2.lucene入门-保持数据库与索引库的同步

保持数据库与索引库的同步

说明：在一个系统中，如果索引功能存在，那么数据库和索引库应该是同时存在的。这个时候需要保证索引库的数据和数据库中的数据保持一致性。可以在对数据库进行增、删、改操作的同时对索引库也进行相应的操作。这样就可以保证数据库与索引库的一致性。

1.

package com.home.utils;

import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.Field.Index;
import org.apache.lucene.document.Field.Store;
import org.w3c.dom.ranges.DocumentRange;

public class DocumentUtils {

    public static Document article2Document(Article article) {

        Document document = new Document();
        Field idField = new Field("id", article.getId().toString(), Store.YES,
                Index.NOT_ANALYZED);
        Field titleField = new Field("title", article.getTitle(), Store.YES,
                Index.ANALYZED);
        Field contentField = new Field("content", article.getContent(),
                Store.YES, Index.ANALYZED);
        document.add(idField);
        document.add(titleField);
        document.add(contentField);

        return document;
    }

    public static Article document2Article(Document document) {
        Article article = new Article();
        article.setId(Long.parseLong(document.get("id")));
        article.setTitle(document.get("title"));
        article.setContent(document.get("content"));
        return article;
    }
    
    
}

 

2.

package com.home.utils;

import java.io.File;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;

public class LuceneUtils {

    public static Directory directory;
    public static Analyzer analyzer;

    static {
        try {
            directory = FSDirectory.open(new File("E:\\s"));
            analyzer = new StandardAnalyzer(Version.LUCENE_30);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    
}

 

3.

package com.home.utils;

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

import org.apache.lucene.document.Document;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriter.MaxFieldLength;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.search.TopScoreDocCollector;
import org.apache.lucene.store.LockObtainFailedException;
import org.apache.lucene.util.Version;
import org.junit.Test;

import com.sun.org.apache.xerces.internal.impl.xpath.regex.ParseException;

public class ArticleIndex {

    @Test
    public void testCreateIndex() throws Exception {
        Article article = new Article();
        article.setId(1L);
        article.setTitle("lucene可以做搜索引擎");
        article.setContent("baidu,google都是很好的搜索引擎");

        IndexWriter indexWriter = new IndexWriter(LuceneUtils.directory,
                LuceneUtils.analyzer, MaxFieldLength.LIMITED);
        indexWriter.addDocument(DocumentUtils.article2Document(article));
        indexWriter.close();

    }

    @Test
    public void testSearchIndex() throws Exception {

        IndexSearcher indexSearcher = new IndexSearcher(LuceneUtils.directory);
        // 使用MultiFieldQueryParser进行多字段搜索
        QueryParser parser = new MultiFieldQueryParser(Version.LUCENE_30,
                new String[] { "id", "content" }, LuceneUtils.analyzer);
        Query query = parser.parse("baidu");
        TopDocs topDocs = indexSearcher.search(query, 2);
        ScoreDoc[] scDocs = topDocs.scoreDocs;
        List<Article> articleList = new ArrayList<Article>();
        for (ScoreDoc doc : scDocs) {
            Document document = indexSearcher.doc(doc.doc);
            Article article = DocumentUtils.document2Article(document);
            articleList.add(article);
        }
        

        for (Article article : articleList) {
            System.out.println(article.getId());
            System.out.println(article.getTitle());
            System.out.println(article.getContent());
        }

    }

    /**
     * 一般情况下索引库的删除用关键词
     * 
     * @throws Exception
     */
    @Test
    public void testDeleteIndex() throws Exception {
        IndexWriter indexWriter = new IndexWriter(LuceneUtils.directory,LuceneUtils.analyzer,MaxFieldLength.LIMITED);
        //indexWriter.deleteAll()删除所有的索引值
          /**
          * term就为关键词对象
          */
        Term term = new Term("title", "lucene");
        indexWriter.deleteDocuments(term);
        indexWriter.close();
    }
    
    /**
      * 修改
      *    先删除后增加
      */
     @Test
     public void testUpdateIndex() throws Exception{
      IndexWriter indexWriter = new IndexWriter(LuceneUtils.directory,LuceneUtils.analyzer,MaxFieldLength.LIMITED);
      Term term = new Term("title", "lucene");
      Article article = new  Article();
      article.setId(1L);
      article.setTitle("lucene可以做搜索引擎");
      article.setContent("修改后的内容");
      /**
      * term是用删除的
      * document是用于增加的
      */
      indexWriter.updateDocument(term, DocumentUtils.article2Document(article));
      indexWriter.close();
     
    }
     
     
     public void create () throws CorruptIndexException, LockObtainFailedException, IOException{
          Article article = new  Article();
          article.setId(1L);
          article.setTitle("lucene可以做搜索引擎");
          article.setContent("baidu,google都是很好的搜索引擎");
          IndexWriter indexWriter=new IndexWriter(LuceneUtils.directory, LuceneUtils.analyzer, MaxFieldLength.LIMITED);
          indexWriter.addDocument(DocumentUtils.article2Document(article));
          indexWriter.close();
         }

         

        @Test
         public void Query() throws CorruptIndexException, IOException,
           ParseException, org.apache.lucene.queryParser.ParseException {
          IndexSearcher indexSearcher = new IndexSearcher(LuceneUtils.directory);
          QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_30,
            new String[] { "title", "content" }, LuceneUtils.analyzer);

          TopDocs topDocs = indexSearcher.search(queryParser.parse("lucene"), 2);
          ScoreDoc[] scoreDocs = topDocs.scoreDocs;
          List<Article> articleList = new ArrayList<Article>();
          for (ScoreDoc scoreDoc : scoreDocs) {
           System.err.println("相关度为" + scoreDoc.score);
           Document document = indexSearcher.doc(scoreDoc.doc);
           Article article = DocumentUtils.document2Article(document);
           articleList.add(article);
          }
          for (Article article : articleList) {
           System.out.println(article.getId());
           System.out.println(article.getTitle());
           System.out.println(article.getContent());
          }
         }

         

        @Test
         public void delete() throws CorruptIndexException, LockObtainFailedException, IOException{
          IndexWriter indexWriter=new IndexWriter(LuceneUtils.directory, LuceneUtils.analyzer, MaxFieldLength.LIMITED);
          // indexWriter.deleteAll()删除所有的索引值
            /**
            * term就为关键词对象
            */
          indexWriter.deleteDocuments(new Term("title","lucene"));
          indexWriter.close();
         
         }

         

        /**
          *
          * 修改 先删除后增加
          * @throws IOException
          * @throws CorruptIndexException
          *
          */
         @Test
         public void update() throws CorruptIndexException, IOException {
          IndexWriter indexWriter = new IndexWriter(LuceneUtils.directory,
            LuceneUtils.analyzer, MaxFieldLength.LIMITED);
          Term term = new Term("title", "lucene");
          Article article = new Article();
          article.setId(1L);
          article.setTitle("lucene可以做搜索引擎");
          article.setContent("修改后的内容");
          /**
          * term是用删除的 document是用于增加的
          */
          indexWriter.updateDocument(term,
            DocumentUtils.article2Document(article));
          indexWriter.close();
         }

         
}