Lucene集成——作为强大高效的检索引擎，Lucene的美名早已久经考验了；
数据的自动插入和更新——当一个对象通过Hibernate添加或更新时，索引也会相应进行透明的更新；
支持众多复杂的搜索方式——可快速的使用通配符进行搜索，以及多关键词全文检索（multi-word text searches）和近似或同义词搜索（approximation/synonym searches），或根据相关性排列搜索结果；
搜索集群（Search Clustering）——Hibernate Search提供了内建搜索集群解决方案，其中包括一个基于JMS的异步查询和索引系统；
对Lucene API接口的直接调用——如果用户打算处理某些特别复杂的问题，可以在查询中直接使用Lucene提供的API接口；
对Lucene的自动管理——Hibernate Search可以管理并优化Lucene的索引，并且非常高效地使用Lucene的API接口。
项目的主要目标包含以下几个方面：

易用性——和Hibernate的ORM映射一样，Hibernate Search帮助用户实现了业务90%的工作，并且使用户专注于余下更为困难的业务实现部分；
和已有的Hibernate/JPA编程模型保持一致性——更轻松地集成Hibernate/JPA编程模型是“一开始就致力要实现的目标”。

import Java.io.FileInputStream;
import Java.io.FileNotFoundException;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.InputStreamReader;
import Java.io.Reader;
import Java.io.UnsupportedEncodingException;

import org.apache.lucene.demo.html.HTMLParser;

public class HTMLDocParser {

 private String htmlPath;
 private HTMLParser htmlParser;
 
 public HTMLDocParser(String htmlPath){
  this.htmlPath=htmlPath;
  initHtmlParser();
 }
 public void initHtmlParser(){
  InputStream inputStream=null;
  try{
   inputStream=new FileInputStream(htmlPath);
  }catch(FileNotFoundException e){
   e.printStackTrace();
  }
  if(null!=inputStream){
   try{
    htmlParser=new HTMLParser(new InputStreamReader(inputStream,"utf-8"));
   }catch(UnsupportedEncodingException e){
    e.printStackTrace();
   }
  }
 }
 public String getTitle(){
  if(null!=htmlParser){
   try{
    return htmlParser.getTitle();
   }catch(IOException e){
    e.printStackTrace();
   }catch(InterruptedException e){
    e.printStackTrace();
   }
  }
  return "";
 }
 public Reader getContent(){
  if(null!=htmlParser){
   try{
    return htmlParser.getReader();
   }catch(IOException e){
    e.printStackTrace();
   }
  }
  return null;
 }
 public String getPath(){
  return this.htmlPath;
 }
}

描述搜索结果的结构实体Bean
package com.rain.search;

public class SearchResultBean {
    private String htmlPath;
   
    private String htmlTitle;

 public String getHtmlPath() {
  return htmlPath;
 }

 public void setHtmlPath(String htmlPath) {
  this.htmlPath = htmlPath;
 }

 public String getHtmlTitle() {
  return htmlTitle;
 }

 public void setHtmlTitle(String htmlTitle) {
  this.htmlTitle = htmlTitle;
 }
}

索引子系统的实现

package com.rain.index;

import Java.io.File;
import Java.io.IOException;
import Java.io.Reader;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.document.Field;

import com.rain.util.HTMLDocParser;

public class IndexManager {
 
 //the directory that stores HTML files
 private final String dataDir="E:\\dataDir";
 
 //the directory that is used to store a Lucene index
 private final String indexDir="E:\\indexDir";
 
 public boolean creatIndex()throws IOException{
  if(true==inIndexExist()){
   return true;
  }
  File dir=new File(dataDir);
  if(!dir.exists()){
   return false;
  }
  File[] htmls=dir.listFiles();
  Directory fsDirectory=FSDirectory.getDirectory(indexDir,true);
  Analyzer analyzer=new StandardAnalyzer();
  IndexWriter indexWriter=new IndexWriter(fsDirectory,analyzer,true);
  for(int i=0;i<htmls.length;i++){
   String htmlPath=htmls[i].getAbsolutePath();
   if(htmlPath.endsWith(".html")||htmlPath.endsWith("htm")){
    addDocument(htmlPath,indexWriter);
   }
  }
  indexWriter.optimize();
  indexWriter.close();
  return true;
 }
 
 public void addDocument(String htmlPath,IndexWriter indexWriter){
  HTMLDocParser htmlParser=new HTMLDocParser(htmlPath);
  String path=htmlParser.getPath();
  String title=htmlParser.getTitle();
  Reader content=htmlParser.getContent();
  
  Document document=new Document();
  document.add(new Field("path",path,Field.Store.YES,Field.Index.NO));
  document.add(new Field("title",title,Field.Store.YES,Field.Index.TOKENIZED));
     document.add(new Field("content",content));
     try{
      indexWriter.addDocument(document);
     }catch(IOException e){
      e.printStackTrace();
     }
 }
 public String getDataDir(){
  return this.dataDir;
 }
 
 public String getIndexDir(){
  return this.indexDir;
 }
 
 public boolean inIndexExist(){
  File directory=new File(indexDir);
  if(0<directory.listFiles().length){
   return true;
  }else{
   return false;
  }
 }
}

搜索功能的实现
package com.rain.search;

import Java.io.IOException;
import Java.util.ArrayList;
import Java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;

import com.rain.index.IndexManager;

public class SearchManager {
 private String searchWord;
 private IndexManager indexManager;
 private Analyzer analyzer;
 
 public SearchManager(String searchWord){
  this.searchWord=searchWord;
  this.indexManager=new IndexManager();
  this.analyzer=new StandardAnalyzer();
 }
 
 /**
     * do search
     */
 public List search(){
  List searchResult=new ArrayList();
  if(false==indexManager.inIndexExist()){
   try{
    if(false==indexManager.creatIndex()){
     return searchResult;
    }
   }catch(IOException e){
    e.printStackTrace();
    return searchResult;
   }
  }
  IndexSearcher indexSearcher=null;
  try{
   indexSearcher=new IndexSearcher(indexManager.getIndexDir());
  }catch(IOException e){
   e.printStackTrace();
  }
  QueryParser queryParser=new QueryParser("content",analyzer);
  Query query=null;
  try{
   query=queryParser.parse(searchWord);
  }catch(ParseException e){
   e.printStackTrace();
  }
  if(null!=query&&null!=indexSearcher){
   try{
    Hits hits=indexSearcher.search(query);
    for(int i=0;i<hits.length();i++){
     SearchResultBean resultBean=new SearchResultBean();
     resultBean.setHtmlPath(hits.doc(i).get("path"));
     resultBean.setHtmlTitle(hits.doc(i).get("title"));
     searchResult.add(resultBean);
    }
   }catch(IOException e){
    e.printStackTrace();
   }
  }
   return searchResult;
 }

}

请求管理器的实现

package com.rain.servlet;

import Java.io.IOException;
import Java.util.List;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.rain.search.SearchManager;

/**
 * @author zhourui
 * 2007-1-28
 */
public class SearchController extends HttpServlet {
 private static final long serialVersionUID=1L;
 
 /* (non-Javadoc)
  * @see javax.servlet.http.HttpServlet#doPost(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
  */
 @Override
 protected void doPost(HttpServletRequest arg0, HttpServletResponse arg1) throws ServletException, IOException {
  // TODO Auto-generated method stub
  String searchWord=arg0.getParameter("searchWord");
  SearchManager searchManager=new SearchManager(searchWord);
  List searchResult=null;
  searchResult=searchManager.search();
  RequestDispatcher dispatcher=arg0.getRequestDispatcher("search.jsp");
  arg0.setAttribute("searchResult",searchResult);
        dispatcher.forward(arg0, arg1);
 }
 
}

随着系统信息的越来越多，怎么样从这些信息海洋中捞起自己想要的那一根针就变得非常重要了，全文检索是通常用于解决此类问题的方案，而Lucene则为实现全文检索的工具，任何应用都可通过嵌入它来实现全文检索。

二.  环境搭建

从lucene.apache.org上下载最新版本的lucene.jar，将此jar作为项目的build path，那么在项目中就可以直接使用lucene了。

三.  使用说明

3.1.       基本概念

这里介绍的主要为在使用中经常碰到一些概念，以大家都比较熟悉的数据库来进行类比的讲解，使用Lucene进行全文检索的过程有点类似数据库的这个过程，table---à查询相应的字段或查询条件----à返回相应的记录，首先是IndexWriter，通过它建立相应的索引表，相当于数据库中的table，在构建此索引表时需指定的为该索引表采用何种方式进行构建，也就是说对于其中的记录的字段以什么方式来进行格式的划分，这个在Lucene中称为Analyzer，Lucene提供了几种环境下使用的Analyzer：SimpleAnalyzer、StandardAnalyzer、GermanAnalyzer等，其中StandardAnalyzer是经常使用的，因为它提供了对于中文的支持，在表建好后我们就需要往里面插入用于索引的记录，在Lucene中这个称为Document，有点类似数据库中table的一行记录，记录中的字段的添加方法，在Lucene中称为Field，这个和数据库中基本一样，对于Field Lucene分为可被索引的，可切分的，不可被切分的，不可被索引的几种组合类型，通过这几个元素基本上就可以建立起索引了。在查询时经常碰到的为另外几个概念，首先是Query，Lucene提供了几种经常可以用到的Query：TermQuery、MultiTermQuery、BooleanQuery、WildcardQuery、PhraseQuery、PrefixQuery、PhrasePrefixQuery、FuzzyQuery、RangeQuery、SpanQuery，Query其实也就是指对于需要查询的字段采用什么样的方式进行查询，如模糊查询、语义查询、短语查询、范围查询、组合查询等，还有就是QueryParser，QueryParser可用于创建不同的Query，还有一个MultiFieldQueryParser支持对于多个字段进行同一关键字的查询，IndexSearcher概念指的为需要对何目录下的索引文件进行何种方式的分析的查询，有点象对数据库的哪种索引表进行查询并按一定方式进行记录中字段的分解查询的概念，通过IndexSearcher以及Query即可查询出需要的结果，Lucene返回的为Hits.通过遍历Hits可获取返回的结果的Document，通过Document则可获取Field中的相关信息了。

比较一下Lucene和数据库：

索引数据源：doc(field1,field2...) doc(field1,field2...)
                  \  indexer /
                 _____________
                | Lucene Index|
                --------------
                 / searcher \
 结果输出：Hits(doc(field1,field2) doc(field1...))

 索引数据源：record(field1,field2...) record(field1..)
              \  SQL: insert/
               _____________
              | DB  Index   |
               -------------
              / SQL: select \
结果输出：results(record(field1,field2..) record(field1...))

需要熟悉几个接口：
分析器Analyzer
        分析器主要工作是筛选，一段文档进来以后，经过它，出去的时候只剩下那些有用的部分，其他则剔除。而这个分析器也可以自己根据需要而编写。
        org.apache.lucene.analysis.Analyzer：这是一个虚构类，以下两个借口均继承它而来。
        org.apache.lucene.analysis.SimpleAnalyzer：分析器，支持最简单拉丁语言。
        org.apache.lucene.analysis.standard.StandardAnalyzer：标准分析器，除了拉丁语言还支持亚洲语言，并在一些匹配功能上进行完善。在这个接口中还有一个很重要的构造函数：StandardAnalyzer(String[] stopWords)，可以对分析器定义一些使用词语，这不仅可以免除检索一些无用信息，而且还可以在检索中定义禁止的政治性、非法性的检索关键词。
IndexWriter
        IndexWriter的构造函数有三种接口，针对目录Directory、文件File、文件路径String三种情况。
例如IndexWriter(String path, Analyzer a, boolean create)，path为文件路径，a为分析器，create标志是否重建索引（true：建立或者覆盖已存在的索引，false：扩展已存在的索引。）
       一些重要的方法：

索引建立部分的代码：

private void createIndex(String indexFilePath) throws Exception{

        IndexWriter iwriter=getWriter(indexFilePath);

        Document doc=new Document();

        doc.add(Field.Keyword("name","jerry"));

        doc.add(Field.Text("sender","bluedavy@gmail.com"));

        doc.add(Field.Text("receiver","google@gmail.com"));

        doc.add(Field.Text("title","用于索引的标题"));

        doc.add(Field.UnIndexed("content","不建立索引的内容"));

        Document doc2=new Document();

        doc2.add(Field.Keyword("name","jerry.lin"));

        doc2.add(Field.Text("sender","bluedavy@hotmail.com"));

        doc2.add(Field.Text("receiver","msn@hotmail.com"));

        doc2.add(Field.Text("title","用于索引的第二个标题"));

        doc2.add(Field.Text("content","建立索引的内容"));

        iwriter.addDocument(doc);

        iwriter.addDocument(doc2);

        iwriter.optimize();

        iwriter.close();

    }

    private IndexWriter getWriter(String indexFilePath) throws Exception{

        boolean append=true;

        File file=new File(indexFilePath+File.separator+"segments");

        if(file.exists())

            append=false;

        return new IndexWriter(indexFilePath,analyzer,append);

    }

3.2.1.       对于某字段的关键字的模糊查询

Query query=new WildcardQuery(new Term("sender","*davy*"));

        Searcher searcher=new IndexSearcher(indexFilePath);

        Hits hits=searcher.search(query);

        for (int i = 0; i < hits.length(); i++) {

            System.out.println(hits.doc(i).get("name"));

        }

3.2.2.       对于某字段的关键字的语义查询

Query query=QueryParser.parse("索引","title",analyzer);

        Searcher searcher=new IndexSearcher(indexFilePath);

        Hits hits=searcher.search(query);

        for (int i = 0; i < hits.length(); i++) {

            System.out.println(hits.doc(i).get("name"));

        }

3.2.3.       对于多字段的关键字的查询

Query query=MultiFieldQueryParser.parse("索引",new String[]{"title","content"},analyzer);

        Searcher searcher=new IndexSearcher(indexFilePath);

        Hits hits=searcher.search(query);

        for (int i = 0; i < hits.length(); i++) {

            System.out.println(hits.doc(i).get("name"));

        }

3.2.4.       复合查询(多种查询条件的综合查询)

Query query=MultiFieldQueryParser.parse("索引",new String[]{"title","content"},analyzer);

        Query mquery=new WildcardQuery(new Term("sender","bluedavy*"));

        TermQuery tquery=new TermQuery(new Term("name","jerry"));

        BooleanQuery bquery=new BooleanQuery();

        bquery.add(query,true,false);

        bquery.add(mquery,true,false);

        bquery.add(tquery,true,false);

        Searcher searcher=new IndexSearcher(indexFilePath);

        Hits hits=searcher.search(bquery);

        for (int i = 0; i < hits.length(); i++) {

            System.out.println(hits.doc(i).get("name"));

        }

四.  总结

相信大家通过上面的说明能知道Lucene的一个基本的使用方法，在全文检索时建议大家先采用语义时的搜索，先搜索出有意义的内容，之后再进行模糊之类的搜索，^_^，这个还是需要根据搜索的需求才能定了，Lucene还提供了很多其他更好用的方法，这个就等待大家在使用的过程中自己去进一步的摸索了，比如对于Lucene本身提供的Query的更熟练的掌握，对于Filter、Sorter的使用，自己扩展实现Analyzer，自己实现Query等等，甚至可以去了解一些关于搜索引擎的技术(切词、索引排序 etc)等等