elasticsearch插件分析(1)-IK分词器源代码分析（流程）

IK分词器

从毕业开始维护的solr集群到现在接触的es集群，分词器在搜索引擎这个区域内一直都是最常见的东西。分词这种行为存在天生的语言差异，拉丁语系以单词成句，让分词变得非常简单，而中文分词则不然，中文语法复杂而又模糊，不像拉丁语系本身就是用空格把单词分开，所以中文分词也一直是做中文搜索引擎的一个重点。业界有几个开源的中文分词的组件：

IK分词器
ansj分词器
jieba分词器
hanNLP
ictclas分词器（中科院）
其中其实是最后一个中科院的分词器性能和效果会比较好，但是是收费的。分词器本身的算法大同小异，主要的效果都取决于词典的优劣。而词典的收集整理工作是一个相当漫长而又耗时的工作，非旦夕之功。这次的记录主要是想看看IK分词器内部的源码实现流程，下一篇来分析其中的算法原理。

lucene是怎么调用分词器的

分词器分别实现了lucene的这两个接口Analyzer和Tokenizer并实现对应的方法，lucene就可以在后面的逻辑中去调用这个分词器。这种非常易于扩展的代码设计风格也是阅读源码中能够收获到的东西，在以后的系统设计中，在需要或者可能的扩展点，做好代码的抽象工作会使以后的扩展事半功倍。

/**
 * IK分词器，Lucene Analyzer接口实现
 * 兼容Lucene 4.0版本
 */
public final class IKAnalyzer extends Analyzer{
    
    private Configuration configuration;

    /**
     * IK分词器Lucene  Analyzer接口实现类
     * 
     * 默认细粒度切分算法
     */
    public IKAnalyzer(){
    }

    /**
     * IK分词器Lucene Analyzer接口实现类
     * 
     * @param configuration IK配置
     */
    public IKAnalyzer(Configuration configuration){
        super();
        this.configuration = configuration;
    }


    /**
     * 重载Analyzer接口，构造分词组件
     */
    @Override
    protected TokenStreamComponents createComponents(String fieldName) {
        Tokenizer _IKTokenizer = new IKTokenizer(configuration);
        return new TokenStreamComponents(_IKTokenizer);
    }

}

/**
 * IK分词器 Lucene Tokenizer适配器类
 * 兼容Lucene 4.0版本
 */
public final class IKTokenizer extends Tokenizer {
    
    //IK分词器实现
    private IKSegmenter _IKImplement;
    
    //词元文本属性
    private final CharTermAttribute termAtt;
    //词元位移属性
    private final OffsetAttribute offsetAtt;
    //词元分类属性（该属性分类参考org.wltea.analyzer.core.Lexeme中的分类常量）
    private final TypeAttribute typeAtt;
    //记录最后一个词元的结束位置
    private int endPosition;

    private int skippedPositions;

    private PositionIncrementAttribute posIncrAtt;


    /**
     * Lucene 4.0 Tokenizer适配器类构造函数
     */
    public IKTokenizer(Configuration configuration){
        super();
        offsetAtt = addAttribute(OffsetAttribute.class);
        termAtt = addAttribute(CharTermAttribute.class);
        typeAtt = addAttribute(TypeAttribute.class);
        posIncrAtt = addAttribute(PositionIncrementAttribute.class);

        _IKImplement = new IKSegmenter(input,configuration);
    }

    /* (non-Javadoc)
     * @see org.apache.lucene.analysis.TokenStream#incrementToken()
     */
    @Override
    public boolean incrementToken() throws IOException {
        //清除所有的词元属性
        clearAttributes();
        skippedPositions = 0;

        Lexeme nextLexeme = _IKImplement.next();
        if(nextLexeme != null){
            posIncrAtt.setPositionIncrement(skippedPositions +1 );

            //将Lexeme转成Attributes
            //设置词元文本
            termAtt.append(nextLexeme.getLexemeText());
            //设置词元长度
            termAtt.setLength(nextLexeme.getLength());
            //设置词元位移
            offsetAtt.setOffset(correctOffset(nextLexeme.getBeginPosition()), correctOffset(nextLexeme.getEndPosition()));

            //记录分词的最后位置
            endPosition = nextLexeme.getEndPosition();
            //记录词元分类
            typeAtt.setType(nextLexeme.getLexemeTypeString());          
            //返会true告知还有下个词元
            return true;
        }
        //返会false告知词元输出完毕
        return false;
    }
    
    /*
     * (non-Javadoc)
     * @see org.apache.lucene.analysis.Tokenizer#reset(java.io.Reader)
     */
    @Override
    public void reset() throws IOException {
        super.reset();
        _IKImplement.reset(input);
        skippedPositions = 0;
    }   
    
    @Override
    public final void end() throws IOException {
        super.end();
        // set final offset
        int finalOffset = correctOffset(this.endPosition);
        offsetAtt.setOffset(finalOffset, finalOffset);
        posIncrAtt.setPositionIncrement(posIncrAtt.getPositionIncrement() + skippedPositions);
    }
}

也就是说如果我们要自己开发一个新的分词器，也是只需要实现这两个接口即可，其他的可以放我们自己的逻辑，打成jar后即可使用。

从一个demo说起

check下IK的源码到idea后可以开始调试了。IK分词器github地址
我另起炉灶建立了test目录来放单元测试的代码，创建我们的测试类


import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.junit.Test;
import org.wltea.analyzer.cfg.Configuration;
import org.wltea.analyzer.lucene.IKAnalyzer;

import java.io.StringReader;

public class TestIk {

    @Test
    public void test(){
        System.out.println("for the best");
    }

    @Test
    public void testAnalyzer() throws Exception{
        String text = "hello world";

        Configuration configuration = new Configuration(true, false, true);

        //创建分词对象
        Analyzer anal = new IKAnalyzer(configuration);
        StringReader reader = new StringReader(text);
        //分词
        TokenStream ts = anal.tokenStream("", reader);
        CharTermAttribute term = ts.getAttribute(CharTermAttribute.class);
        //遍历分词数据
        ts.reset();
        while(ts.incrementToken()){
            System.out.print(term.toString() + "|");
        }
        reader.close();
        System.out.println();
    }
}

这里我修改了一点源代码来进行本地调试，因为IK分词器的插件形式是依赖es的环境变量的，加载字典的时候会报错，所以我对org.wltea.analyzer.dic.Dictionary做了一些修改

    private Dictionary(Configuration cfg) {
        this.configuration = cfg;
        this.props = new Properties();
//      this.conf_dir = cfg.getEnvironment().configFile().resolve(AnalysisIkPlugin.PLUGIN_NAME);
        this.conf_dir = Paths.get("/Users/huangqq/IdeaProjects/elasticsearch-analysis-ik/config");
        Path configFile = conf_dir.resolve(FILE_NAME);

将资源路径改为绝对路径，然后为org.wltea.analyzer.cfg.Configuration添加新的构造函数

    //测试时使用的构造函数
    public Configuration(boolean use_smart, boolean enable_lowercase, boolean enable_remote_dict){
        this.useSmart = use_smart;
        this.enableLowercase = enable_lowercase;
        this.enableRemoteDict = enable_remote_dict;

        Dictionary.initial(this);
    }

OK，先在上面的单元测试就可以完美运行了。
hello|world|运行结果符合预期，接下来就尝试跟踪进去看看怎么做的分词。

做一次最简单的分词

跟踪代码首先从创建分词流这里进入开始TokenStream ts = anal.tokenStream("", reader);
我跟踪到了IKTokenizer中的这个方法

    @Override
    public boolean incrementToken() throws IOException {
        //清除所有的词元属性
        clearAttributes();
        skippedPositions = 0;

        // Lexeme是IK的分词单元
        Lexeme nextLexeme = _IKImplement.next();
        if(nextLexeme != null){
            posIncrAtt.setPositionIncrement(skippedPositions +1 );

            //将Lexeme转成Attributes
            //设置词元文本
            termAtt.append(nextLexeme.getLexemeText());
            //设置词元长度
            termAtt.setLength(nextLexeme.getLength());
            //设置词元位移
            offsetAtt.setOffset(correctOffset(nextLexeme.getBeginPosition()), correctOffset(nextLexeme.getEndPosition()));

            //记录分词的最后位置
            endPosition = nextLexeme.getEndPosition();
            //记录词元分类
            typeAtt.setType(nextLexeme.getLexemeTypeString());          
            //返会true告知还有下个词元
            return true;
        }
        //返会false告知词元输出完毕
        return false;
    }

代码中很明显这是一个反复获得词单元，这个方法是lucene中Tokenizer的方法，lucene在调用分词器的时候会反复调用这个方法判断是否存在下一个词原。

其实和iterator中的hasNext()方法很像。

这里有个结论，在执行Lexeme nextLexeme = _IKImplement.next();的时候其实已经分词完了，都放在内存里等着拿，并不是每次到这里再去执行，这是IK的逻辑。_IKImplement变量就是分词器的实例。
跟入Lexeme nextLexeme = _IKImplement.next();的代码中，先看下它的几个变量

    //字符窜reader
    private Reader input;
    //分词器上下文
    private AnalyzeContext context;
    //分词处理器列表
    private List segmenters;
    //分词歧义裁决器
    private IKArbitrator arbitrator;
    private  Configuration configuration;

这几个变量决定了这个分词器的“形状”

input：输入进来的整句话，在demo中就是"hello world！"
context：上下文，顾名思义，它记录了句子中每个字的类型，字符，偏移量和指针位置
segmenters：分词器列表，这里IK用这样一个链表来存储各种不同类型的小分词器，凭感觉这里应该是一个可以自定义的拓展点，IK默认提供了CJKSegmenter CN_QuantifierSegmenter LetterSegmenter这三个分词器，demo中的英文主要会用到最后一个LetterSegmenter分词器。tips：cjk是中日韩的意思
arbitrator：裁决器，一时半会说不清楚，但是结果是由它这里输出的

下面是IK自己分词时的next函数

    /**
     * 分词，获取下一个词元
     * @return Lexeme 词元对象
     * @throws java.io.IOException
     */
    public synchronized Lexeme next()throws IOException{
        Lexeme l = null;
        while((l = context.getNextLexeme()) == null ){
            /*
             * 从reader中读取数据，填充buffer
             * 如果reader是分次读入buffer的，那么buffer要  进行移位处理
             * 移位处理上次读入的但未处理的数据
             */
            int available = context.fillBuffer(this.input);
            if(available <= 0){
                //reader已经读完
                context.reset();
                return null;
                
            }else{
                //初始化指针
                context.initCursor();
                do{
                    //遍历子分词器
                    for(ISegmenter segmenter : segmenters){
                        segmenter.analyze(context);
                    }
                    //字符缓冲区接近读完，需要读入新的字符
                    if(context.needRefillBuffer()){
                        break;
                    }
                //向前移动指针
                }while(context.moveCursor());
                //重置子分词器，为下轮循环进行初始化
                for(ISegmenter segmenter : segmenters){
                    segmenter.reset();
                }
            }
            //对分词进行歧义处理
            this.arbitrator.process(context, configuration.isUseSmart());
            //将分词结果输出到结果集，并处理未切分的单个CJK字符
            context.outputToResult();
            //记录本次分词的缓冲区位移
            context.markBufferOffset();         
        }
        return l;
    }

这里可以注意一下这个代码

            //遍历子分词器
                    for(ISegmenter segmenter : segmenters){
                        segmenter.analyze(context);
                    }

意思就是遍历执行3个分词器，我认为这里可能存在优化点，比如我是否需要全部执行所有分词器？有一些比较特殊的分词需求也可以特殊处理。我们已经快接近目标了。

segmenter.analyze(context);

这句代码字面上的意思就是调用分词器去处理上下文，上下文保留什么信息前面提到了，就是整段分词的文本和目前的偏移量cursor，由于我们是做英文分词所以直接看LetterSegmenter的analyze方法

    public void analyze(AnalyzeContext context) {
        boolean bufferLockFlag = false;
        //处理英文字母
        bufferLockFlag = this.processEnglishLetter(context) || bufferLockFlag;
        //处理阿拉伯字母
        bufferLockFlag = this.processArabicLetter(context) || bufferLockFlag;
        //处理混合字母(这个要放最后处理，可以通过QuickSortSet排除重复)
        bufferLockFlag = this.processMixLetter(context) || bufferLockFlag;
        
        //判断是否锁定缓冲区
        if(bufferLockFlag){
            context.lockBuffer(SEGMENTER_NAME);
        }else{
            //对缓冲区解锁
            context.unlockBuffer(SEGMENTER_NAME);
        }
    }

我们处理的是英文字母，跟随debug进入了第一个方法this.processEnglishLetter(context)，然后很自然的发现了具体逻辑的位置

    /**
     * 处理纯英文字母输出
     * @param context
     * @return
     */
    private boolean processEnglishLetter(AnalyzeContext context){
        boolean needLock = false;
        
        if(this.englishStart == -1){//当前的分词器尚未开始处理英文字符  
            if(CharacterUtil.CHAR_ENGLISH == context.getCurrentCharType()){
                //记录起始指针的位置,标明分词器进入处理状态
                this.englishStart = context.getCursor();
                this.englishEnd = this.englishStart;
            }
        }else {//当前的分词器正在处理英文字符 
            if(CharacterUtil.CHAR_ENGLISH == context.getCurrentCharType()){
                //记录当前指针位置为结束位置
                this.englishEnd =  context.getCursor();
            }else{
                //遇到非English字符,输出词元
                Lexeme newLexeme = new Lexeme(context.getBufferOffset() , this.englishStart , this.englishEnd - this.englishStart + 1 , Lexeme.TYPE_ENGLISH);
                context.addLexeme(newLexeme);
                this.englishStart = -1;
                this.englishEnd= -1;
            }
        }
        
        //判断缓冲区是否已经读完
        if(context.isBufferConsumed() && (this.englishStart != -1 && this.englishEnd != -1)){
            //缓冲以读完，输出词元
            Lexeme newLexeme = new Lexeme(context.getBufferOffset() , this.englishStart , this.englishEnd - this.englishStart + 1 , Lexeme.TYPE_ENGLISH);
            context.addLexeme(newLexeme);
            this.englishStart = -1;
            this.englishEnd= -1;
        }   
        
        //判断是否锁定缓冲区
        if(this.englishStart == -1 && this.englishEnd == -1){
            //对缓冲区解锁
            needLock = false;
        }else{
            needLock = true;
        }
        return needLock;            
    }

如果用白话描述IK分词英文的逻辑就是顺序扫描句子，遇到非英语类型字符标记偏移量并记录。并不需要词典，相比中文分词动辄多大的词典，英语真是方便。。

IK在分词过程中保存的是类似这样的偏移[0,5][5,10]标记单词在句子中的位置，在返回的时候才从缓冲区将单词拷贝过来。

那么这一次简单的源码跟踪差不多就这样，其中关于锁定缓冲区的目的和操作还是有点疑惑，目的也是锻炼自己的debug能力和吸收更漂亮的写法，下一篇希望能分析下关于分词的算法。

elasticsearch插件分析(1)-IK分词器源代码分析（流程）

IK分词器

lucene是怎么调用分词器的

从一个demo说起

做一次最简单的分词

你可能感兴趣的:(elasticsearch插件分析(1)-IK分词器源代码分析（流程）)