第一个lucene例子

目前需要解决的问题是：解决英文单字模糊查询

package com.test.search;

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

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.cjk.CJKAnalyzer;
import org.apache.lucene.analysis.cn.ChineseAnalyzer;
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.Term;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.Token;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.MultiSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.Searcher;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.WildcardQuery;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.store.SimpleFSDirectory;
import org.apache.lucene.util.Version;
import org.compass.core.util.reader.StringReader;

public class LuceneTest {
private static String indexFilePath = "e://lucene//";

//private static String indexFilePathClass = "e://lucene//class//";
//private static String indexFilePathSchool = "e://lucene//school";

public LuceneTest(String filepath) {
this.indexFilePath = filepath;
}

public static void main(String[] args) {
try {
LuceneTest luceneTest = new LuceneTest(indexFilePath);
//luceneTest.initIndex();// 初始化索引
//luceneTest.search("student", "w"); //需要解决分词问题，目前只支持整词检索// 调用search方法进行检索，填入想检索的文字 多个词可用空格分开,
luceneTest.search("class","一");// 调用search方法进行检索，填入想检索的文字 多个词可用空格分开
//luceneTest.search("school","东");// 调用search方法进行检索，填入想检索的文字 多个词可用空格分开

// 删除一条记录
// indexWriter.deleteDocuments(new Term("title","1"));

// 增加一条记录
// indexWriter.addDocument(document);

// 更新一条记录
// indexWriter.updateDocument(new Term("title","1"), document);

System.out.println("检索完毕！");
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 执行查询
* @param searchType--查询类别（学生，班级，学校）
* @param serchString--输入的查询关键字
* @throws Exception
*/
public void search(String searchType, String serchWord) throws Exception {
Directory directory = new SimpleFSDirectory(new File(indexFilePath
+ File.separator + searchType));

/* 创建一个搜索，搜索刚才创建的e://lucene//目录下的索引 */
IndexSearcher indexSearcher = new IndexSearcher(directory, true);
/* 在这里我们只需要搜索一个目录 */
IndexSearcher indexSearchers[] = { indexSearcher };
/* Multisearcher表示多目录搜索，在这里我们只有一个目录 */
Searcher searcher = new MultiSearcher(indexSearchers);

/* 我们需要搜索两个域"ArticleTitle", "ArticleText"里面的内容 */
String[] fields = { "title", "content", "url" };

/* 这里只搜索title域,只有title域中有符合条件的数据才做为搜索结果集中的一部分,MUST表示and，MUST_NOT表示not, SHOULD表示or*/
BooleanClause.Occur[] clauses = { BooleanClause.Occur.MUST,
BooleanClause.Occur.MUST_NOT, BooleanClause.Occur.MUST_NOT };

/*
* MultiFieldQueryParser表示多个域解析，
* 同时可以解析含空格的字符串，如果我们搜索"老板"，根据前面的索引，显然搜到的是第二份文件
*/
/*Query query = MultiFieldQueryParser.parse(Version.LUCENE_CURRENT,
serchWord, fields, clauses, new StandardAnalyzer(Version.LUCENE_CURRENT));
*/
/*Query query = MultiFieldQueryParser.parse(Version.LUCENE_CURRENT,
serchWord, fields, clauses, new CJKAnalyzer(Version.LUCENE_CURRENT));
*/
Query query=new WildcardQuery(new Term("title","*"+serchWord+"*"));

/* 把搜索出来的所有文件打印出来 */
int thispage = 300;
int startindex = 0; // 前台可利用此参数来控制分页查询
int maxpage = 300; // 每页最多显示50条结果记录
thispage = maxpage;
/* 开始搜索 */
TopDocs h = searcher.search(query, maxpage);

if ((startindex + maxpage) > h.totalHits) {
thispage = h.totalHits - startindex; // set the max index to
// maxpage or last
}

for (int i = startindex; i < (thispage + startindex); i++) {
Document doc = searcher.doc(h.scoreDocs[i].doc); // get the next
// document
String doctitle = doc.get("title"); // get its title
String content = doc.get("content"); // get its path field
String url = doc.get("url"); // get its url field
System.out.println(doctitle);
System.out.println(content);
System.out.println(url);
}

/* 关闭 */
searcher.close();
}

public void closeIndex(IndexWriter indexWriter) {
try {
indexWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 初始化索引，在系统第一次启动时用，以后只对其做更新、删除等操作，
* 系统再重启后也不需要，因为索引已经以文件的形式存储在的索引文件中，永久有效
*
* @return
*/
public String initIndex() {
/////////添加学生
String title = "wenfujun";
String content = "文付军和文亚龙: congratulations on your success!";
String url = "http://wenfujun_url";
addIndex(title, content, url, "student");

title = "wenbo";
content = "文博和文昊: congratulations on your success!";
url = "http://wenbo_url";
addIndex(title, content, url, "student");

/////////添加班级
title = "05界一班";
content = "一年级一班!";
url = "http://wenfujun_url";
addIndex(title, content, url, "class");

title = "03界二班";
content = "一年级二班";
url = "http://wenbo_url";
addIndex(title, content, url, "class");

//添加学校
title = "山东省东明县第二高级中学";
content = "东明二中是个很不错的中学，是我的母校";
url = "http://wenfujun_url";
addIndex(title, content, url, "school");

title = "山东省菏泽市第一中高级中学";
content = "山东菏泽一中的升学率非常高，教学质量那个高啊!!!";
url = "http://wenbo_url";
addIndex(title, content, url, "school");
return null;
}

/**
* 删除索引
*
* @return
*/
public String deleteIndex() {
try {
this.getWriter(indexFilePath).deleteDocuments(
new Term("title", "1"));
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/**
* 更新（修改）索引
*
* @return
*/
public String updateIndex(String title, String content, String url) {
Document document = new Document();
// Field对象，相当于数据库中字段
Field FiledTitle = new Field("title", title, Field.Store.YES,
Field.Index.ANALYZED);// Field.Index.ANALYZED 这就能进行索引了,
// 如果设置为NO的话就不能检索
Field FiledContent = new Field("content", content, Field.Store.YES,
Field.Index.ANALYZED);
Field FieldBody = new Field("url", url, Field.Store.YES, Field.Index.NO);
document.add(FieldBody);
document.add(FiledContent);
document.add(FiledTitle);
try {
this.getWriter(indexFilePath).updateDocument(
new Term("title", "1"), document);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}

/**
* 添加索引
* @param title
* @param content
* @param url
* @param indexType--索引类别（student,class,school）
* @return
*/
public boolean addIndex(String title, String content, String url,
String indexType) {
try {
// 增加document到索引去
// document对象，相当于数据库中一条记录
Document document = new Document();
// Field对象，相当于数据库中字段
Field FiledTitle = new Field("title", title, Field.Store.YES,
Field.Index.ANALYZED);// Field.Index.ANALYZED 这就能进行索引了,
// 如果设置为NO的话就不能检索
Field FiledContent = new Field("content", content, Field.Store.YES,
Field.Index.ANALYZED);
Field FieldBody = new Field("url", url, Field.Store.YES,
Field.Index.NO);
document.add(FieldBody);
document.add(FiledContent);
document.add(FiledTitle);
IndexWriter indexWriter = this.getWriter(indexFilePath
+ File.separator + indexType);
indexWriter.addDocument(document);

indexWriter.optimize();
indexWriter.close();
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}

/**
* 判断索引是否存在
* @param indexDir
* @return
*/
public static boolean indexExist(String indexDir) {
boolean isExt = true;
try {
isExt = IndexReader.indexExists(new SimpleFSDirectory(new File(
indexDir)));
} catch (Exception e) {
e.printStackTrace();
}
return isExt;
}

/**
* 获得IndexWriter
* @param indexFilePath--索引目录，在调用此方法时已经指定类型是student、class或school
* @return
* @throws CorruptIndexException
* @throws LockObtainFailedException
* @throws IOException
*/
private IndexWriter getWriter(String indexFilePath)
throws CorruptIndexException, LockObtainFailedException,
IOException {
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);
//Analyzer analyzer = new ChineseAnalyzer();
boolean append = true;
File file = new File(indexFilePath + File.separator + "segments.gen");
if (file.exists()) {
append = false;
}
return new IndexWriter(new SimpleFSDirectory(new File(indexFilePath)),
analyzer, append, new IndexWriter.MaxFieldLength(999999999));
}

/**
* 此方法暂时不用了，改写为用addIndex()方法
*
* @throws Exception
*/
public void index() throws Exception {
Directory directory = new SimpleFSDirectory(new File("e://lucene//"));
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);

// 初始化索引，清空或创建e://lucene//下的索引
IndexWriter writer1 = new IndexWriter(directory, analyzer, true,
new IndexWriter.MaxFieldLength(25000));
writer1.close();// 关闭

/*
* 往创建的初始化索引中添加索引内容，StandardAnalyzer表示用lucene自带的标准分词机制，
* false表示不覆盖原来该目录的索引，细心的读者可能已经发现， 这句话和上面的那句就这个false不一样
*/
// IndexWriter writer2 = new IndexWriter("e://lucene//",new
// StandardAnalyzer(), false);
IndexWriter writer2 = new IndexWriter(directory, analyzer, false,
new IndexWriter.MaxFieldLength(25000));
Document doc = new Document();// 创建文件

// 创建一个域ArticleTitle，并往这个域里面添加内容
// "Field.Store.YES"表示域里面的内容将被存储到索引,"Field.Index.ANALYZED"表示域里面的内容将被索引，以便用来搜索
Field articleTitle = new Field("title", "title:文付军和文亚龙",
Field.Store.YES, Field.Index.ANALYZED);
/* 往文件里添加这个域 */
doc.add(articleTitle);

/* 同理：创建另外一个域ArticleText，并往这个域里面添加内容 */
Field srticleText = new Field("content",
"content:文付军和文亚龙: congratulations on your success!",
Field.Store.YES, Field.Index.ANALYZED);
doc.add(srticleText);
// 在这里还可以添加其他域

/* 添加这份文件到索引 */
writer2.addDocument(doc);

/* 同理：创建第二份文件 */
doc = new Document();// 创建文件
articleTitle = new Field("title", "title:文博和文昊", Field.Store.YES,
Field.Index.ANALYZED);
doc.add(articleTitle);
srticleText = new Field("content",
"content:文博和文昊: congratulations on your success!",
Field.Store.YES, Field.Index.ANALYZED);
doc.add(srticleText);
writer2.addDocument(doc);
// 在这里可以添加其他文件

/* 关闭 */
writer2.close();
}

/**
* 暂时不用
* @param type
* @param keyword
*/
public void executeSearch(String type, String keyword) {
Hits result = null;
if (type != null && !"".equals(type) && keyword != null
&& !keyword.equals("")) {
try {
//根据关键字构造一个数组
String key[] = { keyword, type };

//同时声明一个与之对应的字段数组
String fields[] = { "title", "type" };

//声明BooleanClause.Occur[]数组，它表示多个条件之间的关系
BooleanClause.Occur flags[] = { BooleanClause.Occur.MUST,
BooleanClause.Occur.MUST };
//ChineseAnalyzer analyzer = new ChineseAnalyzer();
Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);

//用MultiFieldQueryParser得到query对象
Query query = MultiFieldQueryParser.parse(key, fields, flags,
analyzer);

//e://lucene表示索引文件所在目录
IndexSearcher searcher = new IndexSearcher(indexFilePath);

//查询结果
//result = searcher.search(query);

///////////////////////////////////////////
/* 把搜索出来的所有文件打印出来 */
int thispage = 30;
int startindex = 0; // 前台可利用此参数来控制分页查询
int maxpage = 30; // 每页最多显示50条结果记录
thispage = maxpage;
TopDocs h = searcher.search(query, maxpage);

if ((startindex + maxpage) > h.totalHits) {
thispage = h.totalHits - startindex; // set the max index to
// maxpage or last
}

for (int i = startindex; i < (thispage + startindex); i++) {
Document doc = searcher.doc(h.scoreDocs[i].doc); // get the next
// document
String doctitle = doc.get("title"); // get its title
String content = doc.get("type"); // get its path field
System.out.println(doctitle);
System.out.println(content);
}

} catch (Exception e) {
e.printStackTrace();
}
}
//return result;
}

/*
* public ArrayList<BaseItem> getDate(String sql) throws SQLException {
* ArrayList<BaseItem> item = new ArrayList<BaseItem>(); ConnBase dataConn =
* new ConnBase();//数据库连接 conn = dataConn.DBconn(); ps =
* conn.prepareStatement(sql); rs = ps.executeQuery(); //
* jdbcTemplate.execute(sql); while (rs.next()) { BaseItem i = new
* BaseItem(); i.setTitle(rs.getString("title")); // 对应你的Blog表里的title
* i.setContent(rs.getString("content")); // 取表里的博客内容
* i.setUr("SingleArticle_lucene.action?id=" + rs.getInt("blogId")); // 如 a.
* action ?id=8 item.add(i); } // 把数据库里的数据取出来 return item; }
*/

}