lucene實現索引的建立與檢索；ikanalyzer實現對中文的分詞；光到這裡已經能夠實現中文的檢索了，但是光這樣還不夠，很多專案中的檢索，應該還能夠對同義詞進行處理，比如索引庫中有“計算機”，“電腦”這樣的詞條，搜尋“筆記本”應該也能把“計算機”，“電腦”這樣的詞條匹配出來，這就涉及到對同義詞的索引檢索了。

兩種方案：

1、在建立索引時，拆詞建索引時就把同義詞考慮進去，將同義詞的詞條加入到索引中，然後檢索時，直接根據輸入拆詞來檢索

2、在建立索引時，不對同義詞進行任何處理，在檢索時，先拆詞，針對拆分出來的詞元（呵呵，自創的稱呼）也即關鍵字，進行同義詞匹配，把匹配好的同義詞拼成一個新的關鍵字，搜尋索引時根據此關鍵字來進行檢索。

個人覺得，方案二更優於方案一，理由如下：在建立索引時，就處理同義詞，一方面會增加索引庫的容量，導致索引效率的降低；其次，如果後期對同義詞進行了擴充套件，比如原來，一個單詞有2個同義詞，後面增加到3個，就需要對索引進行重建了，比較麻煩！

大致程式碼如下：

lucene版本：4.10.3，ikanalyzer：IKAnalyzer2012_hf.jar

lucene每個版本變化貌似蠻大啊，方法之類的都改了好多了，不知道大家有這種感覺沒

建立索引：

/** 
	* MyIndexer.java 
	* V1.0 
	* 2015-1-28-下午8:53:37 
	* Copyright (c) 宜昌***有限公司-版權所有 
	*/
package com.x.same;

import java.io.File;
import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.TextField;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.MergePolicy.OneMerge;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.lionsoul.jcseg.analyzer.JcsegAnalyzer4X;
import org.lionsoul.jcseg.core.JcsegTaskConfig;
import org.wltea.analyzer.lucene.IKAnalyzer;

/** 
 * 此類描述的是：
 * @author yax 2015-1-28 下午8:53:37 
 * @version v1.0 
 */
public class MyIndexer {
	
	public static void createIndex(String indexPath) throws IOException{
		Directory directory = FSDirectory.open(new File(indexPath));
		Analyzer analyzer = new IKAnalyzer();
		
//		IKAnalyzer analyzer = new IKAnalyzer();
		IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
		IndexWriter indexWriter = new IndexWriter(directory, config);
		Document document1 = new Document();
		document1.add(new TextField("title", "thinkpad超極本筆記本中的戰鬥機", Store.YES));
		indexWriter.addDocument(document1);
		
		Document document2 = new Document();
		document2.add(new TextField("title", "使用者可以在這裡配置自己的擴充套件字典", Store.YES));
		indexWriter.addDocument(document2);
		
		Document document3 = new Document();
		document3.add(new TextField("title", "您可以參考分詞器原始碼", Store.YES));
		indexWriter.addDocument(document3);
		
		Document document4 = new Document();
		document4.add(new TextField("title", "第一臺計算機是美國軍方定製，專門為了計算彈道和射擊特性表面而研製的，承擔開發任務的“莫爾小組”由四位科學家和工程師埃克特、莫克利、戈爾斯坦、博克斯組成。1946年這臺計算機主要元器件採用的是電子管。該機使用了1500" +
												"個繼電器，18800個電子管，佔地170m2，重量重達30多噸，耗電150KW，造價48萬美元。這臺計算機每秒能完成5000次加法運算，400次乘法運算，比當時最快的計算工具快300倍，是繼電器計算機的1000倍、手工計算的20萬倍。" + 
												"用今天的標準看，它是那樣的“笨拙”和“低階”，其功能遠不如一隻掌上可程式設計計算器，但它使科學家們從複雜的計算中解脫出來，它的誕生標誌著人類進入了一個嶄新的資訊革命時代。", Store.YES));
		indexWriter.addDocument(document4);
		indexWriter.close();
	}

}
 

/** 
	* AnalyzerUtil.java 
	* V1.0 
	* 2015-1-28-下午8:42:24 
	* Copyright (c) 宜昌**有限公司-版權所有 
	*/
package com.x.same;

import java.io.IOException;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
import org.apache.lucene.analysis.synonym.SynonymFilterFactory;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.util.FilesystemResourceLoader;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.util.Version;
import org.wltea.analyzer.core.IKSegmenter;
import org.wltea.analyzer.core.Lexeme;
import org.wltea.analyzer.lucene.IKAnalyzer;

/** 
 * 此類描述的是：
 * @author yax 2015-1-28 下午8:42:24 
 * @version v1.0 
 */
public class AnalyzerUtil {
	
	/**
	 * 
	     * 此方法描述的是：進行中文拆分
	 */
	public static String analyzeChinese(String input, boolean userSmart) throws IOException{
		StringBuffer sb = new StringBuffer();
        StringReader reader = new StringReader(input.trim());
        IKSegmenter ikSeg = new IKSegmenter(reader, userSmart);// true　用智慧分詞　，false細粒度
        for (Lexeme lexeme = ikSeg.next(); lexeme != null; lexeme = ikSeg.next()) {
        	sb.append(lexeme.getLexemeText()).append(" ");
        }
        return sb.toString();
	}
	
	/**
	 * 
	     * 此方法描述的是：針對上面方法拆分後的片語進行同義詞匹配，返回TokenStream
	 */
	public static TokenStream convertSynonym(String input) throws IOException{
        Version ver = Version.LUCENE_4_10_3;
        Map<String, String> filterArgs = new HashMap<String, String>();
        filterArgs.put("luceneMatchVersion", ver.toString());
        filterArgs.put("synonyms", "config/synonyms.txt");
        filterArgs.put("expand", "true");
        SynonymFilterFactory factory = new SynonymFilterFactory(filterArgs);
        factory.inform(new FilesystemResourceLoader());
        Analyzer whitespaceAnalyzer = new WhitespaceAnalyzer();
        TokenStream ts = factory.create(whitespaceAnalyzer.tokenStream("someField", input));
        return ts;
	}
	
	/**
	 * 
	     * 此方法描述的是：將tokenstream拼成一個特地格式的字串，交給IndexSearcher來處理
	 */
    public static String displayTokens(TokenStream ts) throws IOException
    {
    	StringBuffer sb = new StringBuffer();
        CharTermAttribute termAttr = ts.addAttribute(CharTermAttribute.class);
        ts.reset();
        while (ts.incrementToken())
        {
            String token = termAttr.toString();
            sb.append(token).append(" ");
            System.out.print(token+"|");
//            System.out.print(offsetAttribute.startOffset() + "-" + offsetAttribute.endOffset() + "[" + token + "] ");
        }
        System.out.println();
        ts.end();
        ts.close();
        return sb.toString();
    }
    
    public static void main(String[] args) {
    	String indexPath = "D:\\search\\test";
    	String input = "超級";
    	System.out.println("**********************");
		try {
			String result = displayTokens(convertSynonym(analyzeChinese(input, true)));
//			MyIndexer.createIndex(indexPath);
			List<String> docs = MySearcher.searchIndex(result, indexPath);
			for (String string : docs) {
				System.out.println(string);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}
 

/** 
	* MySearcher.java 
	* V1.0 
	* 2015-1-28-下午9:02:32 
	* Copyright (c) 宜昌**有限公司-版權所有 
	*/
package com.x.same;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.DirectoryReader;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.queryparser.classic.ParseException;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.FSDirectory;
import org.lionsoul.jcseg.analyzer.JcsegAnalyzer4X;
import org.lionsoul.jcseg.core.JcsegTaskConfig;

/** 
 * 此類描述的是：
 * @author yax 2015-1-28 下午9:02:32 
 * @version v1.0 
 */
public class MySearcher {
	
	public static List<String> searchIndex(String keyword, String indexPath) throws IOException, ParseException{
		List<String> result = new ArrayList<>();
		IndexSearcher indexSearcher = null;
		IndexReader indexReader = DirectoryReader.open(FSDirectory.open(new File(indexPath)));
		indexSearcher = new IndexSearcher(indexReader);
		Analyzer analyzer = new WhitespaceAnalyzer();
		
		QueryParser queryParser = new QueryParser("title", analyzer);
		Query query = queryParser.parse(keyword);
		TopDocs td = indexSearcher.search(query, 10);
		for (int i = 0; i < td.totalHits; i++) {
			Document document = indexSearcher.doc(td.scoreDocs[i].doc);
			result.add(document.get("title"));
		}
		return result;
	}

}

同義詞檔案格式：

我,俺,hankcs
似,is,are => 是
好人,好心人,熱心人
超極本,計算機,電腦

發現了一種更簡潔的做法，即把關鍵詞分詞，轉換同義詞，合併的過程交給一個自定義Analyzer去處理，程式碼如下：

    public class IKSynonymsAnalyzer extends Analyzer {
    @Override
    protected TokenStreamComponents createComponents(String arg0, Reader arg1) {
    Tokenizer token=new IKTokenizer(arg1, false);//開啟智慧切詞
    Map paramsMap=new HashMap();
    paramsMap.put("luceneMatchVersion", "LUCENE_43");
    paramsMap.put("synonyms", "C:\\同義詞\\synonyms.txt");
    SynonymFilterFactory factory=new SynonymFilterFactory(paramsMap);
    FilesystemResourceLoader loader = new FilesystemResourceLoader();
    try {
    factory.inform(loader);
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    return new TokenStreamComponents(token, factory.create(token));
    }

    }

程式碼僅做參考，歡迎大家交流討論指正。

轉載請註明出處