Apache Lucene初探

女爷i 2022-07-28 09:00 130阅读 0赞

## 讲解之前，先来分享一些资料 ##

**首先呢，学习任何一门新的亦或是旧的开源技术，百度其中一二是最简单的办法，先了解其中的大概，思想等等**。[这里就贡献一个讲解很到位的ppt][ppt]。已经被我转成了PDF，便于搜藏。

**其次，关于第一次编程初探，建议还是查看官方资料**。百度到的资料，目前Lucene已经更新到4.9版本，这个版本需要1.7以上的JDK，所以如果还用1.6甚至是1.5的小盆友，请参考低版本，由于我用的1.6，因此在使用Lucene4.0。

这是Lucene4.0的官网文档：***http://lucene.apache.org/core/4\_0\_0/core/overview-summary.html***

这里非常佩服Lucene的开元贡献者，可以阅读Lucene in Action，作者最初想要写软件赚钱，最后贡献给了Apache，跑题了。

**最后，提醒学习Lucene的小盆友们，这个开源软件的版本更新不慢，版本之间的编程风格亦是不同，所以如果百度到的帖子，可能这段代码，用了4.0或者3.6就会不好使。**

比如，以前版本的申请IndexWriter时，是这样的：

IndexWriter indexWriter  =   new IndexWriter(indexDir,luceneAnalyzer, true );

但是4.0，我们需要配置一个conf，把配置内容放到这个对象中：

IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_CURRENT, analyzer);
        IndexWriter iwriter = new IndexWriter(directory, config);

所以，请一定要**参考官方文档的编程风格，进行代码的书写**。

**最后的最后，[从官网上面下载下来的文件，已经上传至百度网盘，欢迎下载。][Link 1]**

![242144055348718.jpg][]

这是其中最常用的五个文件：

第一个，也是最重要的，**Lucene-core-4.0.0.jar**,其中包括了常用的文档，索引，搜索，存储等相关核心代码。

第二个，**Lucene-analyzers-common-4.0.0.jar**，这里面包含了各种语言的词法分析器，用于对文件内容进行关键字切分，提取。

第三个，**Lucene-highlighter-4.0.0.jar**，这个jar包主要用于搜索出的内容高亮显示。

第四个和第五个，**Lucene-queryparser-4.0.0.jar**，提供了搜索相关的代码，用于各种搜索，比如模糊搜索，范围搜索，等等。

--------------------

## 废话说到这里，下面我们简单的讲解一下什么是**全文检索**。 ##

比如，**我们一个文件夹中，或者一个磁盘中有很多的文件，记事本、world、Excel、pdf，我们想根据其中的关键词搜索包含的文件。例如，我们输入Lucene，所有内容含有Lucene的文件就会被检查出来。这就是所谓的全文检索**。

因此，很容易的我们想到，应该**建立一个关键字与文件的相关映射**，盗用ppt中的一张图，很明白的解释了这种映射如何实现。

![242153077539335.jpg][]

在Lucene中，就是使用这种“倒排索引”的技术，来实现相关映射。

--------------------

## 有了这种映射关系，我们就来看看**Lucene的架构设计**。 ##

下面是Lucene的资料必出现的一张图，但也是其精髓的概括。

![242155074404668.jpg][]

我们可以看到，Lucene的使用主要体现在两个步骤：

**1 创建索引，通过IndexWriter对不同的文件进行索引的创建，并将其保存在索引相关文件存储的位置中。**

**　　2 通过索引查寻关键字相关文档。**

下面针对官网上面给出的一个例子，进行分析：

![复制代码][copycode.gif]

1 　　Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);
     2 
     3     // Store the index in memory:
     4     Directory directory = new RAMDirectory();
     5     // To store an index on disk, use this instead:
     6     //Directory directory = FSDirectory.open("/tmp/testindex");
     7     IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_CURRENT, analyzer);
     8     IndexWriter iwriter = new IndexWriter(directory, config);
     9     Document doc = new Document();
    10     String text = "This is the text to be indexed.";
    11     doc.add(new Field("fieldname", text, TextField.TYPE_STORED));
    12     iwriter.addDocument(doc);
    13     iwriter.close();
    14     
    15     // Now search the index:
    16     DirectoryReader ireader = DirectoryReader.open(directory);
    17     IndexSearcher isearcher = new IndexSearcher(ireader);
    18     // Parse a simple query that searches for "text":
    19     QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "fieldname", analyzer);
    20     Query query = parser.parse("text");
    21     ScoreDoc[] hits = isearcher.search(query, null, 1000).scoreDocs;
    22     assertEquals(1, hits.length);
    23     // Iterate through the results:
    24     for (int i = 0; i < hits.length; i++) {
    25       Document hitDoc = isearcher.doc(hits[i].doc);
    26       assertEquals("This is the text to be indexed.", hitDoc.get("fieldname"));
    27     }
    28     ireader.close();
    29     directory.close();

![复制代码][copycode.gif]

## 索引的创建 ##

**首先，我们需要定义一个词法分析器。**

比如一句话，“我爱我们的中国！”，如何对他拆分，扣掉停顿词“的”，提取关键字“我”“我们”“中国”等等。这就要借助的词法分析器Analyzer来实现。这里面使用的是标准的词法分析器，如果专门针对汉语，还可以搭配paoding，进行使用。

1 Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);

参数中的Version.LUCENE\_CURRENT，代表使用当前的Lucene版本，本文环境中也可以写成Version.LUCENE\_40。

**第二步，确定索引文件存储的位置，Lucene提供给我们两种方式：**

1 本地文件存储

Directory directory = FSDirectory.open("/tmp/testindex");

2 内存存储

Directory directory = new RAMDirectory();

可以根据自己的需要进行设定。

**　第三步，创建IndexWriter，进行索引文件的写入。**

IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_CURRENT, analyzer);
    IndexWriter iwriter = new IndexWriter(directory, config);

这里的IndexWriterConfig，据官方文档介绍，是对indexWriter的配置，其中包含了两个参数，第一个是目前的版本，第二个是词法分析器Analyzer。

**第四步，内容提取，进行索引的存储。**

Document doc = new Document();
    String text = "This is the text to be indexed.";
    doc.add(new Field("fieldname", text, TextField.TYPE_STORED));
    iwriter.addDocument(doc);
    iwriter.close();

第一行，申请了一个document对象，这个类似于数据库中的表中的一行。

第二行，是我们即将索引的字符串。

第三行，把字符串存储起来（因为设置了TextField.TYPE\_STORED,如果不想存储，可以使用其他参数，详情参考官方文档），并存储“表明”为"fieldname".

第四行，把doc对象加入到索引创建中。

第五行，关闭IndexWriter,提交创建内容。

这就是索引创建的过程。

## 关键字查询： ##

**第一步，打开存储位置**

DirectoryReader ireader = DirectoryReader.open(directory);

**　　第二步，创建搜索器**

IndexSearcher isearcher = new IndexSearcher(ireader);

**　　第三步，类似SQL，进行关键字查询**

![复制代码][copycode.gif]

QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "fieldname", analyzer);
    Query query = parser.parse("text");
    ScoreDoc[] hits = isearcher.search(query, null, 1000).scoreDocs;
    assertEquals(1, hits.length);
    for (int i = 0; i < hits.length; i++) {
        Document hitDoc = isearcher.doc(hits[i].doc);
        assertEquals("This is the text to be indexed.",hitDoc.get("fieldname"));
    }

![复制代码][copycode.gif]

这里，我们创建了一个查询器，并设置其词法分析器，以及查询的“表名“为”fieldname“。查询结果会返回一个集合，类似SQL的ResultSet，我们可以提取其中存储的内容。

关于各种不同的查询方式，可以参考官方手册，或者推荐的PPT

**　第四步，关闭查询器等。**

ireader.close();
    directory.close();

--------------------

最后，博猪自己写了个简单的例子，可以**对一个文件夹内的内容进行索引的创建，并根据关键字筛选文件，并读取其中的内容**。

## 创建索引： ##

![复制代码][copycode.gif]

/**
         * 创建当前文件目录的索引
         * @param path 当前文件目录
         * @return 是否成功
         */
        public static boolean createIndex(String path){
            Date date1 = new Date();
            List<File> fileList = getFileList(path);
            for (File file : fileList) {
                content = "";
                //获取文件后缀
                String type = file.getName().substring(file.getName().lastIndexOf(".")+1);
                if("txt".equalsIgnoreCase(type)){
                    
                    content += txt2String(file);
                
                }else if("doc".equalsIgnoreCase(type)){
                
                    content += doc2String(file);
                
                }else if("xls".equalsIgnoreCase(type)){
                    
                    content += xls2String(file);
                    
                }
                
                System.out.println("name :"+file.getName());
                System.out.println("path :"+file.getPath());
    //            System.out.println("content :"+content);
                System.out.println();
                
                
                try{
                    analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);
                    directory = FSDirectory.open(new File(INDEX_DIR));
        
                    File indexFile = new File(INDEX_DIR);
                    if (!indexFile.exists()) {
                        indexFile.mkdirs();
                    }
                    IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_CURRENT, analyzer);
                    indexWriter = new IndexWriter(directory, config);
                    
                    Document document = new Document();
                    document.add(new TextField("filename", file.getName(), Store.YES));
                    document.add(new TextField("content", content, Store.YES));
                    document.add(new TextField("path", file.getPath(), Store.YES));
                    indexWriter.addDocument(document);
                    indexWriter.commit();
                    closeWriter();
        
                    
                }catch(Exception e){
                    e.printStackTrace();
                }
                content = "";
            }
            Date date2 = new Date();
            System.out.println("创建索引-----耗时：" + (date2.getTime() - date1.getTime()) + "ms\n");
            return true;
        }

![复制代码][copycode.gif]

## 进行查询： ##

![复制代码][copycode.gif]

/**
         * 查找索引，返回符合条件的文件
         * @param text 查找的字符串
         * @return 符合条件的文件List
         */
        public static void searchIndex(String text){
            Date date1 = new Date();
            try{
                directory = FSDirectory.open(new File(INDEX_DIR));
                analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);
                DirectoryReader ireader = DirectoryReader.open(directory);
                IndexSearcher isearcher = new IndexSearcher(ireader);
        
                QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "content", analyzer);
                Query query = parser.parse(text);
                
                ScoreDoc[] hits = isearcher.search(query, null, 1000).scoreDocs;
            
                for (int i = 0; i < hits.length; i++) {
                    Document hitDoc = isearcher.doc(hits[i].doc);
                    System.out.println("____________________________");
                    System.out.println(hitDoc.get("filename"));
                    System.out.println(hitDoc.get("content"));
                    System.out.println(hitDoc.get("path"));
                    System.out.println("____________________________");
                }
                ireader.close();
                directory.close();
            }catch(Exception e){
                e.printStackTrace();
            }
            Date date2 = new Date();
            System.out.println("查看索引-----耗时：" + (date2.getTime() - date1.getTime()) + "ms\n");
        }

![复制代码][copycode.gif]

## 全部代码: ##

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

1 package test;
      2 
      3 import java.io.BufferedReader;
      4 import java.io.File;
      5 import java.io.FileInputStream;
      6 import java.io.FileReader;
      7 import java.util.ArrayList;
      8 import java.util.Date;
      9 import java.util.List;
     10 
     11 import jxl.Cell;
     12 import jxl.Sheet;
     13 import jxl.Workbook;
     14 
     15 import org.apache.lucene.analysis.Analyzer;
     16 import org.apache.lucene.analysis.standard.StandardAnalyzer;
     17 import org.apache.lucene.document.Document;
     18 import org.apache.lucene.document.LongField;
     19 import org.apache.lucene.document.TextField;
     20 import org.apache.lucene.document.Field.Store;
     21 import org.apache.lucene.index.DirectoryReader;
     22 import org.apache.lucene.index.IndexWriter;
     23 import org.apache.lucene.index.IndexWriterConfig;
     24 import org.apache.lucene.queryparser.classic.QueryParser;
     25 import org.apache.lucene.search.IndexSearcher;
     26 import org.apache.lucene.search.Query;
     27 import org.apache.lucene.search.ScoreDoc;
     28 import org.apache.lucene.store.Directory;
     29 import org.apache.lucene.store.FSDirectory;
     30 import org.apache.lucene.util.Version;
     31 import org.apache.poi.hwpf.HWPFDocument;
     32 import org.apache.poi.hwpf.usermodel.Range;
     33 
     34 /**
     35  * @author xinghl
     36  *
     37  */
     38 public class IndexManager{
     39     private static IndexManager indexManager;
     40     private static String content="";
     41     
     42     private static String INDEX_DIR = "D:\\luceneIndex";
     43     private static String DATA_DIR = "D:\\luceneData";
     44     private static Analyzer analyzer = null;
     45     private static Directory directory = null;
     46     private static IndexWriter indexWriter = null;
     47     
     48     /**
     49      * 创建索引管理器
     50      * @return 返回索引管理器对象
     51      */
     52     public IndexManager getManager(){
     53         if(indexManager == null){
     54             this.indexManager = new IndexManager();
     55         }
     56         return indexManager;
     57     }
     58     /**
     59      * 创建当前文件目录的索引
     60      * @param path 当前文件目录
     61      * @return 是否成功
     62      */
     63     public static boolean createIndex(String path){
     64         Date date1 = new Date();
     65         List<File> fileList = getFileList(path);
     66         for (File file : fileList) {
     67             content = "";
     68             //获取文件后缀
     69             String type = file.getName().substring(file.getName().lastIndexOf(".")+1);
     70             if("txt".equalsIgnoreCase(type)){
     71                 
     72                 content += txt2String(file);
     73             
     74             }else if("doc".equalsIgnoreCase(type)){
     75             
     76                 content += doc2String(file);
     77             
     78             }else if("xls".equalsIgnoreCase(type)){
     79                 
     80                 content += xls2String(file);
     81                 
     82             }
     83             
     84             System.out.println("name :"+file.getName());
     85             System.out.println("path :"+file.getPath());
     86 //            System.out.println("content :"+content);
     87             System.out.println();
     88             
     89             
     90             try{
     91                 analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);
     92                 directory = FSDirectory.open(new File(INDEX_DIR));
     93     
     94                 File indexFile = new File(INDEX_DIR);
     95                 if (!indexFile.exists()) {
     96                     indexFile.mkdirs();
     97                 }
     98                 IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_CURRENT, analyzer);
     99                 indexWriter = new IndexWriter(directory, config);
    100                 
    101                 Document document = new Document();
    102                 document.add(new TextField("filename", file.getName(), Store.YES));
    103                 document.add(new TextField("content", content, Store.YES));
    104                 document.add(new TextField("path", file.getPath(), Store.YES));
    105                 indexWriter.addDocument(document);
    106                 indexWriter.commit();
    107                 closeWriter();
    108     
    109                 
    110             }catch(Exception e){
    111                 e.printStackTrace();
    112             }
    113             content = "";
    114         }
    115         Date date2 = new Date();
    116         System.out.println("创建索引-----耗时：" + (date2.getTime() - date1.getTime()) + "ms\n");
    117         return true;
    118     }
    119     
    120     /**
    121      * 读取txt文件的内容
    122      * @param file 想要读取的文件对象
    123      * @return 返回文件内容
    124      */
    125     public static String txt2String(File file){
    126         String result = "";
    127         try{
    128             BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件
    129             String s = null;
    130             while((s = br.readLine())!=null){
        //使用readLine方法，一次读一行
    131                 result = result + "\n" +s;
    132             }
    133             br.close();    
    134         }catch(Exception e){
    135             e.printStackTrace();
    136         }
    137         return result;
    138     }
    139     
    140     /**
    141      * 读取doc文件内容
    142      * @param file 想要读取的文件对象
    143      * @return 返回文件内容
    144      */
    145     public static String doc2String(File file){
    146         String result = "";
    147         try{
    148             FileInputStream fis = new FileInputStream(file);
    149             HWPFDocument doc = new HWPFDocument(fis);
    150             Range rang = doc.getRange();
    151             result += rang.text();
    152             fis.close();
    153         }catch(Exception e){
    154             e.printStackTrace();
    155         }
    156         return result;
    157     }
    158     
    159     /**
    160      * 读取xls文件内容
    161      * @param file 想要读取的文件对象
    162      * @return 返回文件内容
    163      */
    164     public static String xls2String(File file){
    165         String result = "";
    166         try{
    167             FileInputStream fis = new FileInputStream(file);   
    168             StringBuilder sb = new StringBuilder();   
    169             jxl.Workbook rwb = Workbook.getWorkbook(fis);   
    170             Sheet[] sheet = rwb.getSheets();   
    171             for (int i = 0; i < sheet.length; i++) {   
    172                 Sheet rs = rwb.getSheet(i);   
    173                 for (int j = 0; j < rs.getRows(); j++) {   
    174                    Cell[] cells = rs.getRow(j);   
    175                    for(int k=0;k<cells.length;k++)   
    176                    sb.append(cells[k].getContents());   
    177                 }   
    178             }   
    179             fis.close();   
    180             result += sb.toString();
    181         }catch(Exception e){
    182             e.printStackTrace();
    183         }
    184         return result;
    185     }
    186     /**
    187      * 查找索引，返回符合条件的文件
    188      * @param text 查找的字符串
    189      * @return 符合条件的文件List
    190      */
    191     public static void searchIndex(String text){
    192         Date date1 = new Date();
    193         try{
    194             directory = FSDirectory.open(new File(INDEX_DIR));
    195             analyzer = new StandardAnalyzer(Version.LUCENE_CURRENT);
    196             DirectoryReader ireader = DirectoryReader.open(directory);
    197             IndexSearcher isearcher = new IndexSearcher(ireader);
    198     
    199             QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "content", analyzer);
    200             Query query = parser.parse(text);
    201             
    202             ScoreDoc[] hits = isearcher.search(query, null, 1000).scoreDocs;
    203         
    204             for (int i = 0; i < hits.length; i++) {
    205                 Document hitDoc = isearcher.doc(hits[i].doc);
    206                 System.out.println("____________________________");
    207                 System.out.println(hitDoc.get("filename"));
    208                 System.out.println(hitDoc.get("content"));
    209                 System.out.println(hitDoc.get("path"));
    210                 System.out.println("____________________________");
    211             }
    212             ireader.close();
    213             directory.close();
    214         }catch(Exception e){
    215             e.printStackTrace();
    216         }
    217         Date date2 = new Date();
    218         System.out.println("查看索引-----耗时：" + (date2.getTime() - date1.getTime()) + "ms\n");
    219     }
    220     /**
    221      * 过滤目录下的文件
    222      * @param dirPath 想要获取文件的目录
    223      * @return 返回文件list
    224      */
    225     public static List<File> getFileList(String dirPath) {
    226         File[] files = new File(dirPath).listFiles();
    227         List<File> fileList = new ArrayList<File>();
    228         for (File file : files) {
    229             if (isTxtFile(file.getName())) {
    230                 fileList.add(file);
    231             }
    232         }
    233         return fileList;
    234     }
    235     /**
    236      * 判断是否为目标文件，目前支持txt xls doc格式
    237      * @param fileName 文件名称
    238      * @return 如果是文件类型满足过滤条件，返回true；否则返回false
    239      */
    240     public static boolean isTxtFile(String fileName) {
    241         if (fileName.lastIndexOf(".txt") > 0) {
    242             return true;
    243         }else if (fileName.lastIndexOf(".xls") > 0) {
    244             return true;
    245         }else if (fileName.lastIndexOf(".doc") > 0) {
    246             return true;
    247         }
    248         return false;
    249     }
    250     
    251     public static void closeWriter() throws Exception {
    252         if (indexWriter != null) {
    253             indexWriter.close();
    254         }
    255     }
    256     /**
    257      * 删除文件目录下的所有文件
    258      * @param file 要删除的文件目录
    259      * @return 如果成功，返回true.
    260      */
    261     public static boolean deleteDir(File file){
    262         if(file.isDirectory()){
    263             File[] files = file.listFiles();
    264             for(int i=0; i<files.length; i++){
    265                 deleteDir(files[i]);
    266             }
    267         }
    268         file.delete();
    269         return true;
    270     }
    271     public static void main(String[] args){
    272         File fileIndex = new File(INDEX_DIR);
    273         if(deleteDir(fileIndex)){
    274             fileIndex.mkdir();
    275         }else{
    276             fileIndex.mkdir();
    277         }
    278         
    279         createIndex(DATA_DIR);
    280         searchIndex("man");
    281     }
    282 }

![复制代码][copycode.gif]

## 运行结果： ##

所有包含man关键字的文件，都被筛选出来了。

![242216129719795.jpg][]

![242215150347594.jpg][]

--------------------

## 参考资料 ##

JAVA读取文本大全：http://blog.csdn.net/csh624366188/article/details/6785817

Lucene官方文档：http://lucene.apache.org/core/4\_0\_0/core/overview-summary.html

[ppt]: http://pan.baidu.com/s/1jGxGi6E
[Link 1]: http://pan.baidu.com/s/1gdejAMJ
[242144055348718.jpg]: /images/20220724/7102590ac571495d8f8e5e1e65e2390d.png
[242153077539335.jpg]: /images/20220724/08dc951a7e4d4ca3b013d3e3f300f7b2.png
[242155074404668.jpg]: /images/20220724/60b24171deb34e7ea6dc2d4c16a2a92e.png
[copycode.gif]: /images/20220724/8c64bebed48a4fc89c739c284a0ce0ee.png
[ExpandedBlockStart.gif]: /images/20220724/bba97bdcef4a496a85e3ad37f772ef52.png
[242216129719795.jpg]: /images/20220724/a9fd6b7af5c34a4d81aa96a480ebebc3.png
[242215150347594.jpg]: /images/20220724/94de7952968d4425831957e3b1c86741.png