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