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);
        }
    }
}