Gavin's Blog

//: cn.org.gavin.analysis: NGramTokenizer.java
 
package cn.org.gavin.analysis;
 
import java.io.Reader;
 
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.Tokenizer;
 
public final class NGramTokenizer extends Tokenizer {
 
// ~~ 类变量(静态变量)
 
/* buffer缓冲区大小 */
private final static int MAX_WORD_LEN = 127;
 
/*
* ioBuffer缓冲区大小
*
* !注意：该常量大小与n有关，理论上，IO_BUFFER_SIZE应满足 (IO_BUFFER_SIZE + 1) -
* (n-1) >= 0; 即：IO_BUFFER_SIZE >= n-2。 之所以有这个规定，是为了防止“二次修正”的出现。
* 例如：
* 设 String s = "深圳大学是深圳的大学"; IO_BUFFER_SIZE = 4, n = 7 则
* 读取过程：
* ioBuffer ioBufferEx
* 1 深圳大学 深圳大学
* 2 是深圳的 深圳大学是深圳的
* 3 大学圳的 是深圳的大学圳的
* !出错 ^---到这里时,取出ioBufferEx[4]的字符后，bufferIndex = 5，
* 而这时它要读取的是“大学是深圳的大”，刚好够n(=7)个词，
* 要作：bufferIndex -= n-1; 运算，竟得bufferIndex = -1，出错!
* 这是由于该情况要上溯到上上回ioBuffer的内容，要做“二次修正”而出现的。
*
* 注：以上关系根据: next()函数中的语句：c = ioBufferEx[bufferIndex++]; 和
* dealWithCurrChar(char, int)函数中的语句：bufferIndex -= n-1; 得出
*/
private final static int IO_BUFFER_SIZE = 2048;
 
/*
* 用来扩展的ioBuffer缓冲区ioBufferEx的大小 注意： ioBufferEx的大小至少要是ioBuffer的2倍，因为在最差的情况下，
* 查找不到不同类型字符，这时候要把整个上一次读进ioBuffer的内容拷贝进
* ioBufferEx，而新ioBuffer的dataLen也==IO_BUFFER_SIZE，即：
* IO_BUFFER_EX_SIZE = 2 * IO_BUFFER_SIZE;
*
* !注： 可以更加优化一点，就是：IO_BUFFER_EX_SIZE = IO_BUFFER_SIZE + (n-1);
* 因为事实上最多拷贝n-1个字符则可。由于存在
* n <= IO_BUFFER_SIZE + 2
* 和
* n <= MAX_WORD_LEN
* 的关系，则
* IO_BUFFER_EX_SIZE = IO_BUFFER_SIZE + (n-1) <= IO_BUFFER_SIZE + (MAX_WORD_LEN - 1)
* 取：
* IO_BUFFER_EX_SIZE = IO_BUFFER_SIZE + MAX_WORD_LEN
*/
private final static int IO_BUFFER_EX_SIZE = IO_BUFFER_SIZE + MAX_WORD_LEN;
 
// ~~ 实例变量
 
/* 存放标准化(如小写化)后的输入 */
private final char[] buffer = new char[MAX_WORD_LEN];
 
/*
* 存放原始输入，即原始输入的input 这可以说是用来分析输入流的“截断窗口”
*/
private final char[] ioBuffer = new char[IO_BUFFER_SIZE];
 
/*
* 除了保存当前ioBuffer的内容，还要把上一次读进ioBuffer的“尾”部分
* （即ioBuffer中最后一个不同类型字符至结尾部分）添加进当前ioBuffer内容的前面，
* 以便分析器能正确的工作（不因“截断窗口”而将本该连续的字符截断开）
*/
private final char[] ioBufferEx = new char[IO_BUFFER_EX_SIZE];
 
/*
* nGram中的n，默认为1，即作“切字”处理。 n要满足 (n <= IO_BUFFER_SIZE + 2) && n <
* MAX_WORD_LEN， 如果大于或者等于，则按MAX_WORD_LEN来处理
*/
private int n = 1;
 
private int offset = 0, // 词偏移量，用于指明当前哪个位置(在整个流中)的字符被处理
bufferIndex = 0, // io缓冲区ioBuffer下标指针
dataLen = 0, // 数据长度，指输入io缓冲区(ioBuffer)的字符数
dataLenEx = 0; // 扩展的数据长度，指ioBufferEx的字符数
 
private int length; // 多少个字符被存进缓冲区buffer，最终表示为一个token的长度
 
private int start; // token的起始位置
 
// ~~ 构造器
 
/** 建立一个给定输入流、默认n(1)值构造器
public NGramTokenizer(Reader in) {
input = in;
}*/
 
/** 建立一个给定输入 流，给定n值的构造器 */
public NGramTokenizer(Reader in, int n) {
input = in;
 
if (n > 0 && n <= IO_BUFFER_SIZE + 2) {
if (n < MAX_WORD_LEN)
this.n = n;
else
n = MAX_WORD_LEN;
}
}
 
// ~~ 方法
 
// ~ 缓存token中的字符
private final void push(char c) {
if (length == 0) start = offset - 1; // token的起始位置
buffer[length++] = Character.toLowerCase(c); // 小写化字符c后将之缓存起来
}
 
// ~ 将不符合规则的进了buffer的字符弹出来
private final void pop() {
--length;
}
 
// ~ 根据成员字段length决定生成一个token返回还是返回null
private final Token flush() {
if (length > 0) return new Token(new String(buffer, 0, length), start, start + length);
else return null;
}
 
// ~ 将ioBuffer“末尾”部分拷贝到ioBufferEx开头
/*
* 参数：
* start: 要从ioBuffer中拷贝的开始位置
* count: 要从ioBuffer中拷贝到ioBufferEx的字符数
*/
private final void copyToHead(int start, int count) {
for(int i = 0; i < count; ioBufferEx[i] = ioBuffer[start + i], ++i);
}
 
// ~ 将新读进的ioBuffer的内容拷贝到ioBuffer接下来的空白区
/*
* 参数：
* start: 拷贝到ioBufferEx中的开始位置
* count: 要从ioBuffer中拷贝到ioBufferEx的字符数
*/
private final void copyToFollow(int start, int count) {
for (int i = 0; i < count; ioBufferEx[start + i] = ioBuffer[i], ++i);
}
 
// ~ 查找旧ioBuffer中最后一个与旧ioBuffer最后一个字符类型不同的字符的位置pos
/*
* pos位置范围是[-1,0..dataLen-1] 如果返回值为-1，说明ioBuffer中没有与最后一个字符类型不同的字符
* 或者什么也没有(dataLen=0)
*
* 添加语句：dataLen-i <= n-1能提高性能(不用复制那么多)
*/
private final int findLastDiffTypeChar() {
int i = dataLen - 1;
for (; i >= 0 && dataLen-i <= n-1 && getCharType(ioBuffer[i]) == getCharType(ioBuffer[dataLen - 1]); --i);
return i;
}
 
// ~ 判断输入字符是字母或数字、中文字符、还是其它，
/*
* 返回值：
* 0： 数字字符
* 1： 英文字符
* 2： 中文字符
* -1：其它字符
*/
private int getCharType(final char ch) {
 
switch (Character.getType(ch)) {
 
case Character.DECIMAL_DIGIT_NUMBER:
return 0;
 
case Character.LOWERCASE_LETTER:
case Character.UPPERCASE_LETTER:
return 1;
 
case Character.OTHER_LETTER:
return 2;
 
default:
return -1;
}
}
 
// ~ 判断输入的字符是否是这里定义的连字符
/*
* 参数 :
* ch，指定的字符
*
* 返回值：
* boolean值： true : 是连字符
* false : 不是连字符
*/
private boolean isHyphen(final char ch) {
switch (ch) {
case '-':
case '_':
case '\'':
return true;
 
default:
return false;
}
}
 
// ~ 处理当前字符，决定是缓存当前字符还是将该字符之前的作为token返回、或者舍弃，返回null
/*
* 参数：
* CurrChar: 当前分析字符
* CharTypeNo: 表示当前分析字符的类型(用相应的数字表示)
* 0: 数字
* 1: 字母
* 2:中文字符
* -1: 其它字符
*
* 返回值： Token
*/
private Token dealWithCurrChar(char currChar, int currCharTypeNo) {
 
// ~ 如果length > 0，则说明buffer中已有字符，要看已有的字符的类型是否与当前字符类型相同;
// ~ 如果不同，则要看当前字符类型，作相应的处理
if (length > 0) {
 
int gBct = getCharType(buffer[0]);
 
if (currCharTypeNo == -1) {
 
// ~ 如果当前的分隔符是'-'、'_'、','等之一的连字符。
if (isHyphen(currChar)) {
 
// ~ 如果之前buffer的最后一个字符是连字符，则弹出该那个连字符
if (isHyphen(buffer[length - 1])) {
 
pop();
return flush();
}
// ~ 否则
else {
// ~ 如果之前buffer的首字符是英文字符
if (gBct == 1) {
// ~ 暂时保存当前的分割符
push(currChar);
 
// ~ 如果词长大于预定义的最大词长，则无论中文还是英文，都要截断剩余，把前面部分作为token返回
if (length == MAX_WORD_LEN) return flush();
return null;
}
}
}
 
// ~ 如果分隔符之前buffer起来的字符是中文，而且不够n长，
// ~ 则舍弃(设置length = 0)之前buffer起来的字符
if (gBct == 2 && length < n) {
length = 0;
return null;
}
return flush();
 
} else {
// ~ 当前分析字符和前面buffer起来的字符类型不同
if (currCharTypeNo != gBct) {
 
// ~ 由于当前字符现在不可能为连字符，但之前buffer的最后一个字符有可能是连字符
// ~ 如果是，则要弹出(因为类型不一样的两个词不能用连字符连成一个字)
if (isHyphen(buffer[length - 1]))
pop();
 
--bufferIndex;
--offset;
if (gBct == 2 && length < n) {
length = 0;
return null;
}
return flush();
}
// ~ 当前分析字符和前面buffer起来的字符类型相同
else {
 
push(currChar); // 由于类型相同，继续push
 
// ~ 如果词长大于预定义的最大词长，则无论中文还是英文，都要截断剩余，把前面部分作为token返回
if (length == MAX_WORD_LEN) return flush();
 
// ~ 如果当前分析的字符是中文字符且长度已达到n，则要“n处理”
if (currCharTypeNo == 2 && length == n) {
 
// ! 这里容易产生问题
bufferIndex -= n - 1; // 要回滚n-1个字符
offset -= n - 1;
return flush();
}
}
}
}
 
// ~ 到这里的，说明Length == 0，也即buffer中没有形成Token的字符，
// ~ 可能一个新的Token开始(如果currCharTypeNo != -1)
else {
// : 如果当前分析的是“其它字符”(这时length==0)，则直接返回null。
if (currCharTypeNo == -1)
return null; // 返回null让next()函数跳出循环
 
// : 这是新Token的第一个字符！缓存起来
push(currChar);
 
// : 如果词长大于最大词长，则要直接返回(这里不可能，^_^)
if (length == MAX_WORD_LEN)
return flush();
 
// ~ 如果作的是n=1的nGram中文处理，则直接把刚push的字符作为tokn返回
if (currCharTypeNo == 2 && n == 1)
return flush();
}
 
return null; // 返回null让next()函数跳出switch...case子句，继续循环。
}
 
// ~ 返回下一个token
/**
* 返回Token流中的下一个Token，该Token流是在NGramTokenizer工厂中生产的
*/
public final Token next() throws java.io.IOException {
 
length = 0;
start = offset;
 
while (true) {
 
final char c;
Token token = null;
 
offset++;
 
/*
* 如果io缓冲区索引下标大于或等于上一次分析的dataLenEx，
* 则要从Reader(input)流中继续读取数据进ioBuffer。
*/
if (bufferIndex >= dataLenEx) {
 
/* 修正截断窗口 */
 
/* 1、查找旧ioBuffer中最后一个不同字符的位置pos */
final int pos = findLastDiffTypeChar();
 
/* 2、preLen为要从ioBuffer中拷贝到ioBufferEx开头的字符数 */
final int preLen = dataLen - pos - 1;
 
/* 3、从(pos+1)%ioBuffer.length位置起，拷贝preLen个字符到ioBufferEx[0..preLen-1]的区域. */
copyToHead((pos + 1) % ioBuffer.length, preLen);
 
/* 4、读新数据 */
/*
* 将输入流缓存进ioBuffer缓冲区。
* 如果输入流长度大于IO_BUFFER_SIZE，则按流输入顺序，以IO_BUFFER_SIZE为
* 单位分批缓存。每缓存一批，就先处理一批，直到流结束。
*
* 注： 方法public int Reader.read(char cbuf[]) throws IOException;
* 读取一系列字符到数组cbuf[]中，返回值(假如为dataLen)为实际读取的字符的数量， 或者遇到流结束符时返回-1。
*
* 注意：read方法中，新一次读取是从流中上一次读取完的位置+1开始，
* 而且，新读进来的字符只是覆盖cbuf[0..dataLen-1]的区域。
* 如：
* 假设输入流是 s = "深圳大学是深圳的大学"，10个字符 cbuf大小为4，
* 则read方法的读取过程是：
* 第一次："深圳大学"，返回值dataLen = 4；
* 第二次："是深圳的"，返回值dataLen = 4；
* 第三次："大学圳的"，返回值dataLen = 2；
* ^-^--- 这两个字符没有被“冲掉”
* 第四次："大学圳的"，返回值datalen = -1
*/
dataLen = input.read(ioBuffer);
 
/* 5、将新读取的ioBuffer拷贝到ioBufferEx结尾 */
copyToFollow(preLen, dataLen);
 
/* 6、修正dataLenEx */
dataLenEx = preLen + dataLen;
 
/* 7、修正bufferIndex */
bufferIndex = preLen;
}
 
/* 如果读到输入流Reader(input)的结尾 */
if (dataLen == -1) {
 
/* 到流结束时，如果前面buffer起来到字符是中文字符，而且长度不够n，则要舍弃该分词 */
if (getCharType(buffer[0]) == 2 && length < n)
return null;
else
return flush();
}
/* 取出当前要分析的字符，然后索引下标+1 */
else
c = ioBufferEx[bufferIndex++];
 
/* 根据当前要分析字符的字符类型处理 */
switch (Character.getType(c)) {
 
/* 数字都缓存起来，当遇到非数字字符，或超出缓冲区buffer时才作为一个Token返回 */
case Character.DECIMAL_DIGIT_NUMBER:
 
token = dealWithCurrChar(c, 0);
if (token == null)
break;
else
return token;
 
/* 大小写字母都缓存起来，当遇到非英文字母字符，或超出缓冲区buffer时才作为一个Token返回 */
case Character.LOWERCASE_LETTER:
case Character.UPPERCASE_LETTER:
 
token = dealWithCurrChar(c, 1);
if (token == null)
break;
else
return token;
 
/*
* OTHER_LETTER = Lo(Letter,other)，
* 即除了Lu(Letter,uppercase)、Ll(Letter,lowercase)、
* Lt(Letter,titlecase)、Lm(Letter,modifier)外的所有Letter主类的字符
* 根据这里的上下文，也就是汉字字符
*/
case Character.OTHER_LETTER:
 
token = dealWithCurrChar(c, 2);
if (token == null)
break;
else
return token;
 
/*
* 剩下的，也就是无用的分隔符，这些字符是要被丢弃的， 所以就把之前缓存起来的数字、英文或者中文字符串作为token返回。
*
* 注意： 这里必须确保不能让flush()返回null， 因为在这种情况下，如果length <= 0，
* 说明当前字符之前的字符已经作为token返回，或已经被丢弃，需要重新生成token，
* 而该字符要忽略，就要继续拿下一个字符来测试，而不是直接返回null， 因为现在还未必到达流的结束处(该决定权在这里 if
* (dataLen == -1)) 所以，如果dealWithCurrChar(char, int)返回的是null，
* 则要退出该switch...case，继续循环。
*/
default:
token = dealWithCurrChar(c, -1);
if (token != null)
return token;
}
}
}
}

//: cn.org.gavin.analysis: NGramFilter.java
 
package cn.org.gavin.analysis;
 
import java.util.HashMap;
 
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenFilter;
import org.apache.lucene.analysis.TokenStream;
 
public final class NGramFilter extends TokenFilter {
 
/** 停用词数组 */
public final static String[] STOP_WORDS = { "a", "and", "are", "as", "at",
"be", "but", "by", "for", "if", "in", "i", "into", "is", "it",
"no", "not", "of", "on", "or", "s", "such", "t", "that", "the",
"their", "then", "there", "these", "they", "this", "to", "was",
"will", "with", "www" };
 
/** 建立一个从指定TokenStream过滤的过滤构造器 */
public NGramFilter(TokenStream in) {
super(in);
 
stopTable = new HashMap(STOP_WORDS.length);
for (int i = 0; i < STOP_WORDS.length; stopTable.put(STOP_WORDS[i], STOP_WORDS[i]), ++i);
}
 
/* 停用词Map */
private HashMap stopTable;
 
// ~ 返回下一个token
/**
* 返回Token流中的下一个Token，该Token流是在NGramTokenizer工厂中生产的
*/
public final Token next() throws java.io.IOException {
 
// ~ 调用input.next()后则和UnigramTokenizer关联，
// ~ 因为这里的input是一个TokenStream，是指向UnigramTokenizer的。
// ~ 这里的next()方法是UnigramTokenizer中的next()方法。
for (Token token = input.next(); token != null; token = input.next()) {
 
String text = token.termText();
 
// : 如果在HashMap中找不到指定key的value，说明该token的termText不出现在停用词中，
// : 这样也就过滤了停用词
if (stopTable.get(text) == null) {
 
/*
* 因为从NGramTokenizer返回的token的termText属性，其每个字符的类型肯定一样的，
* 所以只需测试第一个字符的类型则可。
*/
switch (Character.getType(text.charAt(0))) {
 
// case Character.DECIMAL_DIGIT_NUMBER:
case Character.LOWERCASE_LETTER:
case Character.UPPERCASE_LETTER:
// : 英语word/token应该大于1个字符
if (text.length() > 1) {
return token;
}
break;
 
case Character.OTHER_LETTER:
// : OTHER_LETTER = LO(Letter,other)，
// : 即除了Lu(Letter,uppercase)、Ll(Letter,lowercase)、
// : Lt(Letter,titlecase)、Lm(Letter,modifier)外的所有Letter主类的字符
// : 一个中文字符(字)作为一个汉语词。
// : 中文词析取操作在这之后进行
return token;
}
}
}
 
return null;
}
}

//: cn.org.gavin.analysis: NGramAnalyzer.java
 
package cn.org.gavin.analysis;
 
import java.io.Reader;
 
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
 
public class NGramAnalyzer extends Analyzer {
 
/**
* 采用默认n(==1)分析
*
* @param fieldName
* 域名
* @param reader
* 输入Reader流
* @return TokenStream
*/
public final TokenStream tokenStream(String fieldName, Reader reader) {
 
return tokenStream(fieldName, reader, 1);
}
 
/**
* 采用指定n分析
*
* @param fieldName
* 域名
* @param reader
* 输入Reader流
* @return TokenStream
*/
public final TokenStream tokenStream(String fieldName, Reader reader, int n) {
 
TokenStream result = new NGramTokenizer(reader, n);
result = new NGramFilter(result);
 
return result;
}
}