Lucene 4.8全文检索引擎入门示例

来源:转载


 本文转自:http://peihexian.iteye.com/blog/2075514

花了小半天的时间研究了一下Lucene全文检索引擎的使用,看网上的教程动辄十几章着实吓人,想起来N年前学习JDBC的时候买了巨厚的一本专门描写JDBC的书籍,现在想想做数据库编程就那么个套路,其实是很简单的,这个Lucene应该也是一样的,先入了门再关注各个细节的犄角旮旯。

 

先看项目中要用Lucene的话需要引入哪些jar包,我是用maven自动下载的,依赖包如下:

Xml代码  
  1. <dependency>  
  2.             <groupId>org.apache.lucene</groupId>  
  3.             <artifactId>lucene-core</artifactId>  
  4.             <version>4.8.0</version>  
  5.         </dependency>  
  6.         <dependency>  
  7.             <groupId>org.apache.lucene</groupId>  
  8.             <artifactId>lucene-queryparser</artifactId>  
  9.             <version>4.8.0</version>  
  10.         </dependency>  
  11.           
  12.         <dependency>  
  13.             <groupId>org.apache.lucene</groupId>  
  14.             <artifactId>lucene-analyzers-common</artifactId>  
  15.             <version>4.8.0</version>  
  16.         </dependency>  
  17.   
  18.         <dependency>  
  19.             <groupId>org.apache.lucene</groupId>  
  20.             <artifactId>lucene-highlighter</artifactId>  
  21.             <version>4.8.0</version>  
  22.         </dependency>  
  23.           
  24.         <dependency>  
  25.             <groupId>junit</groupId>  
  26.             <artifactId>junit</artifactId>  
  27.             <version>4.11</version>  
  28.         </dependency>  

 注意junit不是必须的,只是便于写单元测试我就没有删除。

 

如果不会使用maven,也可以去Lucene的官方网站下载完整的压缩包后自己复制jar包使用,我的测试示例代码用到的jar包如下图:

复制需要用的jar包就行,不用乱七八糟啥都复制到项目里面的。

 

下面是测试代码,我是在c:/txts目录里面放了几个txt文本文件去建立全文索引的,找了几个公司的项目投标方案,主要目的是测试在比较多的文字内容的情况下全文索引的速度及检索正确率。

代码如下:

Java代码  
  1. package com.xxx;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.FilenameFilter;  
  7. import java.io.IOException;  
  8. import java.io.InputStream;  
  9. import java.io.InputStreamReader;  
  10. import java.io.StringReader;  
  11. import java.text.SimpleDateFormat;  
  12. import java.util.Date;  
  13.   
  14. import org.apache.lucene.analysis.Analyzer;  
  15. import org.apache.lucene.analysis.TokenStream;  
  16. import org.apache.lucene.document.Document;  
  17. import org.apache.lucene.document.Field.Store;  
  18. import org.apache.lucene.document.LongField;  
  19. import org.apache.lucene.document.StoredField;  
  20. import org.apache.lucene.document.StringField;  
  21. import org.apache.lucene.document.TextField;  
  22. import org.apache.lucene.index.DirectoryReader;  
  23. import org.apache.lucene.index.IndexReader;  
  24. import org.apache.lucene.index.IndexWriter;  
  25. import org.apache.lucene.index.IndexWriterConfig;  
  26. import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;  
  27. import org.apache.lucene.queryparser.classic.QueryParser;  
  28. import org.apache.lucene.search.IndexSearcher;  
  29. import org.apache.lucene.search.Query;  
  30. import org.apache.lucene.search.ScoreDoc;  
  31. import org.apache.lucene.search.TopDocs;  
  32. import org.apache.lucene.search.TopScoreDocCollector;  
  33. import org.apache.lucene.search.highlight.Highlighter;  
  34. import org.apache.lucene.search.highlight.QueryScorer;  
  35. import org.apache.lucene.search.highlight.SimpleHTMLFormatter;  
  36. import org.apache.lucene.store.Directory;  
  37. import org.apache.lucene.store.SimpleFSDirectory;  
  38. import org.apache.lucene.util.Version;  
  39. import org.junit.Test;  
  40. import org.wltea.analyzer.lucene.IKAnalyzer;  
  41.   
  42. public class TestLucene {  
  43.   
  44.     // 待索引文件存放路径  
  45.     private static String source_file_path = "c://txts";  
  46.   
  47.     // 生成的全文索引文件存储路径  
  48.     private static String indexDir = "c://index_dir";  
  49.   
  50.     private static SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
  51.   
  52.     // 中文分词器IKAnalyzer,从http://code.google.com/p/ik-analyzer/downloads/list 下载最新源码放入项目中使用  
  53.     private static Analyzer analyzer = new IKAnalyzer();  
  54.   
  55.       
  56.     public void createIndex() {  
  57.         Directory directory = null;  
  58.         try {  
  59.             // 有文件系统或者内存存储方式,这里使用文件系统存储索引数据  
  60.             directory = new SimpleFSDirectory(new File(indexDir));  
  61.   
  62.             // 生成全文索引的配置对象  
  63.             IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_48,analyzer);  
  64.             // 设置生成全文索引的方式为创建或者追加  
  65.             config.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);  
  66.             // 创建真正生成全文索引的writer对象  
  67.             IndexWriter indexWriter = new IndexWriter(directory, config);  
  68.   
  69.             // 读取待索引文件夹下的所有的.txt文件  
  70.             File sourceFiles = new File(source_file_path);  
  71.             String txtFiles[] = sourceFiles.list(new FilenameFilter() {  
  72.                 @Override  
  73.                 public boolean accept(File dir, String name) {  
  74.                     if (name.endsWith(".txt")) { // 这里只对.txt文件创建索引  
  75.                         return true;  
  76.                     }  
  77.                     return false;  
  78.                 }  
  79.             });  
  80.   
  81.             // 遍历所有txt文件写入全文索引,如果数据来源是数据库则遍历数据库查询结果集即可  
  82.             for (String txtFile : txtFiles) {  
  83.                 String file = source_file_path + File.separator + txtFile;  
  84.                 File input_txt_file = new File(file);  
  85.   
  86.                 System.out.println("开始对" + txtFile + "建立索引");  
  87.   
  88.                 Document doc = new Document(); // 约等于数据库的一行记录  
  89.   
  90.                 // 以下生成各个字段的数据值  
  91.                 StringField name = new StringField("filename",  input_txt_file.getName(), Store.YES);  
  92.                 TextField content = new TextField("content", readFileContent(   file, "gbk"), Store.YES);  
  93.                 StringField path = new StringField("path",input_txt_file.getAbsolutePath(), Store.YES);  
  94.                 StoredField date = new StoredField("date",  df.format(new Date()));  
  95.                 LongField size = new LongField("size", input_txt_file.length(),Store.YES);  
  96.   
  97.                 // 向Document对象中加入各个字段的值  
  98.                 doc.add(name);  
  99.                 doc.add(content);  
  100.                 doc.add(path);  
  101.                 doc.add(date);  
  102.                 doc.add(size);  
  103.   
  104.                 // 向IndexWriter中增加新的一行记录  
  105.                 indexWriter.addDocument(doc);  
  106.                 // 提交数据内容  
  107.                 indexWriter.commit();  
  108.             }  
  109.             indexWriter.close();  
  110.             directory.close();  
  111.         } catch (Exception e) {  
  112.             e.printStackTrace();  
  113.         }  
  114.     }  
  115.   
  116.       
  117.     public void search() {  
  118.         String queryString = "test"; //查询条件  
  119.         String query_fields[]=new String[]{"filename","content"};//对哪几个字段进行查询检索  
  120.         File file_index_dir = new File(indexDir);  
  121.         try {  
  122.             Directory directory = new SimpleFSDirectory(file_index_dir);  
  123.             IndexReader indexReader = DirectoryReader.open(directory);  
  124.   
  125.             // 创建搜索类  
  126.             IndexSearcher indexSearcher = new IndexSearcher(indexReader);  
  127.               
  128.             QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_48, query_fields,analyzer);  
  129.               
  130.             queryParser.setDefaultOperator(QueryParser.OR_OPERATOR);//多个关键字时采取 or 操作  
  131.   
  132.             Query query = queryParser.parse(queryString);  
  133.               
  134.             TopDocs topDocs = indexSearcher.search(query, 10000);//查询前多少条满足条件的数据  
  135.               
  136.             System.out.println("一共查到:" + topDocs.totalHits + "记录");  
  137.               
  138.             ScoreDoc[] scoreDoc = topDocs.scoreDocs;  
  139.   
  140.             for (int i = 0; i < scoreDoc.length; i++) {  
  141.                 // 内部编号  
  142.                 int doc = scoreDoc[i].doc;  
  143.                 System.out.println("内部编号:" + doc);  
  144.                   
  145.                 // 根据文档id找到文档  
  146.                 Document mydoc = indexSearcher.doc(doc);  
  147.                   
  148.                 System.out.println("文档路径:" + mydoc.get("path")); //读取path字段的值  
  149.             }  
  150.         } catch (Exception e) {  
  151.             e.printStackTrace();  
  152.         }  
  153.   
  154.     }  
  155.   
  156.     @Test  
  157.     public void searchPage() {  
  158.         int pageIndex=1;  
  159.         int pageSize=1;  
  160.         int start = (pageIndex - 1) * pageSize;   
  161.           
  162.         String queryString = "test"; //查询条件  
  163.         String query_fields[]=new String[]{"filename","content"};//对哪几个字段进行查询检索  
  164.         File file_index_dir = new File(indexDir);  
  165.         try {  
  166.             Directory directory = new SimpleFSDirectory(file_index_dir);  
  167.             IndexReader indexReader = DirectoryReader.open(directory);  
  168.   
  169.             // 创建搜索类  
  170.             IndexSearcher indexSearcher = new IndexSearcher(indexReader);  
  171.               
  172.             QueryParser queryParser = new MultiFieldQueryParser(Version.LUCENE_48, query_fields,analyzer);  
  173.               
  174.             queryParser.setDefaultOperator(QueryParser.OR_OPERATOR);//多个关键字时采取 or 操作  
  175.   
  176.             Query query = queryParser.parse(queryString);  
  177.               
  178.             int max_result_size = start + pageSize;    
  179.             TopScoreDocCollector topDocs = TopScoreDocCollector.create(max_result_size, false);    
  180.             indexSearcher.search(query, topDocs);    
  181.               
  182.             int rowCount = topDocs.getTotalHits();  //满足条件的总记录数  
  183.             int pages = (rowCount - 1) / pageSize + 1; //计算总页数    
  184.             TopDocs tds = topDocs.topDocs(start, pageSize);    
  185.             ScoreDoc[] scoreDoc = tds.scoreDocs;    
  186.   
  187.             System.out.println("一共查到:" + topDocs.getTotalHits() + "记录,共"+pages+"页");  
  188.   
  189.          // 关键字高亮显示的html标签,需要导入lucene-highlighter-x.x.x.jar  
  190.             SimpleHTMLFormatter simpleHTMLFormatter = new SimpleHTMLFormatter(  "<font color='red'>", "</font>");  
  191.             Highlighter highlighter = new Highlighter(simpleHTMLFormatter,new QueryScorer(query));  
  192.               
  193.             for (int i = 0; i < scoreDoc.length; i++) {  
  194.                 // 内部编号  
  195.                 int doc_id = scoreDoc[i].doc;  
  196.                 System.out.println("内部编号:" + doc_id);  
  197.                   
  198.                 // 根据文档id找到文档  
  199.                 Document mydoc = indexSearcher.doc(doc_id);  
  200.                 // 内容增加高亮显示  
  201.                 TokenStream tokenStream2 = analyzer.tokenStream("content",new StringReader(mydoc.get("content")));  
  202.                 String content = highlighter.getBestFragment(tokenStream2,mydoc.get("content"));  
  203.                 System.out.println("文件名称:"+mydoc.get("filename")+" 高亮内容:"   + content);  
  204.             }  
  205.         } catch (Exception e) {  
  206.             e.printStackTrace();  
  207.         }  
  208.   
  209.     }     
  210.       
  211.   
  212.     public static String readFileContent(String FileName, String charset) {  
  213.         InputStream fis=null;  
  214.         BufferedReader reader=null;  
  215.         StringBuffer result = new StringBuffer();  
  216.         try {  
  217.             fis=new FileInputStream(FileName);  
  218.             reader = new BufferedReader(new InputStreamReader(fis, charset));  
  219.             String line = new String();  
  220.   
  221.             while ((line = reader.readLine()) != null) {  
  222.                 result.append(line);  
  223.             }  
  224.               
  225.         } catch (Exception e) {  
  226.             e.printStackTrace();  
  227.         }finally{  
  228.             if (null!=reader){  
  229.                 try {  
  230.                     reader.close();  
  231.                 } catch (IOException e) {}  
  232.             }  
  233.             if (null!=fis){  
  234.                 try {  
  235.                     fis.close();  
  236.                 } catch (IOException e) {}  
  237.             }  
  238.         }  
  239.         //System.out.println("内容:" + result.toString());  
  240.         return result.toString();  
  241.     }  
  242. }  

 

 

 里面除了Lucene以外还用到了中文分词器IKAnalyzer,下载网址http://code.google.com/p/ik-analyzer/downloads/list,下载源码包IK Analyzer 2012FF_hf1_source.rar使用,下载后把src里面的文件复制到项目里面就可以了。

 

记不清是谁说过读书是先读薄再读厚了,使用Lucene的读薄就是先确定索引数据是存到磁盘文件系统还是内存,确定好以后去实例化Directory对象,然后通过配置参数对象去实例化IndexWriter去写待索引文档,对比数据库系统的话,待索引文档对象Document类似于一行记录,上面的示例里面是通过读取硬盘内的文本文件去填充的Document对象,如果要对数据库里面的记录建立全文索引的话,Document的数据来源通过jdbc读取数据库内容即可。

 

查询更简单了,确定好查询什么内容,确定查哪几个字段就可以了。

 



分享给朋友:
您可能感兴趣的文章:
随机阅读: