1. //Tokenizer  
2. public abstract class Tokenizer extends TokenStream {  
3.      /**待分词的文本输入流 */  
4.      protected Reader input;  
5.      /**无参构造器 */  
6.      protected Tokenizer() {  
7.      }  
8.      /** 带输入流的构造器*/  
9.      protected Tokenizer(Reader input) {  
10.           this.input = CharReader.get(input);  
11.      }  
12.      /** 关闭输入流 */  
13.      @Override  
14.      public void close() throws IOException {  
15.          input.close();  
16.      }  
17. } 

1. //TokenFilter  
2. public abstract class TokenFilter extends TokenStream {  
3.   /** 待过滤的词元流 */  
4.   protected final TokenStream input;  
5.   /** 构造器 */  
6.   protected TokenFilter(TokenStream input) {  
7.        super(input);  
8.         this.input = input;  
9.   }  
10.   /** 关闭流 */  
11.   @Override  
12.   public void close() throws IOException {  
13.         input.close();  
14.   }  
15. }  

相对于老版本的Lucene分词器，3.0版本的Lucene的Tokenizer多了一种构造器。

1. protected Tokenizer(AttributeSource source)   

二、Lucene的标准分析器——StandardAnalyzer

    org.apache.lucene.analysis.standard 包含了Lucene的标准分析器(StandardAnalyzer)，它由标准分词器(StandardTokenizer)和标准过滤器(StandardFilter)构成。都只能处理英文。

StandardAnalyzer 部分源代码如下：

1. public class StandardAnalyzer extends Analyzer {  
2.         /**英语停用词表*/  
3.         public static final Set STOP_WORDS_SET = StopAnalyzer.ENGLISH_STOP_WORDS_SET;  
4.         /**若干构造器*/  
5.         public StandardAnalyzer(Version matchVersion) {  
6.            this(matchVersion, STOP_WORDS_SET);  
7.         }  
8.         /**分词并进行标准过滤、大小写过滤和停用词过滤*/  
9.         @Override  
10.         public TokenStream tokenStream(String fieldName, Reader reader) {  
11.                  //构造一个标准分词器，并进行分词  
12.                  StandardTokenizer tokenStream = new StandardTokenizer(matchVersion, reader);  
13.                  //设置分词后词元流的最大长度  
14.                  tokenStream.setMaxTokenLength(maxTokenLength);  
15.                  //进行标准过滤  
16.                  TokenStream result = new StandardFilter(tokenStream);  
17.                  //进行大小写过滤  
18.                  result = new LowerCaseFilter(result);  
19.                  //进行停用词过滤  
20.                  result = new StopFilter(enableStopPositionIncrements, result, stopSet);  
21.                  return result;  
22.        }  
23.   
24. }

标准分词器：StandardTokenizer

1. public final class StandardTokenizer extends Tokenizer {  
2.   
3.        /**JFlex扫描器*/  
4.        private final StandardTokenizerImpl scanner;  
5.       /**从输入流字串中解析出的词元的各种信息*/  
6.        private TermAttribute termAtt; //词元的内容，如"tearcher"  "xy12@yahoo.com"  "1421"  
7.        private OffsetAttribute offsetAtt;  //词元的首字母和尾字母在文本中的位置信息  
8.        private PositionIncrementAttribute posIncrAtt;  //当前词元在TokenStream中相对于前一个token的位置，用于短语搜索  
9.        private TypeAttribute typeAtt;  //词元所属的类别,，如、、  
10.   
11.        //标准分词器构造器，并用JFlex对象解析输入流  
12.        public StandardTokenizer(Version matchVersion, Reader input) {  
13.               super();  
14.               this.scanner = new StandardTokenizerImpl(input);  
15.               init(input, matchVersion);  
16.        }  
17.         //初始化词元的属性信息  
18.        private void init(Reader input, Version matchVersion) {  
19.            if (matchVersion.onOrAfter(Version.LUCENE_24)) {  
20.                   replaceInvalidAcronym = true;  
21.            } else {  
22.                  replaceInvalidAcronym = false;  
23.            }  
24.             this.input = input;      
25.             termAtt = addAttribute(TermAttribute.class);  
26.             offsetAtt = addAttribute(OffsetAttribute.class);  
27.             posIncrAtt = addAttribute(PositionIncrementAttribute.class);  
28.             typeAtt = addAttribute(TypeAttribute.class);  
29.        }  
30.   
31.        //将JFlex扫描后的匹配结果按词元的不同属性存储  
32.        //比如当前词元是I'm  则将I'm存储到TermAttribute中，而则存放到TypeAttribute中。  
33.        @Override  
34.        public final boolean incrementToken() throws IOException {  
35.             clearAttributes();  
36.             int posIncr = 1;  
37.   
38.             while(true) {  
39.                  //通过JFlex扫描器scanner取得与规则相匹配的当前词元，否则返回-1  
40.                  int tokenType = scanner.getNextToken();  
41.   
42.                  if (tokenType == StandardTokenizerImpl.YYEOF) {  
43.                      return false;  
44.                  }  
45.                  //scanner.yylength() 是当前词元的长度，maxTokenLength是词元允许的最大长度，值为255      
46.                  if (scanner.yylength() <= maxTokenLength) {  
47.                        posIncrAtt.setPositionIncrement(posIncr);  
48.                        //将当前词元字串储记录在TermAttribute属性中，比如“I'm”  
49.                        scanner.getText(termAtt);  
50.                        //得到当前词元首字母在整个文本内容中的位置  
51.                        final int start = scanner.yychar();               
52.                        //将当前词元的位置信息(开始位置，结束位置)记录在OffsetAttribute属性中        
53.                        offsetAtt.setOffset(correctOffset(start), correctOffset(start+termAtt.termLength()));  
54.                        //确定当前词元的类别信息，并记录在TypeAttribute属性中  
55.                        if (tokenType == StandardTokenizerImpl.ACRONYM_DEP) {  
56.                        if (replaceInvalidAcronym) {  
57.                            typeAtt.setType(StandardTokenizerImpl.TOKEN_TYPES[StandardTokenizerImpl.HOST]);  
58.                            termAtt.setTermLength(termAtt.termLength() - 1);   
59.                        } else {  
60.                            typeAtt.setType(StandardTokenizerImpl.TOKEN_TYPES[StandardTokenizerImpl.ACRONYM]);  
61.                        }  
62.                   } else {  
63.                        typeAtt.setType(StandardTokenizerImpl.TOKEN_TYPES[tokenType]);  
64.                   }  
65.                   return true;  
66.              } else  
67.                  posIncr++;  
68.             }  
69.        }  
70.  }