lucene练习2

public class IndexDao {
String indexPath = "E:\\luceneIndex";
// Analyzer analyzer = new StandardAnalyzer();
Analyzer analyzer = new MMAnalyzer();// 词库分词
/**
* 添加/创建索引
*
* @param doc
*/
public void save(Document doc) {
IndexWriter indexWriter = null;
try {
indexWriter = new IndexWriter(indexPath, analyzer, MaxFieldLength.LIMITED);
indexWriter.addDocument(doc);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
try {
indexWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* Term是搜索的最小单位，代表某个 Field 中的一个关键词，如：<title, lucene>
*
* new Term( "title", "lucene" );
*
* new Term( "id", "5" );
*
* new Term( "id", UUID );
*
* @param term
*/
public void delete(Term term) {
IndexWriter indexWriter = null;
try {
indexWriter = new IndexWriter(indexPath, analyzer, MaxFieldLength.LIMITED);
indexWriter.deleteDocuments(term);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
try {
indexWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 更新索引
*
* <pre>
* indexWriter.deleteDocuments(term);
* indexWriter.addDocument(doc);
* </pre>
*
* @param term
* @param doc
*/
public void update(Term term, Document doc) {
IndexWriter indexWriter = null;
try {
indexWriter = new IndexWriter(indexPath, analyzer, MaxFieldLength.LIMITED);
indexWriter.updateDocument(term, doc);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
try {
indexWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* <pre>
* totalPage = recordCount / pageSize;
* if (recordCount % pageSize &gt; 0)
* totalPage++;
* </pre>
* @param queryString
* @param firstResult
* @param maxResults
* @return
*/
public QueryResult search(String queryString, int firstResult, int maxResults) {
try {
// 1，把要搜索的文本解析为 Query
String[] fields = { "name", "content" };
Map<String, Float> boosts = new HashMap<String, Float>();
boosts.put("name", 3f);
// boosts.put("content", 1.0f); 默认为1.0f
QueryParser queryParser = new MultiFieldQueryParser(fields, analyzer, boosts);
Query query = queryParser.parse(queryString);

return search(query, firstResult, maxResults);
} catch (Exception e) {
throw new RuntimeException(e);
}
}

public QueryResult search(Query query, int firstResult, int maxResults) {
IndexSearcher indexSearcher = null;

try {
// 2，进行查询
indexSearcher = new IndexSearcher(indexPath);
Filter filter = new RangeFilter("size", NumberTools.longToString(200)
, NumberTools.longToString(1000), true, true);
// ========== 排序
Sort sort = new Sort();
sort.setSort(new SortField("size")); // 默认为升序
// sort.setSort(new SortField("size", true));
// ==========
TopDocs topDocs = indexSearcher.search(query, filter, 10000, sort);
int recordCount = topDocs.totalHits;
List<Document> recordList = new ArrayList<Document>();
// ============== 准备高亮器
Formatter formatter = new SimpleHTMLFormatter("<font color='red'>", "</font>");
Scorer scorer = new QueryScorer(query);
Highlighter highlighter = new Highlighter(formatter, scorer);
Fragmenter fragmenter = new SimpleFragmenter(50);
highlighter.setTextFragmenter(fragmenter);
// ==============
// 3，取出当前页的数据
int end = Math.min(firstResult + maxResults, topDocs.totalHits);
for (int i = firstResult; i < end; i++) {
ScoreDoc scoreDoc = topDocs.scoreDocs[i];
int docSn = scoreDoc.doc; // 文档内部编号
Document doc = indexSearcher.doc(docSn); // 根据编号取出相应的文档
// =========== 高亮
// 返回高亮后的结果，如果当前属性值中没有出现关键字，会返回 null
String hc = highlighter.getBestFragment(analyzer, "content", doc.get("content"));
if (hc == null) {
String content = doc.get("content");
int endIndex = Math.min(50, content.length());
hc = content.substring(0, endIndex);// 最多前50个字符
}
doc.getField("content").setValue(hc);
// ===========

recordList.add(doc);
}
// 返回结果
return new QueryResult(recordCount, recordList);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
try {
indexSearcher.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//==============
public class IndexDaoTest {
String filePath = "E:\\luceneDatasource\\IndexWriter addDocument's a javadoc .txt";
String filePath2 = "E:\\luceneDatasource\\小笑话_总统的房间 Room .txt";
IndexDao indexDao = new IndexDao();
@Test
public void testSave() {
Document doc = File2DocumentUtils.file2Document(filePath);
doc.setBoost(3f);
indexDao.save(doc);
Document doc2 = File2DocumentUtils.file2Document(filePath2);
// doc2.setBoost(1.0f);
indexDao.save(doc2);
}
@Test
public void testDelete() {
Term term = new Term("path", filePath);
indexDao.delete(term);
}
@Test
public void testUpdate() {
Term term = new Term("path", filePath);
Document doc = File2DocumentUtils.file2Document(filePath);
doc.getField("content").setValue("这是更新后的文件内容");
indexDao.update(term, doc);
}
@Test
public void testSearch() {
// String queryString = "IndexWriter";
// String queryString = "房间";
// String queryString = "笑话";
String queryString = "room";
// String queryString = "content:绅士";
QueryResult qr = indexDao.search(queryString, 0, 10);
System.out.println("总共有【" + qr.getRecordCount() + "】条匹配结果");
for (Document doc : qr.getRecordList()) {
File2DocumentUtils.printDocumentInfo(doc);
}
}
}
//============
public class QueryResult {
private int recordCount;
private List<Document> recordList;

public QueryResult(int recordCount, List<Document> recordList) {
super();
this.recordCount = recordCount;
this.recordList = recordList;
}

public int getRecordCount() {
return recordCount;
}

public void setRecordCount(int recordCount) {
this.recordCount = recordCount;
}

public List<Document> getRecordList() {
return recordList;
}

public void setRecordList(List<Document> recordList) {
this.recordList = recordList;
}

}
//==============
public class AnalyzerTest {
String enText = "IndexWriter addDocument's a javadoc.txt";
// String zhText = "我们是中国人";
// String zhText = "小笑话_总统的房间 Room .txt";
String zhText = "一位绅士到旅游胜地的一家饭店要开个房间";
Analyzer en1 = new StandardAnalyzer(); // 单字分词
Analyzer en2 = new SimpleAnalyzer();
Analyzer zh1 = new CJKAnalyzer(); // 二分法分词
Analyzer zh2 = new MMAnalyzer(); // 词库分词
@Test
public void test() throws Exception {
// analyze(en2, enText);
// analyze(en1, zhText);

// analyze(zh1, zhText);
analyze(zh2, zhText);
}
public void analyze(Analyzer analyzer, String text) throws Exception {
System.out.println("-------------> 分词器：" + analyzer.getClass());
TokenStream tokenStream = analyzer.tokenStream("content", new StringReader(text));
for (Token token = new Token(); (token = tokenStream.next(token)) != null;) {
System.out.println(token);
}
}
}
//===========
public class DirectoryTest {
String filePath = "E:\\IndexWriter addDocument 's javadoc.txt";
String indexPath = "E:\\luceneIndex";
Analyzer analyzer = new StandardAnalyzer();
@Test
public void test1()throws Exception {
// Directory dir = FSDirectory.getDirectory(indexPath);
Directory dir = new RAMDirectory();
Document doc = File2DocumentUtils.file2Document(filePath);
IndexWriter indexWriter = new IndexWriter(dir, analyzer, MaxFieldLength.LIMITED);
indexWriter.addDocument(doc);
indexWriter.close();
}
@Test
public void test2() throws Exception{
Directory fsDir = FSDirectory.getDirectory(indexPath);
// 1，启动时读取
Directory ramDir = new RAMDirectory(fsDir);
// 运行程序时操作 ramDir
IndexWriter ramIndexWriter = new IndexWriter(ramDir, analyzer, MaxFieldLength.LIMITED);
// 添加 Document
Document doc = File2DocumentUtils.file2Document(filePath);
ramIndexWriter.addDocument(doc);
ramIndexWriter.close();

// 2，退出时保存
IndexWriter fsIndexWriter = new IndexWriter(fsDir, analyzer,true, MaxFieldLength.LIMITED);
fsIndexWriter.addIndexesNoOptimize(new Directory[]{ramDir});
// fsIndexWriter.flush();
// fsIndexWriter.optimize();
fsIndexWriter.close();
}
@Test
public void test3() throws Exception{
Directory fsDir = FSDirectory.getDirectory(indexPath);
IndexWriter fsIndexWriter = new IndexWriter(fsDir, analyzer, MaxFieldLength.LIMITED);
fsIndexWriter.optimize();
fsIndexWriter.close();
}
}
//=================
public class HelloWorld {

String filePath = "E:\\lesson\\20090723就业班\\workspace\\LuceneDemo\\luceneDatasource\\IndexWriter addDocument's a javadoc.txt";

String indexPath = "E:\\lesson\\20090723就业班\\workspace\\LuceneDemo\\luceneIndex";

Analyzer analyzer = new StandardAnalyzer();

/**
* 创建索引
*
* IndexWriter 是用来操作（增、删、改）索引库的
*/
@Test
public void createIndex() throws Exception {
// file --> doc
Document doc = File2DocumentUtils.file2Document(filePath);

// 建立索引
IndexWriter indexWriter = new IndexWriter(indexPath, analyzer, true,
MaxFieldLength.LIMITED);
indexWriter.addDocument(doc);
indexWriter.close();
}

/**
* 搜索
*
* IndexSearcher 是用来在索引库中进行查询的
*/
@Test
public void search() throws Exception {
// String queryString = "document";
String queryString = "adddocument";

// 1，把要搜索的文本解析为 Query
String[] fields = { "name", "content" };
QueryParser queryParser = new MultiFieldQueryParser(fields, analyzer);
Query query = queryParser.parse(queryString);

// 2，进行查询
IndexSearcher indexSearcher = new IndexSearcher(indexPath);
Filter filter = null;
TopDocs topDocs = indexSearcher.search(query, filter, 10000);
System.out.println("总共有【" + topDocs.totalHits + "】条匹配结果");

// 3，打印结果
for (ScoreDoc scoreDoc : topDocs.scoreDocs) {
int docSn = scoreDoc.doc; // 文档内部编号
Document doc = indexSearcher.doc(docSn); // 根据编号取出相应的文档
File2DocumentUtils.printDocumentInfo(doc); // 打印出文档信息
}
}
}
//================
public class QueryTest {

IndexDao indexDao = new IndexDao();

public void queryAndPrintResult(Query query) {
System.out.println("对应的查询字符串：" + query);
QueryResult qr = indexDao.search(query, 0, 100);
System.out.println("总共有【" + qr.getRecordCount() + "】条匹配结果");
for (Document doc : qr.getRecordList()) {
File2DocumentUtils.printDocumentInfo(doc);
}
}

/**
* 关键词查询
*
* name:room
*/
@Test
public void testTermQuery() {
// Term term = new Term("name", "房间");
// Term term = new Term("name", "Room"); // 英文关键词全是小写字符
Term term = new Term("name", "room");
Query query = new TermQuery(term);

queryAndPrintResult(query);
}

/**
* 范围查询
*
* 包含边界：size:[0000000000001e TO 000000000000rs]
*
* 不包含边界：size:{0000000000001e TO 000000000000rs}
*/
@Test
public void testRangeQuery() {
Term lowerTerm = new Term("size", NumberTools.longToString(50));
Term upperTerm = new Term("size", NumberTools.longToString(1000));
Query query = new RangeQuery(lowerTerm, upperTerm, false);

queryAndPrintResult(query);
}

// public static void main(String[] args) {
// System.out.println(Long.MAX_VALUE);
// System.out.println(NumberTools.longToString(1000));
// System.out.println(NumberTools.stringToLong("000000000000rs"));
//
// System.out.println(DateTools.dateToString(new Date(), Resolution.DAY));
// System.out.println(DateTools.dateToString(new Date(), Resolution.MINUTE));
// System.out.println(DateTools.dateToString(new Date(), Resolution.SECOND));
// }

/**
* 通配符查询
*
* '?' 代表一个字符， '*' 代表0个或多个字符
*
* name:房*
*
* name:*o*
*
* name:roo?
*/
@Test
public void testWildcardQuery() {
Term term = new Term("name", "roo?");
// Term term = new Term("name", "ro*"); // 前缀查询 PrefixQuery
// Term term = new Term("name", "*o*");
// Term term = new Term("name", "房*");
Query query = new WildcardQuery(term);

queryAndPrintResult(query);
}

/**
* 短语查询
*
* content:"? 绅士 ? ? 饭店"
*
* content:"绅士 饭店"~2
*/
@Test
public void testPhraseQuery() {
PhraseQuery phraseQuery = new PhraseQuery();
// phraseQuery.add(new Term("content", "绅士"), 1);
// phraseQuery.add(new Term("content", "饭店"), 4);

phraseQuery.add(new Term("content", "绅士"));
phraseQuery.add(new Term("content", "饭店"));
phraseQuery.setSlop(2);

queryAndPrintResult(phraseQuery);
}

/**
* +content:"绅士 饭店"~2 -size:[000000000000dw TO 000000000000rs]
*
* +content:"绅士 饭店"~2 +size:[000000000000dw TO 000000000000rs]
*
* content:"绅士 饭店"~2 size:[000000000000dw TO 000000000000rs]
*
* +content:"绅士 饭店"~2 size:[000000000000dw TO 000000000000rs]
*/
@Test
public void testBooleanQuery() {
// 条件1
PhraseQuery query1 = new PhraseQuery();
query1.add(new Term("content", "绅士"));
query1.add(new Term("content", "饭店"));
query1.setSlop(2);

// 条件2
Term lowerTerm = new Term("size", NumberTools.longToString(500));
Term upperTerm = new Term("size", NumberTools.longToString(1000));
Query query2 = new RangeQuery(lowerTerm, upperTerm, true);

// 组合
BooleanQuery boolQuery = new BooleanQuery();
boolQuery.add(query1, Occur.MUST);
boolQuery.add(query2, Occur.SHOULD);

queryAndPrintResult(boolQuery);
}

@Test
public void testQueryString() {
// String queryString = "+content:\"绅士 饭店\"~2 -size:[000000000000dw TO 000000000000rs]";
// String queryString = "content:\"绅士 饭店\"~2 AND size:[000000000000dw TO 000000000000rs]";
// String queryString = "content:\"绅士 饭店\"~2 OR size:[000000000000dw TO 000000000000rs]";
// String queryString = "(content:\"绅士 饭店\"~2 NOT size:[000000000000dw TO 000000000000rs])";
// String queryString = "-content:\"绅士 饭店\"~2 AND -size:[000000000000dw TO 000000000000rs]";
// String queryString = "-content:\"绅士 饭店\"~2 OR -size:[000000000000dw TO 000000000000rs]";
String queryString = "-content:\"绅士 饭店\"~2 NOT -size:[000000000000dw TO 000000000000rs]";

QueryResult qr = indexDao.search(queryString, 0, 10);
System.out.println("总共有【" + qr.getRecordCount() + "】条匹配结果");
for (Document doc : qr.getRecordList()) {
File2DocumentUtils.printDocumentInfo(doc);
}
}

}
//============
public class File2DocumentUtils {

// 文件：name, content, size, path
public static Document file2Document(String path) {
File file = new File(path);

Document doc = new Document();
doc.add(new Field("name", file.getName(), Store.YES, Index.ANALYZED));
doc.add(new Field("content", readFileContent(file), Store.YES, Index.ANALYZED));
doc.add(new Field("size", NumberTools.longToString(file.length()), Store.YES, Index.NOT_ANALYZED));
doc.add(new Field("path", file.getAbsolutePath(), Store.YES, Index.NOT_ANALYZED));
return doc;
}

// public static void document2File(Document doc ){
//
// }

/**
* 读取文件内容
*/
public static String readFileContent(File file) {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
StringBuffer content = new StringBuffer();

for (String line = null; (line = reader.readLine()) != null;) {
content.append(line).append("\n");
}

return content.toString();
} catch (Exception e) {
throw new RuntimeException(e);
}
}

/**
* <pre>
* 获取 name 属性的值的两种方法：
* 1，Field f = doc.getField(&quot;name&quot;);
*    f.stringValue();
* 2，doc.get(&quot;name&quot;);
* </pre>
*
* @param doc
*/
public static void printDocumentInfo(Document doc) {
// Field f = doc.getField("name");
// f.stringValue();
System.out.println("------------------------------");
System.out.println("name     = " + doc.get("name"));
System.out.println("content  = " + doc.get("content"));
System.out.println("size     = " + NumberTools.stringToLong(doc.get("size")));
System.out.println("path     = " + doc.get("path"));
}

}