lucene 学习笔记

package com.test.lucene;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.Version;
import org.junit.Test;

public class Main {

private static final Version version = Version.LUCENE_35;
private static final Analyzer analyzer = new StandardAnalyzer(version);
private static final File indexDir = new File("E:/lucene/index");
private static final File dataDir = new File("E:/lucene/data");

/**
* 建立索引
*
* @throws Exception
*/
public void index() throws Exception {
IndexWriter writer = getIndexWriter();
File[] files = dataDir.listFiles();
for (File file : files) {
if (file.isDirectory()) {// 略过文件夹
continue;
}
Document doc = getDoc(file);
writer.addDocument(doc);
}
writer.close();
}

private IndexWriter getIndexWriter() {
IndexWriterConfig iwc = null;
IndexWriter writer = null;
try {
Directory dir = null;
dir = FSDirectory.open(indexDir);// 索引文件保存在文件系统上， 存在io操作， 速度较慢
dir = new RAMDirectory();// 放在内存里， 速度快， 没有io操作， 但是程序一退出， 就没有了

// 可以结合以上两个优点：索引存放在文件系统上， 程序启动时， 把索引库读到内存，
// 程序退出时， 把经过增删改的索引库保存会硬盘上
// 1.启动时读入

writer = new IndexWriter(dir, iwc);
} catch (Exception e) {
e.printStackTrace();
}
return writer;
}

/**
* 测试两种存放方式：
*
* <pre>
* 1.启动时从filesystem加载索引到ram
* 2.对ram中的索引进行增删改查
* 3.退出时保存：从ram到filesystem
* </pre>
*/
@Test
public void test() {
IndexWriterConfig iwc1 = null;
IndexWriterConfig iwc2 = null;
IndexWriter fsWriter = null;
IndexWriter ramWriter = null;
// indexWriterConfig 不能用两次： the object cannot be set twice!
iwc1 = new IndexWriterConfig(version, analyzer);
iwc1.setOpenMode(OpenMode.CREATE_OR_APPEND);// ram中，添加文档，使用创建或追加
iwc2 = new IndexWriterConfig(version, analyzer);
iwc2.setOpenMode(OpenMode.CREATE);// 因为是从ram中写入， ram中保存的是最新的， 所以直接创建
try {
Directory fsDir = FSDirectory.open(indexDir);
Directory ramDir = new RAMDirectory(fsDir);// 从systemfile加载
ramWriter = new IndexWriter(ramDir, iwc2);// 操作内存索引的writer
ramWriter.addDocument(getDoc(new File("E:/lucene/data/test")));// 直接添加，方便点
ramWriter.commit();
ramWriter.close();// 关闭后才能把ram中最新的索引写回systemfile

fsWriter = new IndexWriter(fsDir, iwc1);// 操作硬盘索引的writer
fsWriter.addIndexes(ramDir);
fsWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}

private Document getDoc(File file) {
Document doc = new Document();
/**
* 网页搜索时有：url地址， 标题， 内容等， 而通常不需要通过url进行搜索， 但是url还是得存起来，
* 这时需要用Field.Store.YES， Field.Index.NOT_ANALYZED <br/>
* 索引
*
* <pre>
* +--+不索引
* +--+索引
* 		+---+分词
* 		+---+不分词
* </pre>
*/

Field name = new Field("name", file.getName(), Field.Store.YES,
Field.Index.ANALYZED);// 索引
Field size = new Field("size", String.valueOf(file.length()),
Field.Store.YES, Field.Index.NOT_ANALYZED);
Field content = new Field("content", readFile(file), Field.Store.YES,
Field.Index.ANALYZED);
doc.add(name);
doc.add(size);
doc.add(content);
return doc;
}

private String readFile(File file) {
StringBuffer content = new StringBuffer();
String line = "";
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(
new FileInputStream(file)));
while ((line = reader.readLine()) != null) {
content.append(line).append("\n");
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return content.toString();
}

private Query getQuery(String fieldName, String key) throws Exception {// 单个field中索引
QueryParser parser = new QueryParser(version, fieldName, analyzer);
return parser.parse(key);
}

private Query getQuery(String[] fields, String key) throws Exception {// 多个field中检索
QueryParser parser = new MultiFieldQueryParser(version, fields,
analyzer);
return parser.parse(key);
}

@Test
public void search() throws Exception {
IndexReader reader = IndexReader.open(FSDirectory.open(indexDir));// 存放在文件系统
// IndexReader reader = IndexReader.open(new RAMDirectory());// 存放在内存
IndexSearcher searcher = new IndexSearcher(reader);

Query query = getQuery(new String[] { "name", "content" }, "test");
TopDocs hits = searcher.search(query, 100);// 100 是搜索最大记录数， 不是分页用的， 搞错了
int total = hits.totalHits;
if (total > 0) {
System.out.println("共找到" + total + "条记录");
} else {
System.out.println("没有找到记录");
}
ScoreDoc[] scoreDocs = hits.scoreDocs;
int start = 0;
int end = hits.totalHits;
// for (ScoreDoc doc : hits.scoreDocs) {//这样不便分页
for (int i = start; i < end; i++) {// 可以分页
int sn = scoreDocs[i].doc;// 相当于获取主键，
Document document = searcher.doc(sn);// 根据主键获取文档
print(document);
}
searcher.close();
}

private void print(Document doc) {
System.out
.println("--------------------------------------------------");
System.out.println("name   :" + doc.get("name"));
System.out.println("size   :" + doc.get("size"));
System.out.println("content:\n" + doc.get("content"));
}
}