全文检索Lucene

------------恢复内容开始------------

一，什么是全文检索

概念：先创建索引然后查询索引的过程就做全文索引。索引一次创建可以多次使用，表现为每次查询速度都很快。

二，数据的分类

结构化数据：格式固定，长度固定，数据类型固定比如数据库的数据
非结构化数据：格式不固定，长度不固定，数据类型不固定word文档，pdf文档，邮件，html，txt

三，数据的查询

结构化数据的查询：SQL语句，查询简单，速度快
非结构化数据的查询：
1. 从文本文件中查找出包含spring单词的文件
  1. 目测
  2. 使用程序把文档读取到内存中，然后匹配字符串
  3. 把非结构化数据进行字符串拆分，得到一个单词的列表，基于单词列表创建一个索引，然后查询索引，根据单词和文档的对应关系找到文档列表，这个过程就叫做全文索引
2. 索引：一个为了提高查询速度，创建某种数据结构的集合

四，全文检索的应用场景

搜索引擎：百度，360，谷歌，搜狗
站内搜索：论坛搜索，微博，文章搜索
电商搜索：淘宝，京东　　
只要是搜索的地方就可以使用全文搜索技术

五，什么是Lucene

　　Lucene，是基于Java开发的全文检索工具包

Lucene实现全文检索的流程
1. 创建索引
  1. 获得文档
    1. 原始文档：要基于哪些数据来进行搜索，那么这些数据就是原始文档
    2. 搜索引擎：使用爬虫获得原始文档
    3. 站内搜索：数据库中的数据
    4. 案例：直接使用io流读取磁盘上的文件
  2. 构建文档对象
    1. 对应每个原始文档创建一个Document对象
    2. 每个Document对象中包含多个域（field）
    3. 域中保存的就是原始文档数据：域的名称和域的值
    4. 每个文档都有一个唯一的编号，就是文档id
  3. 分析文档：就是分词的过程
    1. 根据空格进行字符串拆分，得到一个单词列表
    2. 把单词统一转换成小写
    3. 去除标点符号
    4. 去除停用词：无意义的词
    5. 每个关键词都封装成一个Term对象中
      1. Term中包含两部分内容：关键词所在的域，关键词本身
      2. 不同的域中拆分出来的相同关键词是不同的term
  4. 创建索引：
    1. 基于关键词列表创建一个索引，保存在索引库中，索引库中包含：索引，document对象，关键词和文档的对应关系
    2. 通过词语找文档，这种索引的结构叫倒排索引结构
2. 查询索引
  1. 用户查询接口：用户输入查询的条件的地方例如百度的搜索框
  2. 把关键词封装成一个查询对象：要查询的域，要查询的关键词
  3. 执行查询
    1. 根据要查询的关键词到对应的域上进行搜索
    2. 找到关键词，根据关键词找到对应的文档
  4. 渲染结果
    1. 根据文档的id找到文档对象
    2. 对关键词进行高亮显示
    3. 分页处理
    4. ...
    5. 最终展示给用户看

六，Lucene快速入门

　　入门需求:

　　　　实现一个文件的搜索功能，通过关键字搜索文件，凡是文件名或者文件内容包括关键字的文件都需要找出来。还可以根据中文词语进行查询，并且需要支持多个条件查询。本案例的原始内容就是磁盘上的文件

　　1.创建索引

　　　　工程搭建：

　　　　　　创建一个空的Java工程

　　　　　　添加jar依赖：lucene-analyzers-common-7.4.0.jar,lucene-core-7.4.0.jar,commons-io.jar

　　　　步骤：

　　　　　　1.创建一个Directory对象，指定索引库保存的位置

　　　　　　2.基于Directory对象创建一个IndexWriter对象

　　　　　　3.读取磁盘上的文件，对应每个文件创建一个文档对象

　　　　　　4.向文档对象中添加域

　　　　　　5.把文档对象写入索引库

　　　　　　6.关闭IndexWriter对象

　　2.代码

 1 public class LuceneFirst {
 2     @Test
 3     public void createIndex() throws Exception{
 4 //       1.创建一个Director对象，指定索引库保存的位置
 5 //        Directory directory = new RAMDirectory();    //索引库保存在内存中
 6         Directory directory = FSDirectory.open(new File("E:\\temp\\index").toPath());
 7 //　　　　2.基于Director对象创建一个IndexWriter对象
 8         IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig());
 9 //　　　　3.读取磁盘上的文件，对应每个文件创建一个文档对象
10         File dir = new File("D:\\java（新课程）\\00 讲义+笔记+资料\\流行框架\\61.会员版(2.0)-就业课(2.0)-Lucene\\lucene\\02.参考资料\\searchsource");
11         File[] files = dir.listFiles();
12         for (File file : files) {
13             String fileName = file.getName();   //获取文件名
14             String filePath = file.getPath();   //获取文件路径
15             String fileContext = FileUtils.readFileToString(file, "utf-8"); //获取文件内容
16             long fileSize = FileUtils.sizeOf(file); //获取文件大小
17
18             //创建Field
19             //参数：域的名称，域的内容，是否存储
20             Field fieldName = new TextField("name", fileName, Field.Store.YES);
21             Field fieldPath = new TextField("filePath", filePath, Field.Store.YES);
22             Field fieldContext = new TextField("fileContext", fileContext, Field.Store.YES);
23             Field fieldSize = new TextField("fileSize", fileSize+"", Field.Store.YES);
24
25             //创建文档对象
26             Document document = new Document();
27 //　　　　4.向文档对象中添加域
28             document.add(fieldName);
29             document.add(fieldPath);
30             document.add(fieldContext);
31             document.add(fieldSize);
32 //　　　　5.把文档对象写入索引库
33             indexWriter.addDocument(document);
34         }
35 //　　　　6.关闭IndexWriter对象
36         indexWriter.close();
37     }
38 }

　　2.查询索引库

　　　　步骤：

　　　　　　1.创建一个Directory对象，指定索引库的位置

　　　　　　2.创建一个IndexReader对象

　　　　　　3.创建一个IndexSearcher对象，构造方法中的参数IndexReader 对象

　　　　　　4.创建一个Query对象，TermQuery

　　　　　　5.执行查询，得到一个TomDocs对象

　　　　　　6.取查询结果的总记录数

　　　　　　7.取文档列表

　　　　　　8.打印文档的内容

　　　　　　9.关闭IndexReader对象

　　代码实现

 1 @Test
 2     public void searchIndex() throws Exception {
 3 //       1.创建一个Directory对象，指定索引库的位置
 4         Directory directory = FSDirectory.open(new File("E:\\temp\\index").toPath());
 5 //　　　　2.创建一个IndexReader对象
 6         IndexReader indexReader = DirectoryReader.open(directory);
 7 //　　　　3.创建一个IndexSearcher对象，构造方法中的参数IndexReader 对象
 8         IndexSearcher indexSearcher = new IndexSearcher(indexReader);
 9 //　　　　4.创建一个Query对象，TermQuery
10         Query query = new TermQuery(new Term("fileContext", "spring"));
11 //　　　　5.执行查询，得到一个TomDocs对象
12         TopDocs topDocs = indexSearcher.search(query, 10);
13 //　　　　6.取查询结果的总记录数
14         System.out.println("查询总记录数：" + topDocs.totalHits);
15 //　　　　7.取文档列表
16         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
17 //　　　　8.打印文档的内容
18         for (ScoreDoc scoreDoc : scoreDocs) {
19             //获取文档id
20             int docId = scoreDoc.doc;
21             //根据id取文档对象
22             Document document = indexSearcher.doc(docId);
23             System.out.println(document.get("name"));
24             System.out.println(document.get("filePath"));
25 //            System.out.println(document.get("fileContext"));
26             System.out.println(document.get("fileSize"));
27         }
28 //　　　　9.关闭IndexReader对象
29         indexReader.close();
30     }

　　3.分析器

　　　　默认使用的是标准分析器：StandarAnalyzer

　　　　1.查看分析器的分析效果

　　　　　　使用Analyzer对象的tokenStream方法返回一个TokenStream对象。词对象中包含了最终分词结果

　　　　实现步骤：

　　　　　　1.创建要给Analyzer对象，StandardAnalyzer对象

　　　　　　2.使用分析器对象的tokenStream方法获得一个TokenStream对象

　　　　　　3.向TokenStream对象中设置一个引用，相当于是一个指针

　　　　　　4.调用TokenStream对象的reset方法。如果不调用抛异常

　　　　　　5.使用while循环遍历TokenStream对象

　　　　　　6.关闭TokenStream对象

　　　　代码实现

 1 @Test
 2     public void testTokenStream() throws Exception {
 3 //       1.创建要给Analyzer对象，StandardAnalyzer对象
 4         Analyzer analyzer = new StandardAnalyzer();
 5 //　　　　2.使用分析器对象的tokenStream方法获得一个TokenStream对象
 6         TokenStream tokenStream = analyzer.tokenStream(null, "The Spring Framework provides a comprehensive programming and configuration model.");
 7 //　　　　3.向TokenStream对象中设置一个引用，相当于是一个指针
 8         CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
 9 //　　　　4.调用TokenStream对象的reset方法。如果不调用抛异常
10         tokenStream.reset();
11 //　　　　5.使用while循环遍历TokenStream对象
12         while (tokenStream.incrementToken()){
13             System.out.println(charTermAttribute.toString());
14         }
15 //　　　　6.关闭TokenStream对象
16         tokenStream.close();
17     }

　　　　　2.IKAnalyzer的使用方法

　　　　　　1.把IKAnalyzer的jar包添加到工程中

　　　　　　2.把配置文件和扩展词典添加到工程的classpath下

　　　　　　　　注意：扩展词典严禁使用window记事本编辑，因为有保证扩展词典的编码是utf-8

　　　　　　　　扩展词典：添加一些新词

　　　　　　　　停用词词典：无意义的词或者是敏感的词

　　　　　　3.代码实现

 1 @Test
 2     public void testIkAnalyzer() throws Exception {
 3 //       1.创建要给Analyzer对象，StandardAnalyzer对象
 4         Analyzer analyzer = new IKAnalyzer();
 5 //　　　　2.使用分析器对象的tokenStream方法获得一个TokenStream对象
 6         TokenStream tokenStream = analyzer.tokenStream("", "全文检索是将整本书java、整篇文章中的任意内容信息查找出来的检索，java。它可以根据需要获得全文中有关章、节、段、句、词等信息，计算机程序通过扫描文章中的每一个");
 7 //　　　　3.向TokenStream对象中设置一个引用，相当于是一个指针
 8         CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
 9 //　　　　4.调用TokenStream对象的reset方法。如果不调用抛异常
10         tokenStream.reset();
11 //　　　　5.使用while循环遍历TokenStream对象
12         while (tokenStream.incrementToken()){
13             System.out.println(charTermAttribute.toString());
14         }
15 //　　　　6.关闭TokenStream对象
16         tokenStream.close();
17     }

　　　　　　3.IkAnalyzer，在代码中使用

 1 @Test
 2     public void createIndex() throws Exception{
 3 //       1.创建一个Director对象，指定索引库保存的位置
 4 //        Directory directory = new RAMDirectory();    //索引库保存在内存中
 5         Directory directory = FSDirectory.open(new File("E:\\temp\\index").toPath());
 6 //　　　　2.基于Director对象创建一个IndexWriter对象
 7         IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig(new IKAnalyzer()));
 8 //　　　　3.读取磁盘上的文件，对应每个文件创建一个文档对象
 9         File dir = new File("D:\\java（新课程）\\00 讲义+笔记+资料\\流行框架\\61.会员版(2.0)-就业课(2.0)-Lucene\\lucene\\02.参考资料\\searchsource");
10         File[] files = dir.listFiles();
11         for (File file : files) {
12             String fileName = file.getName();   //获取文件名
13             String filePath = file.getPath();   //获取文件路径
14             String fileContext = FileUtils.readFileToString(file, "utf-8"); //获取文件内容
15             long fileSize = FileUtils.sizeOf(file); //获取文件大小
16
17             //创建Field
18             //参数：域的名称，域的内容，是否存储
19             Field fieldName = new TextField("name", fileName, Field.Store.YES);
20             Field fieldPath = new TextField("filePath", filePath, Field.Store.YES);
21             Field fieldContext = new TextField("fileContext", fileContext, Field.Store.YES);
22             Field fieldSize = new TextField("fileSize", fileSize+"", Field.Store.YES);
23
24             //创建文档对象
25             Document document = new Document();
26 //　　　　4.向文档对象中添加域
27             document.add(fieldName);
28             document.add(fieldPath);
29             document.add(fieldContext);
30             document.add(fieldSize);
31 //　　　　5.把文档对象写入索引库
32             indexWriter.addDocument(document);
33         }
34 //　　　　6.关闭IndexWriter对象
35         indexWriter.close();
36     }

七，索引库的维护

　　1.索引库的添加

　　　　1.field域的属性

　　　　　　是否分析：是否对域的内容进行分词处理。前提是我们要对域的内容进行查询。

　　　　　　是否索引：将field分析后的词或整个field值进行索引，只有索引方可搜索到。

　　　　　　　　比如：商品名称，商品简介分析后进行索引，订单号，身份证不用分析但也是要索引的，这些将来都要作为查询的条件

　　　　　　是否存储：将field值存储在文档中，存储在文档中的field才可以从Document中获取

　　　　　　　　比如：商品名称，订单号，凡是将来要从Document中获取的field都要存储。

　　　2.添加文档

　　　　步骤：

　　　　　　1.创建一个IndexWriter 对象，需要使用IKAnalyzer作为分析器

　　　　　　2.创建一个Document对象

　　　　　　3.向Document对象中添加域

　　　　　　4.把文档写入索引库

　　　　　　5.关闭索引库

　　　　代码实现

 1 @Test
 2     public void addDocument() throws Exception {
 3 //    1.创建一个IndexWriter 对象，需要使用IKAnalyzer作为分析器
 4         IndexWriter indexWriter = new IndexWriter(FSDirectory.open(new File("E:/temp/index").toPath()), new IndexWriterConfig(new IKAnalyzer()));
 5 //　　2.创建一个Document对象
 6         Document document = new Document();
 7 //　　3.向Document对象中添加域
 8         document.add(new TextField("name","新添加的文件", Field.Store.YES));
 9         document.add(new TextField("content","新添加的文件内容", Field.Store.NO));
10         document.add(new StoredField("path","c:/temp/hello"));
11 //　　4.把文档写入索引库
12         indexWriter.addDocument(document);
13 //　　5.关闭索引库
14         indexWriter.close();
15
16     }

　　2.删除索引库

　　　　1.根据查询关键词删除

　　　　　　代码实现

 1 private IndexWriter indexWriter;
 2     @Before
 3     public void init() throws Exception {
 4         indexWriter = new IndexWriter(FSDirectory.open(new File("E:/temp/index").toPath()), new IndexWriterConfig(new IKAnalyzer()));
 5     }
 6     @Test
 7     public void deleteDocumentByQuery() throws Exception{
 8         indexWriter.deleteDocuments(new Term("name","apache"));
 9         indexWriter.close();
10     }

　　　　2.删除整个索引库

　　　　　　代码实现

1 @Test
2     public void deleteAllDocument() throws Exception {
3         indexWriter.deleteAll();
4         indexWriter.close();
5     }

　　3.更新索引库

　　　　原理是先删除再添加

　　　　步骤：

　　　　　　1.创建新的文档对象

　　　　　　2.向文档对象中添加域

　　　　　　3.更新操作

　　　　　　4.关闭索引库

　　　　　代码实现

@Test
    public void updateIndex() throws Exception{
//       1.创建新的文档对象
        Document document = new Document();
//　　　　2.向文档对象中添加域
        document.add(new TextField("name1","更新之后的文档1", Field.Store.YES));
        document.add(new TextField("name2","更新之后的文档2", Field.Store.YES));
        document.add(new TextField("name3","更新之后的文档3", Field.Store.YES));
//　　　　3.更新操作
        indexWriter.updateDocument(new Term("name","spring"),document);
//　　　　4.关闭索引库
        indexWriter.close();

原文地址：https://www.cnblogs.com/jianer/p/12128701.html

时间： 2024-10-26 23:33:20

全文检索Lucene的相关文章

[全文检索]Lucene基础入门.

本打算直接来学习Solr, 现在先把Lucene的只是捋一遍. 本文内容: 1. 搜索引擎的发展史 2. Lucene入门 3. Lucene的API详解 4. 索引调优 5. Lucene搜索结果排名规则 1 搜索引擎的发展史 1.1 搜索引擎的发展史萌芽:Archie.Gopher 起步:Robot(网络机器人)和spider(网络爬虫) 1. Robot:网络机器人,自动在网络中运行,完成特定任务的程序,如刷票器.抢票软件等. 2. spider:网络爬虫,是一中特殊的机器人,抓取(下载

全文检索-Lucene.net

Lucene.net是Lucene的.net移植版本,在较早之前是比较受欢迎的一个开源的全文检索引擎开发包,即它不是一个完整的全文检索引擎,而是一个全文检索引擎的架构,提供了完整的查询引擎和索引引擎. 例子的组件版本 Lucene.Net:3.0.3.0 盘古分词:2.4.0.0 分词例子分词是核心算法,将完整的句子分词成若干个词或字:同时它只能处理文本信息,非文本信息只能转换成为文本信息,无法转换的只能放弃. 所有供全文搜索的要先写入索引库,索引库可以看成存放数据的数据库搜索对象建立的时候

BOS物流管理系统-第一天

BOS物流管理系统-第一天-系统分析.环境搭建.前端框架 BoBo老师整体项目内容目标: 对项目概述的一些理解亮点技术的学习注意学习方式:优先完成当天代码. 其他内容. 最终: 学到新的技术,会应用新的技术:对项目有个整体感觉: 课程安排:12天左右主要内容: 项目整体概述和一般流程(项目概念.一般项目流程等) BOS项目的概述(项目背景.需求.技术架构.学习目标) 开发环境搭建项目导入和运行(传统项目结构)(Struts2的通配符映射) 项目导入和运行(Maven项目结构)(STS开

我心中的核心组件（可插拔的AOP）~大话开篇及目录

我心中的核心组件(可插拔的AOP)~大话开篇及目录 http://www.cnblogs.com/lori/p/3247905.html 回到占占推荐博客索引核心组件我心中的核心组件,核心组件就是我认为在项目中比较常用的功能,如日志,异常处理,消息,邮件,队列服务,调度,缓存,持久化,分布式文件存储,NoSQL存储,IoC容器,方法拦截等等. 对于以上内容可以说即是一个大餐,又是一个挑战,就让我带着大家去迎接这份挑战吧,呵呵! 可插拔的AOP AOP即面向切面的编程,是指将一个公用的与领域无

2015年33期Java/Spring/Struts2/web/基础/就业班视频

一.基础班课程(掌握Java核心课程) 日期星期课程(空内容表示放假) 上课老师2014/12/8 星期一 [开学典礼].Java开发前奏钟太潋2014/12/9 星期二 Java语言基础钟太潋2014/12/10 星期三 2014/12/11 星期四 Java语言基础钟太潋2

.NET常用第三方库（包）总结

序列化与反序列化 JSON.NET应该是.NET平台上使用最为广泛的序列化/反序列化包了,ASP.NET和ASP.NET Core中默认序列化/反序列化包 Jil官网上说性能优于JSON.NET 文本日志记录 NLog Log4Net 以上二位都是从JAVA阵营移植过来的,对于分布式系统使用文本日志追踪问题也是比较恶心的一件事儿对象映射 AutoMapper这儿有一篇比较好的教程文章 ValueInject这个我接触的第一个对象映射库,还是比较简单的,源码读起来难度也不大数据库 Dapper

Lucene01

数据分类结构化数据和非结构化数据结构化数据搜索 sql 非结构化数据查询方法顺序扫描法全文检索 lucene实现全文检索的流程创建索引对文档索引的过程,将用户要搜索的文档内容进行索引,索引存在索引库中, 获取原始文档创建文档对象,文档中包括一个一个的域(Field),域中存储内容,可以将磁盘上的一个文件当成一个document, Document中包括一些Field(file_name文件名称.file_path文件路径.file_size

ElasticSearch(分布式全文搜索引擎)

1.Lucene的优化, 实现了高可用的分布式集群的搜索方案 2.首先,ES的索引库管理支持依然是基于Apache Lucene(TM)的开源搜索引擎.ES也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能,但是它的目的是通过简单的 RESTful API来隐藏Lucene的复杂性,从而让全文搜索变得简单. 3.ES的特点 a) 分布式的实时文件存储,每个字段都被索引并可被搜索分布式的实时分析搜索引擎可以扩展到上百台服务器,处理PB级结构化或非结构化数据高度集成化的

全文检索技术---Lucene

1 Lucene介绍 1.1 什么是Lucene Lucene是apache下的一个开源的全文检索引擎工具包.它为软件开发人员提供一个简单易用的工具包(类库),以方便的在目标系统中实现全文检索的功能. 1.2 全文检索的应用场景 1.2.1 搜索引擎 ©注意: Lucene和搜索引擎是不同的,Lucene是一套用java或其它语言写的全文检索的工具包.它为应用程序提供了很多个api接口去调用,可以简单理解为是一套实现全文检索的类库.搜索引擎是一个全文检索系统,它是一个单独运