资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

立即前往
首页/文章专栏/Lucene学习笔记

Lucene学习笔记

justCoding / 2909人阅读

摘要：全文检索概述数据分类结构化数据具有固定格式或者长度有限的数据，例如数据库中的表。语句非结构化数据与结构化数据对立，例如邮件网页文档。

全文检索概述 数据分类

结构化数据：具有固定格式或者长度有限的数据，例如数据库中的表。【SQL语句】

非结构化数据：与结构化数据对立，例如：邮件、网页、word文档。【数据扫描、全文检索】

半结构化数据：介于两者之间，例如xml或者json格式的数据。

全文检索过程


反向索引(倒排表)：由字符串到文件的映射是文件到字符串映射的反向过程。

索引创建

索引检索

Lucene数学模型 文档、域、词元

文档是Lucene搜索和索引的原子单位，文档为包含一个或者多个域的容器，而域则是依次包含“真正的”被搜索的内容，域值通过分词技术处理，得到多个词元。

For Example，一篇小说（斗破苍穹）信息可以称为一个文档，小说信息又包含多个域，例如：标题（斗破苍穹）、作者、简介、最后更新时间等等，对标题这个域采用分词技术又可以得到一个或者多个词元（斗、破、苍、穹）。

词元权重计算

Term Frequency（tf）：此term在文档中出现的次数，tf越大则该词元越重要。

Document Frequency（df）：有多少文档包含此term，df越大该词元越不重要。

空间向量模型如下：

计算夹角的余弦值，夹角越小，余弦值越大，分值越大，从而相关性越大。

Lucene文件结构 层次结构

index：一个索引存放在一个目录中；

segment：一个索引中可以有多个段，段与段之间是独立的，添加新的文档可能产生新段，不同的段可以合并成一个新段；

document：文档是创建索引的基本单位，不同的文档保存在不同的段中，一个段可以包含多个文档；

field:域，一个文档包含不同类型的信息，可以拆分开索引；

term：词，索引的最小单位，是经过词法分析和语言处理后的数据。

正向信息

按照层次依次保存了从索引到词的包含关系：index-->segment-->document-->field-->term。

反向信息

反向信息保存了词典的倒排表映射：term-->document

配置Lucene开发环境

Lucene是ASF的开源项目，最新版本是5.2.1，但是鉴于网络上大多数教程使用的是Lucene 4，在本文中使用的版本是Lucene 4.3.1，下载解压，到对应目录找到以下的jar包并添加到构建路径中。

如果使用maven其maven依赖如下：

</>复制代码 
  2. org.apache.lucene
  3. lucene-core
  4. 4.3.1
  7. org.apache.lucene
  8. lucene-queryparser
  9. 4.3.1
  12. org.apache.lucene
  13. lucene-queries
  14. 4.3.1
  17. org.apache.lucene
  18. lucene-highlighter
  19. 4.3.1
  22. org.apache.lucene
  23. lucene-analyzers-smartcn
  24. 4.3.1
  27. org.apache.lucene
  28. lucene-analyzers-common
  29. 4.3.1
Lucene常用功能介绍 索引创建 创建索的关键类

创建索引的示例代码：

</>复制代码 
  1. /**
  2.  * 索引创建
  3.  */
  4. @Test
  5. public void createIndex() {
  6. // 创建一个分词器（指定Lucene版本）
  7. Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_43);
  8. // IndexWriter配置信息（指定Lucene版本和分词器）
  9. IndexWriterConfig indexWriterConfig = new IndexWriterConfig(Version.LUCENE_43, analyzer); 
  10. // 设置索引的打开方式
  11. indexWriterConfig.setOpenMode(OpenMode.CREATE_OR_APPEND);
  12. // 创建Directory对象和IndexWriter对象
  13. Directory directory = null;
  14. IndexWriter indexWriter = null;
  15. try {
  16. directory = FSDirectory.open(new File("Lucene_index/test"));
  17. // 检查Directory对象是否处于锁定状态（如果锁定则进行解锁）
  18. if (IndexWriter.isLocked(directory)) {
  19. IndexWriter.unlock(directory);
  20. }
  21. indexWriter = new IndexWriter(directory, indexWriterConfig);
  22. } catch (IOException e) {
  23. e.printStackTrace();
  24. }
  25. // 创建测试文档并为其添加域
  26. Document doc1 = new Document();
  27. doc1.add(new StringField("id", "abcde", Store.YES)); 
  28.   // 添加一个id域，域值为abcde
  29. doc1.add(new TextField("content", "使用Lucene实现全文检索", Store.YES)); // 文本域
  30. doc1.add(new IntField("num", 1, Store.YES));
  31.   // 添加数值域
  32. // 将文档写入索引
  33. try {
  34. indexWriter.addDocument(doc1);
  35. } catch (IOException e) {
  36. e.printStackTrace();
  37. }
  38. Document doc2 = new Document();
  39. doc2.add(new StringField("id", "yes", Store.YES)); 
  40.  
  41. doc2.add(new TextField("content", "Docker容器技术简介", Store.YES)); 
  42. doc2.add(new IntField("num", 2, Store.YES));
  43.  
  44. try {
  45. indexWriter.addDocument(doc2);
  46. } catch (IOException e) {
  47. e.printStackTrace();
  48. }
  49. // 将IndexWriter提交
  50. try {
  51. indexWriter.commit();
  52. } catch (IOException e) {
  53. e.printStackTrace();
  54. } finally{
  55. try {
  56. indexWriter.close();
  57. directory.close();
  58. } catch (IOException e) {
  59. e.printStackTrace();
  60. }
  61. }
  62. }

生成的索引文件如下：

索引检索 索引检索关键类

利用以下的检索程序对前面创建的索引进行检索：

</>复制代码 
  1. /**
  2.  * 索引检索
  3.  */
  4. @Test
  5. public void searchIndex(){
  6. Directory directory = null;
  7. DirectoryReader dReader = null;
  8. try {
  9. directory = FSDirectory.open(new File("Lucene_index/test"));
  10. // 索引文件
  11. dReader = DirectoryReader.open(directory);
  12. // 读取索引文件
  13. IndexSearcher searcher = new IndexSearcher(dReader);
  14. // 创建IndexSearcher对象
  15. Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_43);    // 指定分词技术（标准分词-与创建索引时使用的分词技术一致）
  16. // 创建查询字符串（指定搜索域和采用的分词技术）
  17. QueryParser parser = new QueryParser(Version.LUCENE_43, "content", analyzer);
  18. Query query = parser.parse("Docker"); 
  19. // 创建Query对象（指定搜索词）
  20. // 检索索引(指定前10条)
  21. TopDocs topDocs = searcher.search(query, 10);
  22. if (topDocs != null) {
  23. System.out.println("符合条件的文档总数为：" + topDocs.totalHits);
  24. for (int i = 0; i < topDocs.scoreDocs.length; i++) {
  25. Document doc = searcher.doc(topDocs.scoreDocs[i].doc);
  26. System.out.println("id = " + doc.get("id") + ",content = " + doc.get("content") + ",num = " + doc.get("num"));
  27. }
  28. }
  29. } catch (IOException e) {
  30. e.printStackTrace();
  31. } catch (ParseException e) {
  32. e.printStackTrace();
  33. } finally{
  34. try {
  35. dReader.close();
  36. directory.close();
  37. } catch (IOException e) {
  38. e.printStackTrace();
  39. }
  40. }
  41. }

运行结果：

Lucene分词器 常见分词器

其中IKAnalyzer需要下载专门的jar包

</>复制代码 
  1. /**
  2.  * 常见分词器
  3.  */
  4. @Test
  5. public void testAnalyzer(){
  6. final String str = "利用Lucene 实现全文检索";
  7. Analyzer analyzer = null;
  8. analyzer = new StandardAnalyzer(Version.LUCENE_43); 
  9. // 标准分词
  10. print(analyzer, str);
  11. analyzer = new IKAnalyzer();
  12. // 第三方中文分词
  13. print(analyzer, str);
  14. analyzer = new WhitespaceAnalyzer(Version.LUCENE_43); 
  15. // 空格分词
  16. print(analyzer, str);
  17. analyzer = new SimpleAnalyzer(Version.LUCENE_43); 
  18. // 简单分词
  19. print(analyzer, str);
  20. analyzer = new CJKAnalyzer(Version.LUCENE_43);
  21. // 二分法分词
  22. print(analyzer, str);
  23. analyzer = new KeywordAnalyzer();
  24. // 关键字分词
  25. print(analyzer, str);
  26. analyzer = new StopAnalyzer(Version.LUCENE_43); 
  27. //被忽略词分词器
  28. print(analyzer, str);
  29. }
  30. /**
  31.  * 该方法用于打印分词器及其分词结果
  32.  * @param analyzer 分词器
  33.  * @param str 需要分词的字符串
  34.  */
  35. public void print(Analyzer analyzer,String str){
  36. StringReader stringReader = new StringReader(str);
  37. try {
  38. TokenStream tokenStream = analyzer.tokenStream("", stringReader); 
  39. // 分词
  40. tokenStream.reset();
  41. CharTermAttribute term = tokenStream.getAttribute(CharTermAttribute.class); // 获取分词结果的CharTermAttribute
  42. System.out.println("分词技术:" + analyzer.getClass());
  43. while (tokenStream.incrementToken()) {
  44. System.out.print(term.toString() + "|");
  45. }
  46. System.out.println();
  47. } catch (IOException e) {
  48. e.printStackTrace();
  49. }
  50. }

运行结果：

Query创建 



</>复制代码 
  1. /**
  2.  * 创建Query
  3.  */
  4. @Test
  5. public void createQuery(){
  6. String key = "JAVA EE Lucene案例开发";
  7. String field = "name";
  8. String[] fields = {"name","content"};
  9. Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_43); // 分词器
  10. // 单域查询
  11. QueryParser parser1 = new QueryParser(Version.LUCENE_43, field, analyzer);
  12. Query query1 = null;
  13. try {
  14. query1 = parser1.parse(key); // 使用QueryParser创建Query
  15. } catch (ParseException e) {
  16. e.printStackTrace();
  17. }
  18. System.out.println(QueryParser.class + query1.toString());
  19. // 多域查询
  20. MultiFieldQueryParser parser2 = new MultiFieldQueryParser(Version.LUCENE_43, fields, analyzer);
  21. try {
  22. query1 = parser2.parse(key);
  23. } catch (ParseException e) {
  24. e.printStackTrace();
  25. }
  26. System.out.println(QueryParser.class + query1.toString());
  27. // 短语查询
  28. query1 = new TermQuery(new Term(field, key));
  29. System.out.println(TermQuery.class + query1.toString());
  30. // 前缀查询
  31. query1 = new PrefixQuery(new Term(field, key));
  32. System.out.println(PrefixQuery.class + query1.toString());
  33. // 短语查询
  34. PhraseQuery query2 = new PhraseQuery();
  35. query2.setSlop(2); // 设置短语间的最大距离是2
  36. query2.add(new Term(field, "Lucene"));
  37. query2.add(new Term(field, "案例"));
  38. System.out.println(PhraseQuery.class + query2.toString());
  39. // 通配符查询
  40. query1 = new WildcardQuery(new Term(field, "Lucene?"));
  41. System.out.println(WildcardQuery.class + query1.toString());
  42. // 字符串范围搜索
  43. query1 = TermRangeQuery.newStringRange(field, "abc", "azz", false, false);
  44. System.out.println(TermRangeQuery.class + query1.toString());
  45. // 布尔条件查询
  46. BooleanQuery query3 = new BooleanQuery();
  47. query3.add(new TermQuery(new Term(field, "Lucene")),Occur.SHOULD); // 添加条件
  48. query3.add(new TermQuery(new Term(field, "案例")),Occur.MUST); 
  49. query3.add(new TermQuery(new Term(field, "案例")),Occur.MUST_NOT); 
  50. System.out.println(BooleanQuery.class + query3.toString());
  51. }

运行结果：

IndexSearcher常用方法

检索关键类

云服务器 GPU云服务器 学习笔记 学习笔记一 基础学习笔记 深度学习笔记

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/64432.html

相关文章

发表评论

登陆后可评论

0条评论

justCoding

男|高级讲师
我要私信

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<