Lucene框架入门实例

一 简介

Lucene属于Apache开源项目的一部分，是一个开源的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）

Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。在Java开发环境里Lucene是一个成熟的免费开源工具。就其本身而言，Lucene是当前以及最近几年最受欢迎的免费Java信息检索程序库。人们经常提到信息检索程序库，虽然与搜索引擎有关，但不应该将信息检索程序库与搜索引擎相混淆

注：以上介绍参考至百度百科

在使用Lucene建立索引时，可以选择将索引文件存储在内存中或者磁盘里。下面我将分别介绍基于这两种存储方式的全文索引的创建与检索

二 基于内存的索引创建与检索

首先需要做的是下载相关的jar包，下载地址是：http://lucene.apache.org/core/downloads.html

其次，在正式介绍下面的内容之前，至少需要导入以下三个jar包：

• lucene-analyzers-common-6.2.1.jar

• lucene-core-6.2.1.jar

• lucene-queryparser-6.2.1.jar

基于内存的全文索引示例代码如下：

package cn.zifangsky.lucene;

 

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

 

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.document.StringField;

import org.apache.lucene.document.TextField;

import org.apache.lucene.index.DirectoryReader;

import org.apache.lucene.index.IndexReader;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.IndexWriterConfig;

import org.apache.lucene.queryparser.classic.ParseException;

import org.apache.lucene.queryparser.classic.QueryParser;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.ScoreDoc;

import org.apache.lucene.store.Directory;

import org.apache.lucene.store.RAMDirectory;

 

public class Demo1 {

 

    /**

     * 创建索引

     * 

     * @param sourceMap

     *            待索引的内容

     * @return

     */

    public static Directory createIndex(Map<String, String> sourceMap) {

        //1 创建一个默认的词法分析器

        Analyzer analyzer = new StandardAnalyzer();

 

        //2 设置索引文件存储位置，可以存储到磁盘和内存中，这里设置为存储到内存

        Directory directory = new RAMDirectory(); // 存储到内存

 

        //3 索引的写入

        IndexWriterConfig config = new IndexWriterConfig(analyzer);

        try {

            IndexWriter indexWriter = new IndexWriter(directory, config);

 

            //将内容添加到索引中，每本书表示一个“文档”，并将每个文档进行存储

            if (!sourceMap.isEmpty()) {

                for (Entry<String, String> source : sourceMap.entrySet()) {

                    Document document = new Document();

                    //标题需要分词，使用TextField

                    document.add(new TextField("title", source.getKey(), Field.Store.YES));

                    //作者不需要分词，使用StringField

                    document.add(new StringField("author", source.getValue(), Field.Store.YES));

                    indexWriter.addDocument(document);

                }

            }

            indexWriter.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

        return directory;

    }

 

    /**

     * 搜索

     * 

     * @param directory

     * @param searchWord

     *            搜索关键词

     */

    public static void readIndex(Directory directory, String searchWord) {

        int preHits = 10; //获取前面多少个结果

 

        try {

            //1 打开一个文档

            IndexReader indexReader = DirectoryReader.open(directory);

            IndexSearcher indexSearcher = new IndexSearcher(indexReader);

            Analyzer analyzer = new StandardAnalyzer();

 

            //2 设置使用关键字检索，这里是检索标题

            QueryParser parser = new QueryParser("title", analyzer);

            Query query = parser.parse(searchWord);

 

            //3 获取检索到的结果

            System.out.println("总共有 " + indexSearcher.count(query) + " 个结果");

            ScoreDoc[] hits = indexSearcher.search(query, preHits).scoreDocs;

 

            System.out.println("当前有 " + hits.length + " 个结果，内容分别如下：");

            //遍历检索到的“文档”

            for (int i = 0; i < hits.length; i++) {

                int docId = hits[i].doc;

                Document hitDoc = indexSearcher.doc(docId);

                System.out.println("《 " + hitDoc.get("title") + "》    作者： " + hitDoc.get("author"));

            }

            indexReader.close();

        } catch (IOException | ParseException e) {

            e.printStackTrace();

        }

    }

 

    public static void main(String[] args) {

        Map<String, String> books = new HashMap<>();

        books.put("Java编程思想", "Bruce Eckel");

        books.put("Java8实战", "Raoul-Gabriel Urma");

        books.put("Spring入门经典", "Mert Caliskan");

        books.put("Spring实战", "Craig Walls");

        books.put("Spring Boot实战", "汪云飞");

        books.put("Redis实战", "Josiah L. Carlson");

 

        Directory directory = Demo1.createIndex(books);

        Demo1.readIndex(directory, "Spring");

//      Demo1.readIndex(directory, "实战");

    }

}

上面代码并不复杂，而且还有详细的注释，因此一些细节流程我就不多做介绍了。只是需要强调的一点是：

在创建索引时使用了这样的代码：

document.add(new TextField("title", source.getKey(), Field.Store.YES));

其中，上面的Field.Store.YES表示在创建索引的同时将内容的原文（也就是：source.getKey()）也存储到内存中。如果我们选择了Field.Store.NO，在创建索引和检索的时候都是没问题的，但是在最后是没法提取检索关键字所在的原文内容的

最后的输出结果如下：

总共有 3 个结果

当前有 3 个结果，内容分别如下：

《 Spring Boot实战》    作者： 汪云飞

《 Spring实战》    作者： Craig Walls

《 Spring入门经典》    作者： Mert Caliskan

三 基于磁盘的索引创建与检索

示例代码如下：

package cn.zifangsky.lucene;

 

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.FilenameFilter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

 

import org.apache.lucene.analysis.Analyzer;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field.Store;

import org.apache.lucene.document.StringField;

import org.apache.lucene.document.TextField;

import org.apache.lucene.index.DirectoryReader;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.IndexWriterConfig;

import org.apache.lucene.queryparser.classic.QueryParser;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.ScoreDoc;

import org.apache.lucene.store.Directory;

import org.apache.lucene.store.FSDirectory;

 

public class Demo2 {

 

    public static void main(String[] args) {

        Demo2.createIndex("D:/test/source", "D:/test/index");

        Demo2.searchIndex("D:/test/index", "apache");

    }

 

    /**

     * 给一个目录下的所有文本文件创建索引

     * 

     * @param sourceDir

     *            待索引的文件目录

     * @param indexDir

     *            索引文件存储目录

     * @return

     */

    public static void createIndex(String sourceDir, String indexDir) {

        List<File> fileList = getFileList(sourceDir);

 

        if (fileList.size() > 0) {

            // 遍历文件并分别创建索引

            for (File file : fileList) {

                StringBuffer stringBuffer = new StringBuffer();

                stringBuffer.append(getFileContent(file));

 

//              System.out.println("fileName: " + file.getName() + "    filePath: " + file.getPath());

 

                Analyzer analyzer = new StandardAnalyzer();

                try {

                    File indexFile = new File(indexDir);

                    if (!indexFile.exists()) {

                        indexFile.mkdirs();

                    }

 

                    //存储到文件中

                    Directory directory = FSDirectory.open(new File(indexDir).toPath());

                    IndexWriterConfig config = new IndexWriterConfig(analyzer);

                    IndexWriter indexWriter = new IndexWriter(directory, config);

 

                    Document document = new Document();

                    document.add(new TextField("fileName", file.getName(), Store.YES));

                    document.add(new TextField("content", stringBuffer.toString(), Store.YES));

                    document.add(new StringField("path", file.getPath(), Store.YES));

 

                    indexWriter.addDocument(document);

                    indexWriter.commit();

 

                    indexWriter.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

 

    /**

     * 在索引目录下检索关键字

     * 

     * @param indexDir

     *            索引文件存储目录

     * @param searchWord

     *            搜索的关键字

     */

    public static void searchIndex(String indexDir, String searchWord) {

        Analyzer analyzer = new StandardAnalyzer();

 

        try {

            //从一个磁盘目录中检索

            Directory directory = FSDirectory.open(new File(indexDir).toPath());

            DirectoryReader directoryReader = DirectoryReader.open(directory);

            IndexSearcher indexSearcher = new IndexSearcher(directoryReader);

 

            // 检索正文

            QueryParser queryParser = new QueryParser("content", analyzer);

            Query query = queryParser.parse(searchWord);

 

            // 检索前1000个结果

            System.out.println("总共有 " + indexSearcher.count(query) + " 个结果");

            ScoreDoc[] hits = indexSearcher.search(query, 1000).scoreDocs;

 

            System.out.println("当前有 " + hits.length + " 个结果，分别如下：");

            for (int i = 0; i < hits.length; i++) {

                int docId = hits[i].doc;

                Document hitDoc = indexSearcher.doc(docId);

                System.out.println("文件名： " + hitDoc.get("fileName") + "    路径： " + hitDoc.get("path"));

                // System.out.println(hitDoc.get("content"));

            }

            directoryReader.close();

            directory.close();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

 

    /***

     * 获取一个目录下的所有文件

     * 

     * @param sourceDir

     *            文件目录

     * @return 所有文件的集合

     */

    private static List<File> getFileList(String sourceDir) {

        File dir = new File(sourceDir);

        if (dir.isDirectory()) {

            // 返回指定格式的文本文件

            File[] files = dir.listFiles(new FilenameFilter() {

 

                public boolean accept(File dir, String name) {

                    return name.endsWith(".txt") || name.endsWith(".log") || name.endsWith(".xml");

                }

            });

 

            List<File> fileList = new ArrayList<File>();

            if (files.length > 0) {

                for (File tmpFile : files) {

                    fileList.add(tmpFile);

                }

            }

            return fileList;

        }

        return null;

    }

 

    /**

     * 获取一个文本文件的所有内容

     * 

     * @param file

     * @return

     */

    private static StringBuffer getFileContent(File file) {

        try {

//          BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));

            BufferedReader reader = new BufferedReader(new FileReader(file));

            String line = null;

            StringBuffer stringBuffer = new StringBuffer();

            while ((line = reader.readLine()) != null) {

                stringBuffer.append(line + "\n");

            }

 

            reader.close();

            return stringBuffer;

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

}

从上面的代码可以看出，索引存储到内存或者磁盘上，其基本步骤是差不多的，只是使用的类稍有区别。同时多了一些基本的IO操作代码，包括文件的读写等操作

运行上面的索引创建方法之后，打开磁盘上的“D:/test/index”，可以发现多了很多这样的文件：

最后，检索关键字“apache”，检索到的结果如下：

总共有 3 个结果

当前有 3 个结果，分别如下：

文件名： Lucene简介.txt    路径： D:\test\source\Lucene简介.txt

文件名： H5_ws.log    路径： D:\test\source\H5_ws.log

文件名： Shiro简介.txt    路径： D:\test\source\Shiro简介.txt

可以发现，有三个文件包含“apache”这个关键字

至此，Lucene的入门介绍到此结束

Lucene例子下载地址：http://download.csdn.net/download/qq_35222232/9954723