分类：
2008-06-20 19:45:29
研究Lucene分析器的实现。
Analyzer抽象类
所有的分析器的实现，都是继承自抽象类Analyzer，它的源代码如下所示：
package org.apache.lucene.analysis;
import java.io.Reader;
public abstract class Analyzer {
// 通过Field的名称，和一个Reader对象，创建一个分词流，该方法是抽象方法
public abstract TokenStream tokenStream(String fieldName, Reader reader);
//个人理解，感觉这个方法是在后台分词用的，因为对一个文件建立索引，要构造Field，可能有重复的。
public int getPositionIncrementGap(String fieldName)
{
return 0;
}
}
这里，tokenStream()的作用非常大。它返回一个TokenStream类对象，这个TokenStream类对象应该是已经经过分词器处理过的。
与Analyzer抽象类有关的其他类
TokenStream也是一个抽象类：
package org.apache.lucene.analysis;
import java.io.IOException;
// 对后台选择的待分析处理的文件，一个TokenStream对象包含了对这个文件分词的词条序列
public abstract class TokenStream {
// 返回下一个分词的词条
public abstract Token next() throws IOException;
// 重置一个分词流，恢复到分词工作的开始状态
public void reset() throws IOException {}
// 关闭分词流，停止分词
public void close() throws IOException {}
}
TokenStream类的方法表明，它最基本的是对分词流的状态进行管理。具体地，它如何对分析的对象处理，应该从继承该抽象类的子类的构造来看。
在包org.apache.lucene.analysis下可以看到有两个TokenStream的子类：Tokenizer和TokenFilter，它们还都是抽象类，从这两个抽象类可以看出，是在TokenStream的基础上，按照功能进行分类实现：处理分词、过滤分词。
Tokenizer类在Lucene中定义如下所示：
package org.apache.lucene.analysis;
import java.io.Reader;
import java.io.IOException;
// Tokenizer所处理的输入来源是一个Reader对象
public abstract class Tokenizer extends TokenStream {
// 一个Reader对象作为它的成员
protected Reader input;
protected Tokenizer() {}
protected Tokenizer(Reader input) {
this.input = input;
}
// 关闭输入流
public void close() throws IOException {
input.close();
}
}
接着，看看TokenFilter类的实现，TokenFilter类在Lucene中定义如下所示：
package org.apache.lucene.analysis;
import java.io.IOException;
// TokenFilter是TokenStream的子类，在分词之后进行，起过滤器的作用
public abstract class TokenFilter extends TokenStream {
// 它以一个TokenStream对象作为成员
protected TokenStream input;
protected TokenFilter(TokenStream input) {
this.input = input;
}
public void close() throws IOException {
input.close();
}
}
TokenFilter是可以嵌套Tokenizer的：
当一个Tokenizer对象不为null时，如果需要对其进行过滤，可以构造一个TokenFilter来对分词的词条进行过滤。
同样地，在包org.apache.lucene.analysis下可以找到继承自Tokenizer类的具体实现类。
很明显了，实现Tokenizer类的具体类应该是分词的核心所在了。
对指定文本建立索引之前，应该先构造Field对象，在此基础上再构造Document对象，然后添加到IndexWriter中进行分析处理。在这个分析处理过程中，包含对其进行分词(Tokenizer)，而经过分词处理以后，返回的是一个Token对象(经过分词器得到的词条)，它可能是Field中的一个Term的一部分。
看一看Token类都定义了哪些内容：
package org.apache.lucene.analysis;
import org.apache.lucene.index.Payload;
import org.apache.lucene.index.TermPositions;
public class Token implements Cloneable {
String termText; // 一个词条的内容
int startOffset; // 记录在源文件中第一次出现的位置
int endOffset; // 记录在源文件中最后一次出现的位置t
String type = "word"; // lexical type
Payload payload;
private int positionIncrement = 1; // 位置增量
public Token(String text, int start, int end) { // 初始化一个词条实例时，初始化词条文本内容、开始位置、最后位置
termText = text;
startOffset = start;
endOffset = end;
}
public Token(String text, int start, int end, String typ) { // 初始化一个词条实例时，初始化词条文本内容、开始位置、最后位置、类型
termText = text;
startOffset = start;
endOffset = end;
type = typ;
}
// 设置位移增量的，相对于TokenStream中该Token的前一个，只能设置为1或0
//默认为1，如果为0，则表示多个Term都具有同一个位置。
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; }
// 设置词条(Token)的内容
public void setTermText(String text) {
termText = text;
}
public final String termText() { return termText; }
// 返回该词条(Token)在一个文件(待建立索引的文件)中的起始位置
public final int startOffset() { return startOffset; }
// 返回该词条(Token)在一个文件(待建立索引的文件)中的结束位置
public final int endOffset() { return endOffset; }
// 返回Token's lexical type
public final String type() { return type; }
// Payload是一个元数据(metadata)对象，对每个检索的词条(Term)都设置相应的Payload，存储在index中，通过Payload可以获取一个词条(Term)的详细信息
public void setPayload(Payload payload) {
this.payload = payload;
}
public Payload getPayload() {
return this.payload;
}
// 将一个词条(Token) 的信息，转换成字符串形式，在该字符串中，使用逗号作为每个属性值的间隔符
public 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();
}
// 需要的时候，该Token对象 可以被克隆
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException(e); // shouldn't happen since we implement Cloneable
}
}
}
继承Tokenizer类的直接子类
Tokenizer类的直接子类有：
CharTokenizer(抽象类)、KeywordTokenizer、
org.apache.lucene.analysis.standard.StandardTokenizer、
org.apache.lucene.analysis.cn.ChineseTokenizer、
org.apache.lucene.analysis.ngram.NGramTokenizer、
org.apache.lucene.analysis.ngram.EdgeNGramTokenizer。
其中：
CharTokenizer是一个抽象类，它又有3个子类，如下：
org.apache.lucene.analysis.ru.RussianLetterTokenizer、
.WhitespaceTokenizer、LetterTokenizer(都和CharTokenizer类在包org.apache.lucene.analysis里)。
最后，LowerCaseTokenizer是最终类，又是LetterTokenizer类的子类。
