Lucene 更新、删除、分页操作以及IndexWriter优化

更新操作如下：

注意：通过lukeall-1.0.0.jar 查看软件,我们可以看到,更新其实是先删除在插入, 前面我们知道索引库中有两部分的内容组成,一个是索引文件,另一个是目录文件, 目前我们更新, 只是真对Document, 但是Term部分并没有同步, 所以等会需要优化索引库即可

 // 把商品信息添加到索引库中
     public void updateGoods(Goods goods){
         // 创建一个indexWriter
         IndexWriter indexWriter=null;
         try {
             indexWriter=new IndexWriter(Configuraction.getDirectory(),Configuraction.getAnalyzer(),MaxFieldLength.LIMITED);
             /*
              * 先删除文档,在追加文档
              * Term: 删除文档的条件,一般来说我们都是根据主键删除
              * doc:追加的新文档
              * */
             indexWriter.updateDocument(new Term("gid",goods.getGid().toString()),DocumentUtil.GoodsToDocument(goods));
             // 提交
             indexWriter.commit();
         } catch (IOException e) {
             e.printStackTrace();
             throw new RuntimeException(e);
         }finally{
             try {
                 // 更新操作的时候,原来的document已经删除,但是原来term并没有同步
                 // 需要同步:otimize:让term与document同步
                 indexWriter.optimize();
                 indexWriter.close();
             } catch (Exception e) {
                 e.printStackTrace();
                 throw new RuntimeException(e);
             }
         }

     }

注意 ：

注意更新操作和删除操作：都要进行optimize()方法优化,否则只会更新索引数据,不会更新索引目录. 以后可以把此操作放到独立的线程中定时执行

删除操作

     public void deleteGoods(int gid){
         // 创建一个indexWriter
         IndexWriter indexWriter=null;
         try {
             indexWriter=new IndexWriter(Configuraction.getDirectory(),Configuraction.getAnalyzer(),MaxFieldLength.LIMITED);
             indexWriter.deleteDocuments(new Term("gid",gid+""));
             // 提交
             indexWriter.commit();
         } catch (IOException e) {
             e.printStackTrace();
             throw new RuntimeException(e);
         }finally{
             try {
                 indexWriter.optimize();
                 indexWriter.close();
             } catch (Exception e) {
                 e.printStackTrace();
                 throw new RuntimeException(e);
             }
         }

     }

分页查询

 public List<Goods> query(String gname,int currentPage){
         int size=5;  // 2*5--->10条
         List<Goods> goodsList=new ArrayList<Goods>();
         // 创建查询工具类
         IndexSearcher indexSearcher=null;
         try {
             QueryParser parse=new QueryParser(Version.LUCENE_30,"gname",Configuraction.getAnalyzer());
             // 解析要查询的关键字:返回的是Query类型
             Query query=parse.parse(gname);
             indexSearcher=new IndexSearcher(Configuraction.getDirectory());
             // indexSearch做查询操作: n 用户期望查询结果数,后面做分页使用
             // 0 1 2 3 4 [5 6 7 8 9]
             TopDocs topDocs=indexSearcher.search(query,currentPage*size);
             /*
              * TopDocs:
              *     totalHits: 实际查询到的结果数
              *     scoreDocs[]: 存储了所有符合条件的document 编号
              * */
             System.out.println("用户期待的数:" + currentPage*size);
             System.out.println("索引库实际拥有结果数为:" + topDocs.totalHits);
             // 存储的是document在lucenen中的逻辑编号
             ScoreDoc[] docs=topDocs.scoreDocs;  //[0]=0 [1]=1
             System.out.println("真实拿出来了文档编号数" + docs.length);
             /*
              * ScoreDoc:
              *     doc: 文档逻辑编号
              *     score: 当前文档得分
              *
              * */
             for(int i=(currentPage-1)*size;i<docs.length;i++){
                 //System.out.println("文档的编号:" + docs[i].doc);
                 //System.out.println("此文档的得分:" + docs[i].score);
                 // 通过文档的编号获取真正的文档
                 Document doc=indexSearcher.doc(docs[i].doc);
                 goodsList.add(DocumentUtil.DocumentToGoods(doc));
             }
         } catch (Exception e) {
             e.printStackTrace();
             throw new RuntimeException(e);
         }
         return goodsList;
     }

分页的原理分析：

Search(query,10000),和Search(query,1)都不会影响topDocs.totalHits这个结果, 这个结果是Lucene索引库命中率的次数(也就是命中的Tearm的数量)那么可能会出现 totalHits大或者currentPage * PAGE_SIZE大的情况. 所以真正截取的时候,选最小的.int endNuM = Math.min(topDocs.totalHits, currentPage * PAGE_SIZE);而且分页的话,不是从开始处,开始所以真正的代码为:for (int i = (currentPage - 1) * PAGE_SIZE; i < endNuM; i++)

IndexWriter存在的问题

IndexWriter: 则必须要用单态模式独占.因为每一个Writer都需要lock文件,IndexWriter本身是操作类,支持多线程,所以一个全局的IndexWriter即可

 @Test
 public void testIndexWriter()throws Exception{
         IndexWriter    indexWriter = new IndexWriter(Configuraction.getDirectory(),Configuraction.getAnalyzer(), MaxFieldLength.LIMITED);
         IndexWriter    indexWriter2 = new IndexWriter(Configuraction.getDirectory(),Configuraction.getAnalyzer(), MaxFieldLength.LIMITED);
     }

异常信息如下：

org.apache.lucene.store.LockObtainFailedException: Lock obtain timed out: NativeFSLock@D:\workspace\lucene3.0\indexData\write.lock

IndexWriter优化

 package cn.index;

 import java.io.IOException;

 import org.apache.lucene.index.CorruptIndexException;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriter.MaxFieldLength;
 import org.apache.lucene.search.IndexSearcher;

 /*
  * 把indexWriter:设置全局唯一的,项目只负责使用, 由LuceneUtil负责创建和销毁
  *
  * */

 public class LuceneUtil {

     private static IndexWriter indexWriter = null;
     // 每一个indexSearcher在创建的时候就给索引库拍了一个快照,后面对索引库更新的操作都不能识别
     // 也类MYSQL：隔离级别3： 可重复读
     private static IndexSearcher indexSearcher=null;

     public static IndexSearcher getIndexSearcher() {
         // 判断是否有IndexSearcher如果没有则创建一个
         if(indexSearcher==null){
             synchronized(LuceneUtil.class){
                 if(indexSearcher==null){
                     try {
                         indexSearcher=new IndexSearcher(Configuraction.getDirectory());
                     } catch (Exception e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                         new RuntimeException(e);
                     }
                 }
             }
         }
         return indexSearcher;
     }

     public static IndexWriter getIndexWriter() {
         // 获取IndexWriter的时候说明要操作索引库,此时关闭前面的indexSearch
         // indexSearcher
         closeIndexSearch(indexSearcher);
         // 把全局变量设置为null
         indexSearcher=null;
         return indexWriter;
     }

     private static void closeIndexWriter(IndexWriter indexWriter){
         if(indexWriter!=null){
             try {
                 indexWriter.optimize();
                 indexWriter.close();
             } catch (IOException e) {
                 e.printStackTrace();
                 throw new RuntimeException(e);
             }
         }
     }

     private static void closeIndexSearch(IndexSearcher indexSearcher){
         if(indexSearcher!=null){
             try {
                 indexSearcher.close();
             } catch (IOException e) {
                 e.printStackTrace();
                 throw new RuntimeException(e);
             }
         }
     }

     static {
         try {
             // 加载LuceneUtil执行indexWriter创建
             indexWriter = new IndexWriter(Configuraction.getDirectory(),
                     Configuraction.getAnalyzer(), MaxFieldLength.LIMITED);
             // 程序关闭的时候要释放资源
             Runtime.getRuntime().addShutdownHook(new Thread(){
                 public void run(){
                     System.out.println("----run-----");
                     // 程序结束的时候关闭indexWriter
                     closeIndexWriter(indexWriter);
                 }
             });
         } catch (Exception e) {
             e.printStackTrace();
             throw new RuntimeException(e);
         }
     }
 }