IndexAnalysis是ansj分詞工具針對搜尋引擎提供的一種分詞方式，會進行最細粒度的分詞，例如下面這句話：

看熱鬧：2014年度足壇主教練收入榜公佈，溫格是真·阿森納代言人啊~

這句話會被拆分成：[看熱鬧/v, ：/w, 2014/m, 年度/n, 足壇/n, 主教練/n, 收入/n, 榜/n, 公佈/v, ，/w, 溫格/nr, 是/v, 真/d, ·/w, 阿森納/nr, 代言人/n, 啊/y, ~, , 熱鬧, 主教, 教練]

也就是“看熱鬧”和“主教練”這兩個詞會進一步細分出三個詞：熱鬧, 主教, 教練

這樣分其實並沒有問題，問題就出在這三個詞放置的位置，細分出來的詞被放置到了末尾！原始碼中是這樣寫的：

/**
			 * 檢索的分詞
			 * 
			 * @return
			 */
			private List<Term> result() {


				String temp = null;

				List<Term> result = new LinkedList<Term>();
				int length = graph.terms.length - 1;
				for (int i = 0; i < length; i++) {
					if (graph.terms[i] != null) {
						result.add(graph.terms[i]);
					}
				}

				LinkedList<Term> last = new LinkedList<Term>() ;
				for (Term term : result) {
					if (term.getName().length() >= 3) {
						GetWordsImpl gwi = new GetWordsImpl(term.getName());
						while ((temp = gwi.allWords()) != null) {
							if (temp.length() < term.getName().length() && temp.length()>1) {
								last.add(new Term(temp, gwi.offe + term.getOffe(), TermNatures.NULL));
							}
						}
					}
				}

				result.addAll(last) ;
				
				setRealName(graph, result);
				return result;
			}
 

先遍歷所有的term，新增到result列表中去，然後再對result中的term看能否進一步分詞，能的話，再細分，最終將細分後的結果新增到result的末尾。

當我們搜尋“阿森納教練”並且需要進行fast vector highlight時，就會報錯，我們寫個demo來測試一下：

package org.ansj.ansj_lucene4_plug;

import org.ansj.lucene4.AnsjAnalysis;
import org.ansj.lucene4.AnsjIndexAnalysis;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.TextField;
import org.apache.lucene.index.*;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.vectorhighlight.FastVectorHighlighter;
import org.apache.lucene.search.vectorhighlight.SimpleFragListBuilder;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;
import org.elasticsearch.search.highlight.vectorhighlight.SourceSimpleFragmentsBuilder;

import java.util.HashSet;

/**
 * Created by xiaojun on 2016/1/11.
 */
public class Test3 {
    public static void main(String[] args) throws Exception {
        HashSet<String> hs = new HashSet<String>();
        hs.add("的");
        Analyzer analyzer = new AnsjIndexAnalysis(hs, false);
        Directory directory = null;
        IndexWriter iwriter = null;
//        String text = "我發現帖子系統有個BUG啊，怎麼解決？怎麼破";
        String text = "看熱鬧：2014年度足壇主教練收入榜公佈，溫格是真·阿森納代言人啊~";
//        String text = "我去過白楊樹林！";

//        UserDefineLibrary.insertWord("阿森納", "n", 1000);
//        UserDefineLibrary.insertWord("系統", "n", 1000);

        IndexWriterConfig ic = new IndexWriterConfig(Version.LUCENE_4_10_4, analyzer);


        directory = new RAMDirectory();
        iwriter = new IndexWriter(directory, ic);

        Document document = new Document();
        document.add(new TextField("_id", "1", Field.Store.YES));
        document.add(new Field("content", text, Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS));
        iwriter.addDocument(document);
//        iwriter.commit();
//        iwriter.close();
        IndexReader reader = DirectoryReader.open(iwriter, true);
        IndexSearcher searcher = new IndexSearcher(reader);
        FastVectorHighlighter highlighter = new FastVectorHighlighter();
        TopDocs topDocs = searcher.search(new TermQuery(new Term("_id", "1")), 1);
//
////        assertThat(topDocs.totalHits, equalTo(1));
//
//
//        String fragment = highlighter.getBestFragment(highlighter.getFieldQuery(new TermQuery(new Term("content", "阿森納"))),
//                reader, topDocs.scoreDocs[0].doc, "content", 30);
////        assertThat(fragment, notNullValue());
////        assertThat(fragment, equalTo("the big <b>bad</b> dog"));
//        System.out.println(fragment);


        Analyzer queryAnalyzer = new AnsjAnalysis(hs, false);

        QueryParser tq = new QueryParser("content", queryAnalyzer);
        String queryStr = "阿森納教練";

        Query query = tq.createBooleanQuery("content", queryStr);
        System.out.println("query:" + query);
        TopDocs hits = searcher.search(query, 5);
        System.out.println(queryStr + ":共找到" + hits.totalHits + "條記錄!");

        String fragment2 = highlighter.getBestFragment(highlighter.getFieldQuery(query),
                reader, topDocs.scoreDocs[0].doc, "content", 30);
//        assertThat(fragment, notNullValue());
//        assertThat(fragment, equalTo("the big <b>bad</b> dog"));
        System.out.println(fragment2);
    }
}
 

執行就會報以下錯誤：

Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: -16
	at java.lang.String.substring(String.java:1911)
	at org.apache.lucene.search.vectorhighlight.BaseFragmentsBuilder.makeFragment(BaseFragmentsBuilder.java:178)
	at org.apache.lucene.search.vectorhighlight.BaseFragmentsBuilder.createFragments(BaseFragmentsBuilder.java:144)
	at org.apache.lucene.search.vectorhighlight.BaseFragmentsBuilder.createFragment(BaseFragmentsBuilder.java:111)
	at org.apache.lucene.search.vectorhighlight.BaseFragmentsBuilder.createFragment(BaseFragmentsBuilder.java:95)
	at org.apache.lucene.search.vectorhighlight.FastVectorHighlighter.getBestFragment(FastVectorHighlighter.java:116)
	at org.ansj.ansj_lucene4_plug.Test3.main(Test3.java:78)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:606)
	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)
 

找到報錯的方法：

  protected String makeFragment( StringBuilder buffer, int[] index, Field[] values, WeightedFragInfo fragInfo,
      String[] preTags, String[] postTags, Encoder encoder ){
    StringBuilder fragment = new StringBuilder();
    final int s = fragInfo.getStartOffset();
    int[] modifiedStartOffset = { s };
    String src = getFragmentSourceMSO( buffer, index, values, s, fragInfo.getEndOffset(), modifiedStartOffset );
    int srcIndex = 0;
    for( SubInfo subInfo : fragInfo.getSubInfos() ){
      for( Toffs to : subInfo.getTermsOffsets() ){
        fragment
          .append( encoder.encodeText( src.substring( srcIndex, to.getStartOffset() - modifiedStartOffset[0] ) ) )
          .append( getPreTag( preTags, subInfo.getSeqnum() ) )
          .append( encoder.encodeText( src.substring( to.getStartOffset() - modifiedStartOffset[0], to.getEndOffset() - modifiedStartOffset[0] ) ) )
          .append( getPostTag( postTags, subInfo.getSeqnum() ) );
        srcIndex = to.getEndOffset() - modifiedStartOffset[0];
      }
    }
    fragment.append( encoder.encodeText( src.substring( srcIndex ) ) );
    return fragment.toString();
  }

標高亮的邏輯是這樣的:

剛開始執行的時候srcIndex=0，首先找到第一個命中的詞：“阿森納”，這裡解釋一下為什麼"阿森納"是第一個詞而“教練”不是第一個詞，明明在原句中教練這兩個字出現在阿森納之前？上面我們隊IndexAnalysis的原始碼已經分析過了，”教練“作為”主教練“的細分詞，被放置在了詞向量的末尾。所以阿森納的position會比教練的position要靠前。

從然後第一個高亮詞前面的片段就是從0到這個詞的起始偏移位置，阿森納的起止位置為：[26,29],也就是0~26，然後下一次迴圈的時候srcIndex會變為29,即從29開始再找高亮片段，然後第二個詞"教練"的起止偏移為：[13,16],src.substring(29,13)顯然會導致異常，substring方法引數指定的是擷取字串的起止位置，顯然第二個引數不能小於第一個引數，不然就會報索引越界的異常。

解釋了這麼多，其實只要保證迴圈的時候先找”教練“這個詞，再找”阿森納這個詞“那就沒有問題了，也就是跟fragInfo.getSubInfos()這個list中詞的順序有關,而這個list中詞的順序最終與Term的position有關，具體可以看到FieldTermStack這個類的構造方法：

public FieldTermStack( IndexReader reader, int docId, String fieldName, final FieldQuery fieldQuery ) throws IOException {
    this.fieldName = fieldName;
    
    Set<String> termSet = fieldQuery.getTermSet( fieldName );
    // just return to make null snippet if un-matched fieldName specified when fieldMatch == true
    if( termSet == null ) return;

    final Fields vectors = reader.getTermVectors(docId);
    if (vectors == null) {
      // null snippet
      return;
    }

    final Terms vector = vectors.terms(fieldName);
    if (vector == null) {
      // null snippet
      return;
    }

    final CharsRefBuilder spare = new CharsRefBuilder();
    final TermsEnum termsEnum = vector.iterator(null);
    DocsAndPositionsEnum dpEnum = null;
    BytesRef text;
    
    int numDocs = reader.maxDoc();
    
    while ((text = termsEnum.next()) != null) {
      spare.copyUTF8Bytes(text);
      final String term = spare.toString();
      if (!termSet.contains(term)) {
        continue;
      }
      dpEnum = termsEnum.docsAndPositions(null, dpEnum);
      if (dpEnum == null) {
        // null snippet
        return;
      }

      dpEnum.nextDoc();
      
      // For weight look here: http://lucene.apache.org/core/3_6_0/api/core/org/apache/lucene/search/DefaultSimilarity.html
      final float weight = ( float ) ( Math.log( numDocs / ( double ) ( reader.docFreq( new Term(fieldName, text) ) + 1 ) ) + 1.0 );

      final int freq = dpEnum.freq();
      
      for(int i = 0;i < freq;i++) {
        int pos = dpEnum.nextPosition();
        if (dpEnum.startOffset() < 0) {
          return; // no offsets, null snippet
        }
        termList.add( new TermInfo( term, dpEnum.startOffset(), dpEnum.endOffset(), pos, weight ) );
      }
    }
    
    // sort by position
    Collections.sort(termList);
    
    // now look for dups at the same position, linking them together
    int currentPos = -1;
    TermInfo previous = null;
    TermInfo first = null;
    Iterator<TermInfo> iterator = termList.iterator();
    while (iterator.hasNext()) {
      TermInfo current = iterator.next();
      if (current.position == currentPos) {
        assert previous != null;
        previous.setNext(current);
        previous = current;
        iterator.remove();
      } else {
        if (previous != null) {
          previous.setNext(first);
        }
        previous = first = current;
        currentPos = current.position;
      }
    }
    if (previous != null) {
      previous.setNext(first);
    }
  }

其中有一句比較關鍵的程式碼：

 // sort by position
    Collections.sort(termList);

也就是termList會按position從小到大排序。

說到這裡問題已經闡述的很清楚了，我們最終的目的就是要改變“教練”這個詞出現的位置，也就是讓細分詞直接緊跟著出現在原始詞的後面，問題就能解決了。

於是可以對IndexAnalysis的result()方法進行如下修改：

			/**
			 * 檢索的分詞
			 * 
			 * @return
			 */
			private List<Term> result() {


				String temp = null;
				List<Term> result = new LinkedList<Term>();
				int length = graph.terms.length - 1;
				for (int i = 0; i < length; i++) {
					if (graph.terms[i] != null) {
						Term term = graph.terms[i];
						result.add(term);
						if (term.getName().length() >= 3 && !Arrays.asList(new String[]{"nr","nt","nrf","nnt","nsf","adv","nz"}).contains(term.getNatureStr())) {
							GetWordsImpl gwi = new GetWordsImpl(term.getName());
							while ((temp = gwi.allWords()) != null) {
								if (temp.length() < term.getName().length() && temp.length()>1) {
									result.add(new Term(temp, gwi.offe + term.getOffe(), TermNatures.NULL));
								}
							}
						}
					}
				}
				
				setRealName(graph, result);
				return result;
			}

即在遍歷每個詞的同時緊接著在判斷該詞是否需要細分，這裡對一些詞性做了一些限制，在原始碼裡緊緊是判斷了term數量是否大於3，我覺得一些專有名詞其實是不需要再細分了，專有名詞細分了反而搜尋質量變差。

進行如上修改之後，再從新執行以下分詞，結果變成如下：

[看熱鬧/v, 熱鬧, ：/w, 2014/m, 年度/n, 足壇/n, 主教練/n, 主教, 教練, 收入/n, 榜/n, 公佈/v, ，/w, 溫格/nrf, 是/v, 真/d, ·/w, 阿森納/nz, 代言人/n, 啊/y, ~, ]

可以看到“主教”和“教練”這兩個詞緊跟著“主教練”這個詞後面出現了。

我們再執行上面的高亮demo，已經可以得到如下正確的結果了：

看熱鬧：2014年度足壇主<b>教練</b>收入榜公佈，溫格是真·<b>阿森納</b>代言人啊~