Gavin's Blog

package org.apache.lucene.analysis;
 
public final class Token{
 
String termText; // 词项文本（the text of the term）
int startOffset; // Token在源文本中的起始位置（start in source text）
int endOffset; // Token在源文本中的结束位置（end in source text）
String type = "word"; //~ Token的词类型，默认是"word"（lexical type, default is "word"）
//: 附：lexical type:
//: single => ASCII
//: double => non-ASCII
//: word => default
 
private int positionIncrement = 1; // 位移增量，即TokenStream里当前Token与
// 先前某一个Token之间的位移差，默认为1
 
//~ 第一个构造器
public Token(String text, int start, int end){
termText = text;
startOffset = start;
endOffset = end;
}
//~ 第二个构造器
public Token(String text, int start, int end, String type){
termText = text;
startOffset = start;
endOffset = end;
this.type = type;
}
 
//~ 设置位移增量方法
public void setPositionIncrement(int positionIncrement){
if( positionIncrement < 0 )
throw new IllegalArgumentException(
"Increment must be zero or greater: " + positionIncrement);
this.positionIncrement = positionIncrement;
}
 
//~ 获取位移增量
public int getPositionIncrement() { return positionIncrement; }
 
//~ 获取词项文本
public final String termText() { return termText; }
 
//~ 获取Token的起始位置
public final int startOffset() { return startOffset; }
 
//~ 获取Token的结束位置
public final int endOffset() { return endOffset; }
 
//~ 获取Token的词类型
public final String type() { return type; }
 
//~ 重载基类(Object)的toString()方法
public final String toString(){
StringBuffer sb = new StringBuffer();
sb.append("(" + termText + ", " + startOffset + ", " + endOffset);
if( !type.equals("word") )
sb.append(", type=" + type);
if( positionIncrement != 1 )
sb.append(", posIncr=" + positionIncrement);
sb.append(")");
return sb.toString();
}
} ///:~

package org.apache.lucene.analysis;
 
import java.io.IOException;
 
/**
* 一个TokenStream是枚举tokens的序列，或者从文档的字段、查询文本枚举的序列流
*
 
* 这是一个抽象类，具体子类是：
*
 
    * * {@link Tokenizer}, 一个输入参数是一个Reader对象的TokenStream
      *
    * {@link TokenFilter}, 一个输入参数是另外一个TokenStream对象的TokenStream
      * 
 
*/
public abstract class TokenStream {
 
/** 返回流中的下一个Token，或者在遇到EOS时返回null */
public abstract Token next() throws IOException;
 
/** 用这个流发布分配的资源 */
public void close() throws IOException {}
 
} ///:~

package org.apache.lucene.analysis;
 
import java.io.Reader;
import java.io.IOException;
 
/**
* 一个Tokenizer是输入参数是一个Reader的TokenStream。
*
 
* 这是一个抽象类。
*/
public abstract class Tokenizer extends TokenStream {
 
/** Tokenizer的文本源 */
protected Reader input;
 
/** 默认构造器，无参数输入 */
protected Tokenizer() {}
 
/** 输入参数是一个Reader对象引用的构造器，输入的input就是待处理的源文本 */
protected Tokenizer(Reader input) {
this.input = input;
}
 
/** 默认关闭输入Reader对象 */
public void close() throws IOException {
input.close();
}
} ///:~

package org.apache.lucene.analysis;
 
import java.io.IOException;
 
/**
* 一个TokenFilter是一个输入参数是另外一个TokenStream的TokenStream。
*
 
* 这是一个抽象类。
*/
public abstract class TokenFilter extends TokenStream {
 
/** 该Filter的源Tokens */
protected TokenStream input;
 
/**
* 已由TokenFilter(TokenStream)替代
* @deprecated
*/
protected TokenFilter() {}
 
/** 构造器，输入参数是一个待过滤的TokenStream对象 */
protected TokenFilter(TokenStream input) {
this.input = input;
}
 
/** 关闭输入TokenStream */
public void close() throws IOException {
input.close();
}
} ///:~

package org.apache.lucene.analysis;
 
import java.io.Reader;
 
/**
* 一个分析器用于建立用来分析文本的TokenStreams，这样它就可以描述一个从文本中析取索引词项的策略
*
 
* 典型的实现是：首先建立一个Tokenizer，它将打碎字符流，使之从输入时的Reader对象流变成一个个未作
* 进一步加工的Token。然后，一个或者多个TokenFilter可能会被应用于Tokenizer的输出
*
 
* 警告：你必须在你的子类中重载由该类定义的方法中的一个，否则分析器将会陷入无穷循环。
*/
public abstract class Analyzer {
 
/**
* 创建一个TokenStream，该TokenStream标记提供的Reader中的所有文本。
* 默认实现前向tokenStream(Reader)是为了兼容旧版本。
* 重载允许分析器选择基于文档以及/或者字段的策略。
* 为了向后兼容，务必能够处理null字段名。
*/
public TokenStream tokenStream(String fieldName, Reader reader) {
//: 为了实现向后兼容
return tokenStream(reader);
}
 
/**
* 创建一个TokenStream，该TokenStream标记提供的Reader中的所有文本。
* 仅是为了向后兼容而提供。
* @deprecated 用 tokenStream(String, Reader) 替代
* @see #tokenStream(String, Reader)
*/
public TokenStream tokenStream(Reader reader) {
return tokenStream(null, reader);
}
 
/**
* 如果词项已经被加到某个字段，则在索引该字段实例之前调用。
* 这允许定制分析器以便在使用相同字段名的字段实例之间放置一个自动位移增量间隔。
* 默认位移增量间隔值为0.拥有一个0值位移增量间隔和典型的默认token位移增量1,
* 所有一个字段中的词项，包括字段实例间的词项都会连成一串，这允许精确词组查询匹配，
* 而实例则可跨越字段实例边界。
* @param fieldName 被索引的字段名
* @return 位移增量间隔，被加到从{@link #tokenStream(String, Reader)}发出的下一个token。
*/
public int getPositionIncrementGap(String fieldName) {
return 0;
}
} ///:~