*lucene索引_的删除和更新

【删除】

【恢复删除】

【强制删除】

【优化和合并】

【更新索引】

附：

代码：

IndexUtil.java：

package cn.hk.index;

import java.io.File;
import java.io.IOException;

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.IndexWriterConfig;
import org.apache.lucene.index.StaleReaderException;
import org.apache.lucene.index.Term;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.util.Version;

public class IndexUtil {
    private String[] ids = {"1","2","3","4","5","6"};
    private String[] emails = {"aa@hk.arg","bb@hk.org","cc@hk.arg",
                               "dd@hk.org","ee@hk.org","ff@hk.org"};
    private String[] content = {
            "welcome to visited the space","hello boy","my name is aa","i like football",
            "I like football and I like Basketball too","I like movie and swim"
    };
    private int[] attachs = {2,3,1,4,5,5};
    private String[] names = {"zhangsan","lisi","john","mike","jetty","jake"};
    
    private Directory directory = null;
    
    public IndexUtil(){
        try {
            directory = FSDirectory.open(new File("d://lucene/index02"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void update(){
        IndexWriter writer =null;
        try {
            writer = new IndexWriter(directory,
                    new IndexWriterConfig(Version.LUCENE_35,new StandardAnalyzer(Version.LUCENE_35)));
            /*
             * lucene并没有提供更新的方法，这里的更新其实是提供如下两个操作：
             * 先删除之后再添加
             */
            Document doc = new Document();
            doc.add(new Field("id","11",Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
            doc.add(new Field("email",emails[0],Field.Store.YES,Field.Index.NOT_ANALYZED));
            doc.add(new Field("content",content[0],Field.Store.NO,Field.Index.ANALYZED));
            doc.add(new Field("name",names[0],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
            writer.updateDocument(new Term("id","1"),doc);
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(writer != null)
                try {
                    writer.close();
                } catch (CorruptIndexException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
        
    }
    
    
    public void merge(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory,
                    new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            //会将索引合并为2段，这两段中的被删除的数据会被清空
            //特别注意：此处在lucene3.5后不建议使用，因为会消耗大量的开销，
            //lucene会根据情况自动处理的
            writer.forceMerge(2);
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(writer != null)
                try {
                    writer.close();
                } catch (CorruptIndexException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
    
    public void forceDelete(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory,
                    new IndexWriterConfig(Version.LUCENE_35,new StandardAnalyzer(Version.LUCENE_35)));
            writer.forceMergeDeletes();
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(writer != null)
                try {
                    writer.close();
                } catch (CorruptIndexException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }
    }
    
    
    public void undelete(){
        //使用IndexReader进行恢复
        try {
            IndexReader reader = IndexReader.open(directory,false);
            //回复时，必须把IndexReader的只读（readyonly）设置为FALSE
            reader.undeleteAll();
            reader.close();
        } catch (StaleReaderException e) {
            
            e.printStackTrace();
        } catch (CorruptIndexException e) {
            
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    
    
    
    
    public void delete(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory,
                    new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            //删除ID为1的文档
            //参数可以是一个选项，可以是一个Query，也可以是一个Term，Term是一个精确查找的值
            //此时删除的文档并不会被完全删除，而是存储在回收站中的，可以恢复
            writer.deleteDocuments(new Term("id","1"));
        } catch (CorruptIndexException e) {
            
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            
            e.printStackTrace();
        }finally{
            if(writer != null)
                try {
                    writer.close();
                } catch (CorruptIndexException e) {
                    
                    e.printStackTrace();
                } catch (IOException e) {
                    
                    e.printStackTrace();
                }
        }
    }
    
    
    
    public void query(){
        try {
            IndexReader reader = IndexReader.open(directory);
            //通过reader可以获取文档的数量
            System.out.println("numDocs:" + reader.numDocs());
            System.out.println("maxDocs" + reader.maxDoc());
            System.out.println("deleteDocs:" + reader.numDeletedDocs());
            reader.close();
        } catch (CorruptIndexException e) {
            
            e.printStackTrace();
        } catch (IOException e) {
            
            e.printStackTrace();
        }
    }
    
    
    public void index(){
        IndexWriter writer = null;
        try {
            writer = new IndexWriter(directory,new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35)));
            Document doc = null;
            for(int i=0;i<ids.length;i++){
                doc = new Document();
                doc.add(new Field("id",ids[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
                doc.add(new Field("email",emails[i],Field.Store.YES,Field.Index.NOT_ANALYZED));
                doc.add(new Field("content",content[i],Field.Store.NO,Field.Index.ANALYZED));
                doc.add(new Field("name",names[i],Field.Store.YES,Field.Index.NOT_ANALYZED_NO_NORMS));
                writer.addDocument(doc);
            }
        } catch (CorruptIndexException e) {
            e.printStackTrace();
        } catch (LockObtainFailedException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
                if(writer != null)
                    try {
                        writer.close();
                    } catch (CorruptIndexException e) {
                        
                        e.printStackTrace();
                    } catch (IOException e) {
                        
                        e.printStackTrace();
                    }
            
        }
    }

}

TestIndex.java：

package cn.hk.test;

import org.junit.Test;

import cn.hk.index.IndexUtil;

public class TestIndex {
    
    @Test
    public void testIndex(){
        IndexUtil iu = new IndexUtil();
        iu.index();
    }
    
    @Test
    public void testQuery(){
        IndexUtil iu = new IndexUtil();
        iu.query();
    }
    
    @Test
    public void testDelete(){
        IndexUtil iu = new IndexUtil();
        iu.delete();
    }
    
    @Test
    public void testUnDelete(){
        IndexUtil iu = new IndexUtil();
        iu.undelete();
    }
    
    @Test
    public void testForceDelete(){
        IndexUtil iu = new IndexUtil();
        iu.forceDelete();
    }
    
    public void testMerge(){
        IndexUtil  iu = new IndexUtil();
        iu.merge();
    }
    
    @Test
    public void testUpdate(){
        IndexUtil iu = new IndexUtil();
        iu.update();
    }
}