lucene&IKAnalyzer入门实例

最近研究了下IKAnalyzer，发现果然很强大，而且说明文档很齐全，上手简单，随便写了个例子。留念。

Ikanalyzer是一个分词工具，lucene是全文检索。

IKAnalyzer 和 IKSimilarity 目前都是直接继承了 Lucene，IKQueryParser是一个新的实现类，如果需要修改可以查看IK的源代码(IK源码)。

用户可以指定数据集使用lucene建立索引，再对这些索引进行查询，lucene可以自动对相似度高的进行排序。

在更新索引时，在实例化IndexWriter是可以提供boolean型的参数，判断是否需要覆盖，还是增加。在更新索引时，找到需要更新的索引，删除之，再添加修改后的索引。

在使用扩展词典的时候，按照说明文档上的说法就是UTF-8的无BOM文档，还有个新手提示说要空一行。其实没那么负责的，打开EditPlus，新建一个无BOM的UTF-8文档，直接一行一个词组添加即可，什么都不用加，也不用空行。

package com.ik;

import java.io.File;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.Term;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.Weight;
import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.wltea.analyzer.IKSegmentation;
import org.wltea.analyzer.Lexeme;
import org.wltea.analyzer.lucene.IKAnalyzer;
import org.wltea.analyzer.lucene.IKQueryParser;
import org.wltea.analyzer.lucene.IKSimilarity;

public class IndexUtil {

	// 索引存储路径
	private final static String INDEX_PATH = "./myindex";

	public void createIndex() {

		// 实例化IKAnalyzer分词器
		Analyzer analyzer = new IKAnalyzer(true);

		IndexWriter iwriter = null;

		try {
			// 创建索引实例
			iwriter = new IndexWriter(FSDirectory.open(new File(INDEX_PATH)),
					analyzer, true, IndexWriter.MaxFieldLength.LIMITED);

			DB db = DB.getInstance();
			db.setDbName("youtee");
			db.open();
			ResultSet rs = db.select("select * from stadium");

			while (rs.next()) {

				// 创建Document
				Document doc = new Document();

				// 添加 field
				doc.add(new Field("sid", rs.getString("sid"), Field.Store.YES,
						Field.Index.ANALYZED));

				doc.add(new Field("name", rs.getString("name"),
						Field.Store.YES, Field.Index.ANALYZED));

				doc.add(new Field("address", rs.getString("address"),
						Field.Store.YES, Field.Index.ANALYZED));

				doc.add(new Field("description", rs.getString("description"),
						Field.Store.YES, Field.Index.ANALYZED));

				iwriter.addDocument(doc);
			}

			// 执行优化
			iwriter.optimize();

			// 关闭indexWriter
			iwriter.close();

		} catch (CorruptIndexException e) {
			e.printStackTrace();
		} catch (LockObtainFailedException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	public List search(String keyword, String field, int returnNum) {
		IndexSearcher isearcher = null;
		List resultList = new ArrayList();

		try {
			// 实例化搜索器
			isearcher = new IndexSearcher(FSDirectory
					.open(new File(INDEX_PATH)), true);

			// 在索引器中使用IKSimilarity相似度评估器
			isearcher.setSimilarity(new IKSimilarity());

			// 使用IKQueryParser查询分析器构造Query对象,fileName->需要搜索的域
			// Query query = IKQueryParser.parse(type, keyword);

			// 不需要使用分词，只对输入的关键字进行查询
			BooleanQuery aBooleanQuery = new BooleanQuery();

			String qParts[] = keyword.split("\\s");
			for (String q : qParts) {
				Query query = new TermQuery(new Term(field, q));
				if (query != null
						&& (!(query instanceof BooleanQuery) || ((BooleanQuery) query)
								.getClauses().length > 0)) {
					aBooleanQuery.add(query, Occur.SHOULD);
				}
			}

			// 搜索相似度最高的n条记录
			TopDocs topDocs = isearcher.search(aBooleanQuery, returnNum);

			returnNum = returnNum <= topDocs.totalHits ? returnNum
					: topDocs.totalHits;
			
			System.out.println("命中：" + topDocs.totalHits);

			// 输出结果
			ScoreDoc[] scoreDocs = topDocs.scoreDocs;

			for (int i = 0; i < returnNum; i++) {
				Document targetDoc = isearcher.doc(scoreDocs[i].doc);
				resultList.add(targetDoc.get(field));

				// System.out.println("内容：" + targetDoc.toString());
			}

		} catch (CorruptIndexException e) {
			e.printStackTrace();
		} catch (LockObtainFailedException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (isearcher != null) {
				try {
					isearcher.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

		return resultList;
	}

	public static void main(String[] args) {
		IndexUtil indexUtil = new IndexUtil();
//		 indexUtil.createIndex();

		ArrayList list = (ArrayList) indexUtil.search("体育 中秋", "address", 100);
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

		
	}

	public void getSplitWord(String keyword) {
		Reader reader = new StringReader(keyword);
		IKSegmentation iks = new IKSegmentation(reader, false);

		try {
			Lexeme lexeme = null;
			do {
				lexeme = iks.next();
				System.out.println(lexeme != null ? lexeme.getLexemeText()
						: "++结束++");
			} while (lexeme != null);

		} catch (IOException e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
	}
}