lucene 建立CRUD操作

IndexSearcher indexSearcher = new IndexSearcher(LuceneUtils.getDirectory()); // 指定所用的索引库
这句会引发线程安全问题，在全剧终 IndexSearcher只能有一个对象才可以，所以在ArticleDocumentUtils中保存一个 并且引用它。
indexSearcher为了提高效率，也是在内存中有缓存的所以需要commit才能放入索引文件数据库中


数据库优化
  每次添加数据在索引文件夹下有很多小文件，为了合并小文件提高效率

//优化，合并多个小文件为一个打文件
LuceneUtils.getIndexWriter.optimize();


//配置当小文件的数量达到多少个后就自动合并为一个大文件，最小2，默认10
 LucenenUtils.getIndexWriter().setMergeFactor(3);
当增加数据的时候自动触发。

Lucene.java

package cn.itcast._util;

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

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.index.CorruptIndexException;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriter.MaxFieldLength;
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 LuceneUtils {

    private static Directory directory; // 索引库目录
    private static Analyzer analyzer; // 分词器

    private static IndexWriter indexWriter;

    static {
        try {
            // 这里应是读取配置文件得到的索引库目录
            directory = FSDirectory.open(new File("./indexDir"));
            analyzer = new StandardAnalyzer(Version.LUCENE_30);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取全局唯一的IndexWriter对象
     * 
     * @return
     */
    public static IndexWriter getIndexWriter() {
        // 在第一次使用IndexWriter是进行初始化
        if (indexWriter == null) {
            synchronized (LuceneUtils.class) { // 注意线程安全问题
                if (indexWriter == null) {
                    try {
                        indexWriter = new IndexWriter(directory, analyzer, MaxFieldLength.LIMITED);
                        System.out.println("=== 已经初始化 IndexWriter ===");
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            }

            // 指定一段代码，会在JVM退出之前执行。
            Runtime.getRuntime().addShutdownHook(new Thread() {
                public void run() {
                    try {
                        indexWriter.close();
                        System.out.println("=== 已经关闭 IndexWriter ===");
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }
            });
        }

        return indexWriter;
    }

    public static Directory getDirectory() {
        return directory;
    }

    public static Analyzer getAnalyzer() {
        return analyzer;
    }

}

ArticleDocumentUtils.java

package cn.itcast._util;

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.apache.lucene.util.NumericUtils;

import cn.itcast._domain.Article;

public class ArticleDocumentUtils {

    /**
     * 把Article转为Document
     * 
     * @param article
     * @return
     */
    public static Document articleToDocument(Article article) {
        Document doc = new Document();

        String idStr = NumericUtils.intToPrefixCoded(article.getId()); // 一定要使用Lucene的工具类把数字转为字符串！
        
        doc.add(new Field("id", idStr, Store.YES, Index.NOT_ANALYZED)); // 注意：唯一标示符一般选择Index.NOT_ANALYZED
        doc.add(new Field("title", article.getTitle(), Store.YES, Index.ANALYZED));
        doc.add(new Field("content", article.getContent(), Store.YES, Index.ANALYZED));

        return doc;
    }

    /**
     * 把Document转为Article
     * 
     * @param doc
     * @return
     */
    public static Article documentToArticle(Document doc) {
        Article article = new Article();
        
        Integer id = NumericUtils.prefixCodedToInt(doc.get("id")); // 一定要使用Lucene的工具类把字符串转为数字！
        
        article.setId(id);
        article.setTitle(doc.get("title"));
        article.setContent(doc.get("content"));
        
        return article;
    }

}

QueryResult.java

package cn.itcast._domain;

import java.util.List;

public class QueryResult {
    private List list; // 一段数据列表
    private int count; // 总记录数

    public QueryResult(List list, int count) {
        this.list = list;
        this.count = count;
    }

    public List getList() {
        return list;
    }

    public void setList(List list) {
        this.list = list;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

}

ArticleIndexDao.java

package cn.itcast.b_indexdao;

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

import org.apache.lucene.document.Document;
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.TopDocs;
import org.apache.lucene.util.NumericUtils;
import org.apache.lucene.util.Version;

import cn.itcast._domain.Article;
import cn.itcast._domain.QueryResult;
import cn.itcast._util.ArticleDocumentUtils;
import cn.itcast._util.LuceneUtils;

public class ArticleIndexDao {

    /**
     * 保存到索引库（建立索引）
     * 
     * @param article
     */
    public void save(Article article) {
        // 1，把Article转为Document
        Document doc = ArticleDocumentUtils.articleToDocument(article);

        // 2，添加到索引库中
        try {
            LuceneUtils.getIndexWriter().addDocument(doc); // 添加
            LuceneUtils.getIndexWriter().commit(); // 提交更改
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 删除索引
     * 
     * Term ：某字段中出现的某一个关键词（在索引库的目录中）
     * 
     * @param id
     */
    public void delete(Integer id) {
        try {
            String idStr = NumericUtils.intToPrefixCoded(id); // 一定要使用Lucene的工具类把数字转为字符串！
            Term term = new Term("id", idStr);

            LuceneUtils.getIndexWriter().deleteDocuments(term); // 删除所有含有这个Term的Document
            LuceneUtils.getIndexWriter().commit(); // 提交更改
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 更新索引
     * 
     * @param article
     */
    public void update(Article article) {
        try {
            Term term = new Term("id", NumericUtils.intToPrefixCoded(article.getId())); // 一定要使用Lucene的工具类把数字转为字符串！
            Document doc = ArticleDocumentUtils.articleToDocument(article);

            LuceneUtils.getIndexWriter().updateDocument(term, doc); // 更新就是先删除再添加
            LuceneUtils.getIndexWriter().commit(); // 提交更改

            // indexWriter.deleteDocuments(term);
            // indexWriter.addDocument(doc);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * * 搜索   用于分页的
     * 
     * @param queryString
     *            查询条件
     * @param first
     *            从结果列表的哪个索引开始获取数据
     * @param max
     *            最多获取多少条数据（如果没有这么多，就把剩余的都返回）
     * 
     * @return 一段数据列表 + 符合条件的总记录数
     */
    public QueryResult search(String queryString, int first, int max) {
        IndexSearcher indexSearcher = null;
        try {
            // 1，把查询字符串转为Query对象（在title与content中查询）
            QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_30, new String[] { "title", "content" }, LuceneUtils.getAnalyzer());
            Query query = queryParser.parse(queryString);

            // 2，执行查询，得到中间结果
            indexSearcher = new IndexSearcher(LuceneUtils.getDirectory());
            TopDocs topDocs = indexSearcher.search(query, first + max); // 最多返回前n条数据，这里要计算好，要返回足够数量的数据
            int count = topDocs.totalHits; // 符合条件的总记录数

            // 3，处理数据
            List<Article> list = new ArrayList<Article>();
            int endIndex = Math.min(first + max, topDocs.scoreDocs.length); // 计算结束的边界

            for (int i = first; i < endIndex; i++) { // 应只取一段数据
                // 根据内部编号获取真正的Document数据
                int docId = topDocs.scoreDocs[i].doc;
                Document doc = indexSearcher.doc(docId);
                // 把Document转换为Article
                Article article = ArticleDocumentUtils.documentToArticle(doc);
                list.add(article);
            }

            // 4，封装结果并返回
            return new QueryResult(list, count);

        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            // 关闭IndexSearcher
            if (indexSearcher != null) {
                try {
                    indexSearcher.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

不分页的查询

LuceneUtils.getIndexWriter()

    public List<Article> searchArticle(String condition) {
        // 执行搜索
        List<Article> list = new ArrayList<Article>();
        IndexSearcher indexSearcher = null;
        try {
            // 1，把查询字符串转为Query对象（默认只从title中查询）
            QueryParser queryParser = new MultiFieldQueryParser(
                    Version.LUCENE_30, new String[] { "title", "content" },
                    LuceneUtils.getAnalyzer());
            Query query = queryParser.parse(condition);

            // 2，执行查询，得到中间结果
            //indexSearcher = new IndexSearcher(LuceneUtils.getDirectory()); // 指定所用的索引库，会引发线程安全问题
　　　　　　　　　indexSearcher=LuceneUtils.getIndexWriter();

            TopDocs topDocs = indexSearcher.search(query, 1000); // 最多返回前n条结果
            int count = topDocs.totalHits;
            System.out.println("scoreDocs.length"+topDocs.scoreDocs.length);        //一样
            System.out.println("count"+count);                //一样
            ScoreDoc[] scoreDocs = topDocs.scoreDocs;

            // 3，处理结果
            for (int i = 0; i < scoreDocs.length; i++) {
                ScoreDoc scoreDoc = scoreDocs[i];
                float score = scoreDoc.score; // 相关度得分
                int docId = scoreDoc.doc; // Document的内部编号

                // 根据编号拿到Document数据
                Document document = indexSearcher.doc(docId);

                // 把Document转为Article
                Article article=ArticleDocumentUtils.documentToArticle(document);

                list.add(article);
            }
        } catch (Exception e) {
            throw new RuntimeException();
        } finally {
            try {
                if (null != indexSearcher)
                    indexSearcher.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return list;
    }

ArticleIndexDaoTest.java

package cn.itcast.b_indexdao;

import java.util.List;

import org.junit.Test;

import cn.itcast._domain.Article;
import cn.itcast._domain.QueryResult;

public class ArticleIndexDaoTest {

    private ArticleIndexDao indexDao = new ArticleIndexDao();

    @Test
    public void testSave() {
        // 准备数据
        Article article = new Article();
        article.setId(1);
        article.setTitle("准备Lucene的开发环境");
        article.setContent("如果信息检索系统在用户发出了检索请求后再去互联网上找答案，根本无法在有限的时间内返回结果。");

        // 放到索引库中
        indexDao.save(article);
    }

    @Test
    public void testSave_25() {
        for (int i = 1; i <= 25; i++) {
            // 准备数据
            Article article = new Article();
            article.setId(i);
            article.setTitle("准备Lucene的开发环境");
            article.setContent("如果信息检索系统在用户发出了检索请求后再去互联网上找答案，根本无法在有限的时间内返回结果。");

            // 放到索引库中
            indexDao.save(article);
        }
    }

    @Test
    public void testDelete() {
        indexDao.delete(1);
    }

    @Test
    public void testUpdate() {
        // 准备数据
        Article article = new Article();
        article.setId(1);
        article.setTitle("准备Lucene的开发环境");
        article.setContent("这是更新后的内容");

        // 更新到索引库中
        indexDao.update(article);
    }
    //用于分页的
    @Test
    public void testSearch() {
        // 准备查询条件
        String queryString = "lucene";
        // String queryString = "hibernate";

        // 执行搜索
        // QueryResult qr = indexDao.search(queryString, 0, 10000);

        // QueryResult qr = indexDao.search(queryString, 0, 10); // 第1页，每页10条
        // QueryResult qr = indexDao.search(queryString, 10, 10); // 第2页，每页10条
        QueryResult qr = indexDao.search(queryString, 20, 10); // 第3页，每页10条

        // 显示结果
        System.out.println("总结果数：" + qr.getCount());
        for (Article a : (List<Article>) qr.getList()) {
            System.out.println("------------------------------");
            System.out.println("id = " + a.getId());
            System.out.println("title = " + a.getTitle());
            System.out.println("content = " + a.getContent());
        }
    }

}

 不分页查询测试

@Test
    public void testSearchArticle() {
        // 准备查询条件
        String queryString = "lucene的";
        // String queryString = "hibernate";

        // 执行搜索
        List<Article> list =dao.searchArticle(queryString);
        
        // 显示结果
        System.out.println("总结果数：" + list.size());
        for (Article a : list) {
            System.out.println("------------------------------");
            System.out.println("id = " + a.getId());
            System.out.println("title = " + a.getTitle());
            System.out.println("content = " + a.getContent());
        }
    }