mysql lucene怎么读_Lucene：一、入门

最新推荐文章于 2021-03-16 22:39:58 发布

Jasin Yip

最新推荐文章于 2021-03-16 22:39:58 发布

阅读量1k

点赞数

文章标签： mysql lucene怎么读

本文链接：https://blog.csdn.net/weixin_28866737/article/details/114328626

版权

1 Lucene简介

Lucene是apache下的一个开源的全文检索引擎工具包。

1.1 全文检索(Full-text Search)

1.1.1 定义

全文检索就是先分词创建索引，再执行搜索的过程。

分词：就是将一段文字分成一个个单词

全文检索就将一段文字分成一个个单词去查询数据！！！

1.1.2 应用场景

1.1.2.1 搜索引擎(了解)

搜索引擎是一个基于全文检索、能独立运行、提供搜索服务的软件系统。

1.2 Lucene实现全文检索的流程

全文检索的流程分为两大部分：索引流程、搜索流程。

索引流程：采集数据--->构建文档对象--->创建索引(将文档写入索引库)。

搜索流程：创建查询--->执行搜索--->渲染搜索结果。

2 入门示例

2.1 需求

使用Lucene实现电商项目中图书类商品的索引和搜索功能。

2.2 配置步骤说明

(1)搭建环境(先下载Lucene)

(2)创建索引库

(3)搜索索引库

2.3 配置步骤

2.3.1 第一部分：搭建环境(创建项目，导入包)

前提：已经创建好了数据库(直接导入book.sql文件)

2.3.1.1 第一步：下载Lucene

Lucene是开发全文检索功能的工具包，使用时从官方网站下载，并解压。

下载版本：4.10.3(要求：jdk1.7及以上)

核心包lucene-core-4.10.3.jar(附常用API)

2.3.1.2 第二步：创建项目，导入包

mysql5.1驱动包：mysql-connector-java-5.1.7-bin.jar

核心包：lucene-core-4.10.3.jar

分析器通用包：lucene-analyzers-common-4.10.3.jar

查询解析器包：lucene-queryparser-4.10.3.jar

项目结构如下：

2.3.2 第二部分：创建索引

步骤说明：

(1)采集数据

(2)将数据转换成Lucene文档

(3)将文档写入索引库，创建索引

2.3.2.1 第一步：采集数据

Lucene全文检索，不是直接查询数据库，所以需要先将数据采集出来。

(1)创建Book类

1 public classBook {2

3 　　private Integer bookId; //图书ID

5 　　private String name; //图书名称

7 　　private Float price; //图书价格

9 　　private String pic; //图书图片

11 　　private String description; //图书描述12

13 　　//补全get\set方法

15 }

View Code

public class Book {

private Integer bookId; // 图书ID

private String name; // 图书名称

private Float price; // 图书价格

private String pic; // 图书图片

private String description; // 图书描述

// 补全get\set方法

}

(2)创建一个BookDao类

1 packagecn.gzsxt.lucene.dao;2

3 importjava.sql.Connection;4

5 importjava.sql.DriverManager;6

7 importjava.sql.PreparedStatement;8

9 importjava.sql.ResultSet;10

11 importjava.sql.SQLException;12

13 importjava.util.ArrayList;14

15 importjava.util.List;16

17 importcn.gzsxt.lucene.pojo.Book;18

19 public classBookDao {20

21 　　public ListgetAll() {22

23 　　　　//数据库链接

25 　　　　Connection connection = null;26

27 　　　　//预编译statement

29 　　　　PreparedStatement preparedStatement = null;30

31 　　　　//结果集

33 　　　　ResultSet resultSet = null;34

35 　　　　//图书列表

37 　　　　List list = new ArrayList();38

39 　　　　try{40

41 　　　　　　//加载数据库驱动

43 　　　　　　Class.forName("com.mysql.jdbc.Driver");44

45 　　　　　　//连接数据库

47 　　　　　　connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lucene", "root", "gzsxt");48

49 　　　　　　//SQL语句

51 　　　　　　String sql = "SELECT * FROM book";52

53 　　　　　　//创建preparedStatement

55 　　　　　　preparedStatement =connection.prepareStatement(sql);56

57 　　　　　　//获取结果集

59 　　　　　　resultSet =preparedStatement.executeQuery();60

61 　　　　　　//结果集解析

63 　　　　　　while(resultSet.next()) {64

65 　　　　　　　　Book book = newBook();66

67 　　　　　　　　book.setBookId(resultSet.getInt("id"));68

69 　　　　　　　　book.setName(resultSet.getString("name"));70

71 　　　　　　　　book.setPrice(resultSet.getFloat("price"));72

73 　　　　　　　　book.setPic(resultSet.getString("pic"));74

75 　　　　　　　　book.setDescription(resultSet.getString("description"));76

77 list.add(book);78

79 }80

81 　　　　} catch(Exception e) {82

83 e.printStackTrace();84

85 　　　　}finally{86

87 　　　　　　if(null!=resultSet){88

89 　　　　　　　　try{90

91 resultSet.close();92

93 　　　　　　　　} catch(SQLException e) {94

95 　　　　　　　　　　//TODO Auto-generated catch block

97 e.printStackTrace();98

99 }100

101 }102

103 　　　　　　if(null!=preparedStatement){104

105 　　　　　　　　try{106

107 preparedStatement.close();108

109 　　　　　　　　} catch(SQLException e) {110

111 　　　　　　　　　　//TODO Auto-generated catch block

112

113 e.printStackTrace();114

115 }116

117 }118

119 　　　　　　if(null!=connection){120

121 　　　　　　　　try{122

123 connection.close();124

125 　　　　　　　　} catch(SQLException e) {126

127 　　　　　　　　　　//TODO Auto-generated catch block

128

129 e.printStackTrace();130

131 }132

133 }134

135 }136

137 　　　　returnlist;138

139 }140

141 }

View Code

package cn.gzsxt.lucene.dao;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import cn.gzsxt.lucene.pojo.Book;

public class BookDao {

public List getAll() {

// 数据库链接

Connection connection = null;

// 预编译statement

PreparedStatement preparedStatement = null;

// 结果集

ResultSet resultSet = null;

// 图书列表

List list = new ArrayList();

try {

// 加载数据库驱动

Class.forName("com.mysql.jdbc.Driver");

// 连接数据库

connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/lucene", "root", "gzsxt");

// SQL语句

String sql = "SELECT * FROM book";

// 创建preparedStatement

preparedStatement = connection.prepareStatement(sql);

// 获取结果集

resultSet = preparedStatement.executeQuery();

// 结果集解析

while (resultSet.next()) {

Book book = new Book();

book.setBookId(resultSet.getInt("id"));

book.setName(resultSet.getString("name"));

book.setPrice(resultSet.getFloat("price"));

book.setPic(resultSet.getString("pic"));

book.setDescription(resultSet.getString("description"));

list.add(book);

}

} catch (Exception e) {

e.printStackTrace();

}finally {

if(null!=resultSet){

try {

resultSet.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

if(null!=preparedStatement){

try {

preparedStatement.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

if(null!=connection){

try {

connection.close();

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return list;

}

(3)创建一个测试类BookDaoTest

1 packagecn.gzsxt.lucene.test;2

3 importjava.util.List;4

5 importorg.junit.Test;6

7 importcn.gzsxt.lucene.dao.BookDao;8

9 importcn.gzsxt.lucene.pojo.Book;10

11 public classBookDaoTest {12

13 @Test14

15 public voidgetAll(){16

17 BookDao dao = newBookDao();18

19 List books =dao.getAll();20

21 for(Book book : books) {22

23 System.out.println("图书id:"+book.getBookId()+",图书名称:"+book.getName());24

25 }26

27 }28

29 }

View Code

package cn.gzsxt.lucene.test;

import java.util.List;

import org.junit.Test;

import cn.gzsxt.lucene.dao.BookDao;

import cn.gzsxt.lucene.pojo.Book;

public class BookDaoTest {

@Test

public void getAll(){

BookDao dao = new BookDao();

List books = dao.getAll();

for (Book book : books) {

System.out.println("图书id:"+book.getBookId()+",图书名称:"+book.getName());

}

(4)测试结果，采集数据成功

2.3.2.2 第二步：将数据转换成Lucene文档

Lucene是使用文档类型来封装数据的，所有需要先将采集的数据转换成文档类型。其格式为：

修改BookDao，新增一个方法，转换数据

public List getDocuments(List books){

// Document对象集合

List docList = new ArrayList();

// Document对象

Document doc = null;

for (Book book : books) {

// 创建Document对象，同时要创建field对象

doc = new Document();

// 根据需求创建不同的Field

Field id = new TextField("id", book.getBookId().toString(), Store.YES);

Field name = new TextField("name", book.getName(), Store.YES);

Field price = new TextField("price", book.getPrice().toString(),Store.YES);

Field pic = new TextField("pic", book.getPic(), Store.YES);

Field desc = new TextField("description", book.getDescription(), Store.YES);

// 把域(Field)添加到文档(Document)中

doc.add(id);

doc.add(name);

doc.add(price);

doc.add(pic);

doc.add(desc);

docList.add(doc);

}

return docList;

}

2.3.2.3 第三步：创建索引库

说明：Lucene是在将文档写入索引库的过程中，自动完成分词、创建索引的。因此创建索引库，从形式上看，就是将文档写入索引库！

修改测试类，新增createIndex方法

1 @Test2

3 public voidcreateIndex(){4

5 　　try{6

7 　　　　BookDao dao = newBookDao();8

9 　　　　//分析文档，对文档中的field域进行分词

11 　　　　Analyzer analyzer = newStandardAnalyzer();12

13 　　　　//创建索引14

15 　　　　//1) 创建索引库目录

17 　　　　Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));18

19 　　　　//2) 创建IndexWriterConfig对象

21 　　　　IndexWriterConfig cfg = newIndexWriterConfig(Version.LATEST, analyzer);22

23 　　　　//3) 创建IndexWriter对象

25 　　　　IndexWriter writer = newIndexWriter(directory, cfg);26

27 　　　　//4) 通过IndexWriter对象添加文档对象(document)

29 writer.addDocuments(dao.getDocuments(dao.getAll()));30

31 　　　　//5) 关闭IndexWriter

33 writer.close();34

35 　　　　System.out.println("创建索引库成功");36

37 　　} catch(Exception e) {38

39 e.printStackTrace();40

41 }42

43 }

View Code

@Test

public void createIndex(){

try {

BookDao dao = new BookDao();

// 分析文档，对文档中的field域进行分词

Analyzer analyzer = new StandardAnalyzer();

// 创建索引

// 1) 创建索引库目录

Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));

// 2) 创建IndexWriterConfig对象

IndexWriterConfig cfg = new IndexWriterConfig(Version.LATEST, analyzer);

// 3) 创建IndexWriter对象

IndexWriter writer = new IndexWriter(directory, cfg);

// 4) 通过IndexWriter对象添加文档对象(document)

writer.addDocuments(dao.getDocuments(dao.getAll()));

// 5) 关闭IndexWriter

writer.close();

System.out.println("创建索引库成功");

} catch (Exception e) {

e.printStackTrace();

}

测试结果，创建成功！！！

2.3.3 第三部分：搜索索引

2.3.3.1 说明

搜索的时候，需要指定搜索哪一个域(也就是字段)，并且，还要对搜索的关键词做分词处理。

2.3.3.2 执行搜索

修改测试类，新增searchDocumentByIndex方法

1 @Test2

3 public voidsearchDocumentByIndex(){4

5 　　try{6

7 　　　　//1、创建查询(Query对象)8

9 　　　　//创建分析器

11 　　　　Analyzer analyzer = newStandardAnalyzer();12

13 　　　　QueryParser queryParser = new QueryParser("name", analyzer);14

15 　　　　Query query = queryParser.parse("name:java教程");16

17 　　　　//2、执行搜索18

19 　　　　//a) 指定索引库目录

21 　　　　Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));22

23 　　　　//b) 创建IndexReader对象

25 　　　　IndexReader reader =DirectoryReader.open(directory);26

27 　　　　//c) 创建IndexSearcher对象

29 　　　　IndexSearcher searcher = newIndexSearcher(reader);30

31 　　　　//d) 通过IndexSearcher对象执行查询索引库，返回TopDocs对象32

33 　　　　//第一个参数：查询对象34

35 　　　　//第二个参数：最大的n条记录

37 　　　　TopDocs topDocs = searcher.search(query, 10);38

39 　　　　//e) 提取TopDocs对象中前n条记录

41 　　　　ScoreDoc[] scoreDocs =topDocs.scoreDocs;42

43 　　　　System.out.println("查询出文档个数为：" +topDocs.totalHits);44

45 　　　　for(ScoreDoc scoreDoc : scoreDocs) {46

47 　　　　　　//文档对象ID

49 　　　　　　int docId =scoreDoc.doc;50

51 　　　　　　Document doc =searcher.doc(docId);52

53 　　　　　　//f) 输出文档内容

55 　　　　　　System.out.println("===============================");56

57 　　　　　　System.out.println("文档id:" +docId);58

59 　　　　　　System.out.println("图书id:" + doc.get("id"));60

61 　　　　　　System.out.println("图书name:" + doc.get("name"));62

63 　　　　　　System.out.println("图书price:" + doc.get("price"));64

65 　　　　　　System.out.println("图书pic:" + doc.get("pic"));66

67 　　　　　　System.out.println("图书description:" + doc.get("description"));68

69 }70

71 　　　　//g) 关闭IndexReader

73 reader.close();74

75 　　} catch(Exception e) {76

77 　　　　//TODO Auto-generated catch block

79 e.printStackTrace();80

81 }82

83 }

@Test

public void searchDocumentByIndex(){

try {

// 1、创建查询(Query对象)

// 创建分析器

Analyzer analyzer = new StandardAnalyzer();

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

Query query = queryParser.parse("name:java教程");

// 2、执行搜索

// a) 指定索引库目录

Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));

// b) 创建IndexReader对象

IndexReader reader = DirectoryReader.open(directory);

// c) 创建IndexSearcher对象

IndexSearcher searcher = new IndexSearcher(reader);

// d) 通过IndexSearcher对象执行查询索引库，返回TopDocs对象

// 第一个参数：查询对象

// 第二个参数：最大的n条记录

TopDocs topDocs = searcher.search(query, 10);

// e) 提取TopDocs对象中前n条记录

ScoreDoc[] scoreDocs = topDocs.scoreDocs;

System.out.println("查询出文档个数为：" + topDocs.totalHits);

for (ScoreDoc scoreDoc : scoreDocs) {

// 文档对象ID

int docId = scoreDoc.doc;

Document doc = searcher.doc(docId);

// f) 输出文档内容

System.out.println("===============================");

System.out.println("文档id:" + docId);

System.out.println("图书id:" + doc.get("id"));

System.out.println("图书name:" + doc.get("name"));

System.out.println("图书price:" + doc.get("price"));

System.out.println("图书pic:" + doc.get("pic"));

System.out.println("图书description:" + doc.get("description"));

}

// g) 关闭IndexReader

reader.close();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

测试结果，非常成功！！！

2.4 小结

Lucene全文检索，确实可以实现对关键词做分词、再执行搜索功能。并且结果更精确。

3 分词

3.1 重要性

分词是全文检索的核心。

所谓的分词，就是将一段文本，根据一定的规则，拆分成一个一个词。

Lucene是根据分析器实现分词的。针对不同的语言提供了不同的分析器。并且提供了一个通用的标准分析器StandardAnalyzer

3.2 分词过程

--说明：我们通过分析StandardAnalyzer核心源码来分析分词过程

1 @Override2

3 protected TokenStreamComponents createComponents(final String fieldName, finalReader reader) {4

5 　　final StandardTokenizer src = newStandardTokenizer(getVersion(), reader);6

7 src.setMaxTokenLength(maxTokenLength);8

9 　　TokenStream tok = newStandardFilter(getVersion(), src);10

11 　　tok = newLowerCaseFilter(getVersion(), tok);12

13 　　tok = newStopFilter(getVersion(), tok, stopwords);14

15 　　return newTokenStreamComponents(src, tok) {16

17 @Override18

19 　　　　protected void setReader(final Reader reader) throwsIOException {20

21 　　　　src.setMaxTokenLength(StandardAnalyzer.this.maxTokenLength);22

23 　　　　super.setReader(reader);24

25 }26

27 };28

29 }

@Override

protected TokenStreamComponents createComponents(final String fieldName, final Reader reader) {

final StandardTokenizer src = new StandardTokenizer(getVersion(), reader);

src.setMaxTokenLength(maxTokenLength);

TokenStream tok = new StandardFilter(getVersion(), src);

tok = new LowerCaseFilter(getVersion(), tok);

tok = new StopFilter(getVersion(), tok, stopwords);

return new TokenStreamComponents(src, tok) {

@Override

protected void setReader(final Reader reader) throws IOException {

src.setMaxTokenLength(StandardAnalyzer.this.maxTokenLength);

super.setReader(reader);

}

};

}

对应Lucene分词的过程，我们可以做如下总结：

(1)分词的时候，是以域为单位的。不同的域，相互独立。

同一个域中，拆分出来相同的词，视为同一个词(Term)

不同的域中，拆分出来相同的词，不是同一个词。由下图可以看出，在name域和desc域中都有java。

其中，Term是Lucene最小的语汇单元，不可再细分。

(2)分词的时候经历了一系列的过滤器。如大小写转换、去除停用词等。

3.3 分词后索引库结构

我们这里借助前面的示例来说明

从上图中，我们发现：

(1)索引库中有两个区域：索引区、文档区。

(2)文档区存放的是文档。Lucene给每一个文档自动加上一个文档编号docID。

(3)索引区存放的是索引。注意：

索引是以域为单位的，不同的域，彼此相互独立。

索引是根据分词规则创建出来的，根据索引就能找到对应的文档。

3.4 Luke客户端连接索引库

Luke作为Lucene工具包中的一个工具(http://www.getopt.org/luke/)，可以通过可视化界面，连接操作索引库。

3.4.1 启动方法

(1)双击start.bat启动！

(2)连接索引库

3.4.2 验证分词效果

4 Field域

问题：我们已经知道，Lucene是在写入文档时，完成分词、索引的。那Lucene是怎么知道如何分词的呢？

答：Lucene是根据文档中的域的属性，来确定是否要分词、创建索引的。所以，我们必须搞清楚域有哪些属性。

4.1 域的属性

4.1.1 三大属性

4.1.1.1 是否分词(tokenized)

只有设置了分词属性为true，lucene才会对这个域进行分词处理。

在实际的开发中，有一些字段是不需要分词的，比如商品id，商品图片等。

而有一些字段是必须分词的，比如商品名称，描述信息等。

4.1.1.2 是否索引(indexed)

只有设置了索引属性为true，lucene才为这个域的Term词创建索引。

在实际的开发中，有一些字段是不需要创建索引的，比如商品的图片等。我们只需要对参与搜索的字段做索引处理。

4.1.1.3 是否存储(stored)

只有设置了存储属性为true，在查找的时候，才能从文档中获取这个域的值。

在实际开发中，有一些字段是不需要存储的。比如：商品的描述信息。

因为商品描述信息，通常都是大文本数据，读的时候会造成巨大的IO开销。而描述信息是不需要经常查询的字段，这样的话就白白浪费了cpu的资源了。

因此，像这种不需要经常查询，又是大文本的字段，通常不会存储到索引库。

4.1.2 特点

(1)三大属性彼此独立。

(2)通常分词是为了创建索引。

(3)不存储这个域文本内容，也可以对这个域先分词、创建索引。

4.2 Field常用类型

域的常用类型有很多，每一个类都有自己默认的三大属性。如下：

Field类

数据类型

Analyzed

是否分词

Indexed

是否索引

Stored

是否存储

StringField(FieldName, FieldValue,Store.YES))

字符串

Y或N

LongField(FieldName, FieldValue,Store.YES)

Long型

Y或N

FloatField(FieldName, FieldValue,Store.YES)

Float型

Y或N

StoredField(FieldName, FieldValue)

重载方法，支持多种类型

TextField(FieldName, FieldValue, Store.NO)

字符串

Y或N

(不单单是这些，还有像DoubleField等等)

4.3 改造入门示例中的域类型

4.3.1 分析

(1)图书id：

是否分词：不用分词，因为不会根据商品id来搜索商品

是否索引：不索引，因为不需要根据图书ID进行搜索

是否存储：要存储，因为查询结果页面需要使用id这个值。

(2)图书名称：

是否分词：要分词，因为要将图书的名称内容分词索引，根据关键搜索图书名称抽取的词。

是否索引：要索引。

是否存储：要存储。

(3)图书价格：

是否分词：要分词，lucene对数字型的值只要有搜索需求的都要分词和索引，因为lucene对数字型的内容要特殊分词处理，本例子可能要根据价格范围搜索，需要分词和索引。

是否索引：要索引

是否存储：要存储

(4)图书图片地址：

是否分词：不分词

是否索引：不索引

是否存储：要存储

(5)图书描述：

是否分词：要分词

是否索引：要索引

是否存储：因为图书描述内容量大，不在查询结果页面直接显示，不存储。

不存储是来不在lucene的索引文件中记录，节省lucene的索引文件空间，如果要在详情页面显示描述，思路：

从lucene中取出图书的id，根据图书的id查询关系数据库中book表得到描述信息。

4.3.2 代码修改

修改BookDao的getDocument方法

1 public List getDocuments(Listbooks){2

3 　　//Document对象集合

5 　　List docList = new ArrayList();6

7 　　//Document对象

9 　　Document doc = null;10

11 　　for(Book book : books) {12

13 　　　　//创建Document对象，同时要创建field对象

15 　　　　doc = newDocument();16

17 　　　　//图书ID18

19 　　　　//参数：域名、域中存储的内容、是否存储20

21 　　　　//不分词、索引、要存储22

23 　　　　//Field id = new TextField("id", book.getId().toString(),Store.YES);

25 　　　　Field id = new StoredField("id", book.getBookId().toString());26

27 　　　　//图书名称28

29 　　　　//分词、索引、存储

31 　　　　Field name = new TextField("name", book.getName(),Store.YES);32

33 　　　　//图书价格34

35 　　　　//分词、索引、存储

37 　　　　Field price = new FloatField("price", book.getPrice(), Store.YES);38

39 　　　　//图书图片40

41 　　　　//不分词、不索引、要存储

43 　　　　Field pic = new StoredField("pic", book.getPic());44

45 　　　　//图书描述46

47 　　　　//分词、索引、不存储

49 　　　　Field desc = new TextField("description",book.getDescription(), Store.NO);50

51 　　　　//把域(Field)添加到文档(Document)中

53 doc.add(id);54

55 doc.add(name);56

57 doc.add(price);58

59 doc.add(pic);60

61 doc.add(desc);62

63 docList.add(doc);64

65 }66

67 　　returndocList;68

69 }

View Code

public List getDocuments(List books){

// Document对象集合

List docList = new ArrayList();

// Document对象

Document doc = null;

for (Book book : books) {

// 创建Document对象，同时要创建field对象

doc = new Document();

// 图书ID

// 参数：域名、域中存储的内容、是否存储

// 不分词、索引、要存储

// Field id = new TextField("id", book.getId().toString(),Store.YES);

Field id =newStoredField("id", book.getBookId().toString());

// 图书名称

// 分词、索引、存储

Field name =newTextField("name", book.getName(),Store.YES);

// 图书价格

// 分词、索引、存储

Field price =newFloatField("price", book.getPrice(), Store.YES);

// 图书图片

// 不分词、不索引、要存储

Field pic =newStoredField("pic", book.getPic());

// 图书描述

// 分词、索引、不存储

Field desc =newTextField("description",book.getDescription(), Store.NO);

// 把域(Field)添加到文档(Document)中

doc.add(id);

doc.add(name);

doc.add(price);

doc.add(pic);

doc.add(desc);

docList.add(doc);

}

return docList;

}

4.3.3 测试

(1)去索引库目录中，手动清空索引库。

(2)重新创建索引库。

(3)使用Luke验证分词、索引效果。

改造成功！！！

5 索引库维护

在第4节，我们需要重新创建索引的时候，是去索引库目录下，手动删除的。

而在实际的开发中，我们可能压根就不知道索引库在哪，就算知道，我们也不可能每次都去手动删除，非常之麻烦！！！

所以，我们必须学习如何维护索引库，使用程序来操作索引库。

需要注意的是，索引是与文档紧密相连的，因此对索引的维护，实际上就是对文档的增删改。

5.1 添加索引(文档)

5.1.1 需求

数据库中新上架了图书，必须把这些图书也添加到索引库中，不然就搜不到该新上架的图书了。

5.1.2 代码实现

调用 indexWriter.addDocument(doc)添加索引。

参考入门示例中的创建索引。

5.2 删除索引(文档)

5.2.1 需求

某些图书不再出版销售了，我们需要从索引库中移除该图书。

5.2.2 代码实现

1@Test2

3 public void deleteIndex() throwsException {4

5 　　//1、指定索引库目录

7 　　Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));8

9 　　//2、创建IndexWriterConfig

11 　　IndexWriterConfig cfg = newIndexWriterConfig(Version.LATEST,12

13 　　newStandardAnalyzer());14

15 　　//3、创建IndexWriter

17 　　IndexWriter writer = newIndexWriter(directory, cfg);18

19 　　//4、通过IndexWriter来删除索引20

21 　　//删除指定索引

23 　　writer.deleteDocuments(new Term("name", "apache"));24

25 　　//5、关闭IndexWriter

27 writer.close();28

29 　　System.out.println("删除成功");30

31 }

@Test

public void deleteIndex() throws Exception {

// 1、指定索引库目录

Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));

// 2、创建IndexWriterConfig

IndexWriterConfig cfg = new IndexWriterConfig(Version.LATEST,

new StandardAnalyzer());

// 3、创建IndexWriter

IndexWriter writer = new IndexWriter(directory, cfg);

// 4、通过IndexWriter来删除索引

// 删除指定索引

writer.deleteDocuments(newTerm("name", "apache"));

// 5、关闭IndexWriter

writer.close();

System.out.println("删除成功");

}

5.2.3 清空索引库

1@Test2

3 public void deleteIndex() throwsException {4

5 　　//1、指定索引库目录

7 　　Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));8

9 　　//2、创建IndexWriterConfig

11 　　IndexWriterConfig cfg = newIndexWriterConfig(Version.LATEST,12

13 　　newStandardAnalyzer());14

15 　　//3、创建IndexWriter

17 　　IndexWriter writer = newIndexWriter(directory, cfg);18

19 　　//4、通过IndexWriter来删除索引20

21 　　//删除指定索引

23 writer.deleteAll();24

25 　　//5、关闭IndexWriter

27 writer.close();28

29 　　System.out.println("清空索引库成功");30

31 }

@Test

public void deleteIndex() throws Exception {

// 1、指定索引库目录

Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));

// 2、创建IndexWriterConfig

IndexWriterConfig cfg = new IndexWriterConfig(Version.LATEST,

new StandardAnalyzer());

// 3、创建IndexWriter

IndexWriter writer = new IndexWriter(directory, cfg);

// 4、通过IndexWriter来删除索引

// 删除指定索引

writer.deleteAll();

// 5、关闭IndexWriter

writer.close();

System.out.println("清空索引库成功");

}

5.3 更新索引(文档)

5.3.1 说明

Lucene更新索引比较特殊，是先删除满足条件的索引，再添加新的索引。

5.3.2 代码实现

1 //修改索引

3 @Test4

5 public void updateIndex() throwsException {6

7 　　//1、指定索引库目录

9 　　Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));10

11 　　//2、创建IndexWriterConfig

13 　　IndexWriterConfig cfg = newIndexWriterConfig(Version.LATEST,14

15 　　newStandardAnalyzer());16

17 　　//3、创建IndexWriter

19 　　IndexWriter writer = newIndexWriter(directory, cfg);20

21 　　//4、通过IndexWriter来修改索引22

23 　　//a)、创建修改后的文档对象

25 　　Document document = newDocument();26

27 　　//文件名称

29 　　Field filenameField = new StringField("name", "updateIndex", Store.YES);30

31 document.add(filenameField);32

33 　　//修改指定索引为新的索引

35 　　writer.updateDocument(new Term("name", "apache"), document);36

37 　　//5、关闭IndexWriter

39 writer.close();40

41 　　System.out.println("更新成功");42

43 }

// 修改索引

@Test

public void updateIndex() throws Exception {

// 1、指定索引库目录

Directory directory = FSDirectory.open(new File("F:\\lucene\\0719"));

// 2、创建IndexWriterConfig

IndexWriterConfig cfg = new IndexWriterConfig(Version.LATEST,

new StandardAnalyzer());

// 3、创建IndexWriter

IndexWriter writer = new IndexWriter(directory, cfg);

// 4、通过IndexWriter来修改索引

// a)、创建修改后的文档对象

Document document = new Document();

// 文件名称

Field filenameField = new StringField("name", "updateIndex", Store.YES);

document.add(filenameField);

// 修改指定索引为新的索引

writer.updateDocument(new Term("name", "apache"), document);

// 5、关闭IndexWriter

writer.close();

System.out.println("更新成功");

}

6 搜索

问题：我们在入门示例中，已经知道Lucene是通过IndexSearcher对象，来执行搜索的。那我们为什么还要继续学习Lucene的查询呢？

答：因为在实际的开发中，我们的查询的业务是相对复杂的，比如我们在通过关键词查找的时候，往往进行价格、商品类别的过滤。

而Lucene提供了一套查询方案，供我们实现复杂的查询。

6.1 创建查询的两种方法

执行查询之前，必须创建一个查询Query查询对象。

Query自身是一个抽象类，不能实例化，必须通过其它的方式来实现初始化。

在这里，Lucene提供了两种初始化Query查询对象的方式。

6.1.1 使用Lucene提供Query子类

Query是一个抽象类，lucene提供了很多查询对象，比如TermQuery项精确查询，NumericRangeQuery数字范围查询等。

使用TermQuery实例化

Query query = new TermQuery(new Term("name", "lucene"));

6.1.2 使用QueryParse解析查询表达式

QueryParser会将用户输入的查询表达式解析成Query对象实例。如下代码：

QueryParser queryParser = new QueryParser("name", new IKAnalyzer());

Query query = queryParser.parse("name:lucene");

6.2 常用的Query子类搜索

6.2.1 TermQuery

特点：查询的关键词不会再做分词处理，作为整体来搜索。代码如下：

1 /**

3 * Query子类查询之 TermQuery4

5 *6

7 * 特点：不会再对查询的关键词做分词处理。8

9 *10

11 * 需要：查询书名与java教程相关书。12

13 */

15 @Test16

17 public voidqueryByTermQuery(){18

19 　　//1、获取一个查询对象

21 　　Query query = new TermQuery(new Term("name", "编程思想"));22

23 doSearch(query);24

25 }26

27 private voiddoSearch(Query query) {28

29 　　try{30

31 　　　　//2、创建一个查询的执行对象32

33 　　　　//指定索引库的目录

35 　　　　Directory d = FSDirectory.open(new File("F:\\lucene\\0719"));36

37 　　　　//创建流对象

39 　　　　IndexReader reader =DirectoryReader.open(d);40

41 　　　　//创建搜索执行对象

43 　　　　IndexSearcher searcher = newIndexSearcher(reader);44

45 　　　　//3、执行搜索

47 　　　　TopDocs result = searcher.search(query, 10);48

49 　　　　//4、提出结果集，获取图书的信息

51 　　　　int totalHits =result.totalHits;52

53 　　　　System.out.println("共查询到"+totalHits+"条满足条件的数据!");54

55 　　　　System.out.println("-----------------------------------------");56

57 　　　　//提取图书信息。58

59 　　　　//score即相关度。即搜索的关键词和图书名称的相关度，用来做排序处理

61 　　　　ScoreDoc[] scoreDocs =result.scoreDocs;62

63 　　　　for(ScoreDoc scoreDoc : scoreDocs) {64

65 　　　　　　/**

67 * scoreDoc.doc的返回值，是文档的id，即将文档写入索引库的时候，lucene自动给这份文档做的一个编号。68

69 *70

71 * 获取到这个文档id之后，即可以根据这个id，找到这份文档。72

73 　　　　　　*/

75 　　　　　　int docId =scoreDoc.doc;76

77 　　　　　　System.out.println("文档在索引库中的编号:"+docId);78

79 　　　　　　//从文档中提取图书的信息

81 　　　　　　Document doc =searcher.doc(docId);82

83 　　　　　　System.out.println("图书id:"+doc.get("id"));84

85 　　　　　　System.out.println("图书name:"+doc.get("name"));86

87 　　　　　　System.out.println("图书price:"+doc.get("price"));88

89 　　　　　　System.out.println("图书pic:"+doc.get("pic"));90

91 　　　　　　System.out.println("图书description:"+doc.get("description"));92

93 System.out.println();94

95 　　　　　　System.out.println("------------------------------------");96

97 }98

99 　　　　//关闭连接，释放资源

100

101 　　　　if(null!=reader){102

103 reader.close();104

105 }106

107 　　} catch(Exception e) {108

109 e.printStackTrace();110

111 }112

113 }

/**

* Query子类查询之 TermQuery

* 特点：不会再对查询的关键词做分词处理。

* 需要：查询书名与java教程相关书。

@Test

public void queryByTermQuery(){

//1、获取一个查询对象

Query query = new TermQuery(new Term("name", "编程思想"));

doSearch(query);

}

private void doSearch(Query query) {

try {

//2、创建一个查询的执行对象

//指定索引库的目录

Directory d = FSDirectory.open(new File("F:\\lucene\\0719"));

//创建流对象

IndexReader reader = DirectoryReader.open(d);

//创建搜索执行对象

IndexSearcher searcher = new IndexSearcher(reader);

//3、执行搜索

TopDocs result = searcher.search(query, 10);

//4、提出结果集，获取图书的信息

int totalHits = result.totalHits;

System.out.println("共查询到"+totalHits+"条满足条件的数据!");

System.out.println("-----------------------------------------");

//提取图书信息。

//score即相关度。即搜索的关键词和图书名称的相关度，用来做排序处理

ScoreDoc[] scoreDocs = result.scoreDocs;

for (ScoreDoc scoreDoc : scoreDocs) {

/**

* scoreDoc.doc的返回值，是文档的id，即将文档写入索引库的时候，lucene自动给这份文档做的一个编号。

* 获取到这个文档id之后，即可以根据这个id，找到这份文档。

int docId = scoreDoc.doc;

System.out.println("文档在索引库中的编号:"+docId);

//从文档中提取图书的信息

Document doc = searcher.doc(docId);

System.out.println("图书id:"+doc.get("id"));

System.out.println("图书name:"+doc.get("name"));

System.out.println("图书price:"+doc.get("price"));

System.out.println("图书pic:"+doc.get("pic"));

System.out.println("图书description:"+doc.get("description"));

System.out.println();

System.out.println("------------------------------------");

}

//关闭连接，释放资源

if(null!=reader){

reader.close();

}

} catch (Exception e) {

e.printStackTrace();

}

6.2.2 NumericRangeQuery

指定数字范围查询.(创建field类型时，注意与之对应)

1 /**

3 * Query子类查询之 NumricRangeQuery4

5 * 需求：查询所有价格在[60,80)之间的书6

7 *@paramquery8

9 */

11 @Test12

13 public voidqueryByNumricRangeQuery(){14

15 　　/**

17 * 第一个参数：要搜索的域18

19 * 第二个参数：最小值20

21 * 第三个参数：最大值22

23 * 第四个参数：是否包含最小值24

25 * 第五个参数：是否包含最大值26

27 　　*/

29 　　Query query = NumericRangeQuery.newFloatRange("price", 60.0f, 80.0f, true, false);30

31 doSearch(query);32

33 }

/**

* Query子类查询之 NumricRangeQuery

* 需求：查询所有价格在[60,80)之间的书

* @param query

@Test

public void queryByNumricRangeQuery(){

/**

* 第一个参数：要搜索的域

* 第二个参数：最小值

* 第三个参数：最大值

* 第四个参数：是否包含最小值

* 第五个参数：是否包含最大值

Query query = NumericRangeQuery.newFloatRange("price", 60.0f, 80.0f, true, false);

doSearch(query);

}

6.2.3 BooleanQuery

BooleanQuery，布尔查询，实现组合条件查询。

1 /**

3 * Query子类查询之 BooelanQuery查询组合条件查询4

5 *6

7 * 需求：查询书名包含java，并且价格区间在[60,80)之间的书。8

9 */

11 @Test12

13 public voidqueryBooleanQuery(){14

15 　　//1、要使用BooelanQuery查询，首先要把单个创建出来，然后再通过BooelanQuery组合

17 　　Query price = NumericRangeQuery.newFloatRange("price", 60.0f, 80.0f, true, false);18

19 　　Query name = new TermQuery(new Term("name", "java"));20

21 　　//2、创建BooleanQuery实例对象

23 　　BooleanQuery query = newBooleanQuery();24

25 query.add(name, Occur.MUST_NOT);26

27 query.add(price, Occur.MUST);28

29 　　/**

31 * MSUT 表示必须满足对应的是 +32

33 * MSUT_NOT 必须不满足应对的是 -34

35 * SHOULD 可以满足也可以不满足没有符号36

37 *38

39 * SHOULD 与MUST、MUST_NOT组合的时候，SHOULD就没有意义了。40

41 　　*/

43 doSearch(query);44

45 }

/**

* Query子类查询之 BooelanQuery查询组合条件查询

* 需求：查询书名包含java，并且价格区间在[60,80)之间的书。

@Test

public void queryBooleanQuery(){

//1、要使用BooelanQuery查询，首先要把单个创建出来，然后再通过BooelanQuery组合

Query price = NumericRangeQuery.newFloatRange("price", 60.0f, 80.0f, true, false);

Query name = new TermQuery(new Term("name", "java"));

//2、创建BooleanQuery实例对象

BooleanQuery query = new BooleanQuery();

query.add(name, Occur.MUST_NOT);

query.add(price, Occur.MUST);

/**

* MSUT 表示必须满足对应的是 +

* MSUT_NOT 必须不满足应对的是 -

* SHOULD 可以满足也可以不满足没有符号

* SHOULD 与MUST、MUST_NOT组合的时候，SHOULD就没有意义了。

doSearch(query);

}

6.3 通过QueryParser搜索

6.3.1 特点

对搜索的关键词，做分词处理。

6.3.2 语法

6.3.2.1 基础语法

域名:关键字

实例：name:java

6.3.2.2 组合条件语法

条件1 AND 条件2

条件1 OR 条件2

条件1 NOT 条件2

6.3.3 QueryParser

6.3.3.1 代码实现

1 /**

3 * 查询解析器查询之 QueryParser查询4

5 */

7 @Test8

9 public voidqueryByQueryParser(){10

11 　　try{12

13 　　　　//1、加载分词器

15 　　　　Analyzer analyzer = newStandardAnalyzer();16

17 　　　　/**

19 * 2、创建查询解析器实例对象20

21 * 第一个参数：默认搜索的域。22

23 * 如果在搜索的时候，没有特别指定搜索的域，则按照默认的域进行搜索24

25 * 如何在搜索的时候指定搜索域呢？26

27 * 答：格式域名：关键词即 name:java教程28

29 *30

31 * 第二个参数：分词器，对关键词做分词处理32

33 　　　　*/

35 　　　　QueryParser parser = new QueryParser("description", analyzer);36

37 　　　　//设置组合条件查询38

39 　　　　//Query query = queryParser.parse("name:java教程 or description:apache");40

41 　　　　//Query query = queryParser.parse("name:java教程 or apache");

43 　　　　Query query = parser.parse("name:java教程");44

45 doSearch(query);46

47 　　} catch(Exception e) {48

49 e.printStackTrace();50

51 }52

53 }

/**

* 查询解析器查询之 QueryParser查询

@Test

public void queryByQueryParser(){

try {

//1、加载分词器

Analyzer analyzer = new StandardAnalyzer();

/**

* 2、创建查询解析器实例对象

* 第一个参数：默认搜索的域。

* 如果在搜索的时候，没有特别指定搜索的域，则按照默认的域进行搜索

* 如何在搜索的时候指定搜索域呢？

* 答：格式域名：关键词即 name:java教程

* 第二个参数：分词器，对关键词做分词处理

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

// 设置组合条件查询

// Query query = queryParser.parse("name:java教程 or description:apache");

// Query query = queryParser.parse("name:java教程 or apache");

Query query = parser.parse("name:java教程");

doSearch(query);

} catch (Exception e) {

e.printStackTrace();

}

6.3.4 MultiFieldQueryParser

通过MulitFieldQueryParse对多个域查询。

1 /**

3 * 查询解析器查询之 MultiFieldQueryParser查询4

5 *6

7 * 特点：同时指定多个搜索域，并且对关键做分词处理8

9 */

11 @Test12

13 public voidqueryByMultiFieldQueryParser(){14

15 　　try{16

17 　　　　//1、定义多个搜索的 name、description

19 　　　　String[] fields = {"name","description"};20

21 　　　　//2、加载分词器

23 　　　　Analyzer analyzer = newStandardAnalyzer();24

25 　　　　//3、创建 MultiFieldQueryParser实例对象

27 　　　　MultiFieldQueryParser mParser = newMultiFieldQueryParser(fields, analyzer);28

29 　　　　Query query = mParser.parse("lucene教程");30

31 doSearch(query);32

33 　　} catch(Exception e) {34

35 e.printStackTrace();36

37 }38

39 }

/**

* 查询解析器查询之 MultiFieldQueryParser查询

* 特点：同时指定多个搜索域，并且对关键做分词处理

@Test

public void queryByMultiFieldQueryParser(){

try {

//1、定义多个搜索的 name、description

String[] fields = {"name","description"};

//2、加载分词器

Analyzer analyzer = new StandardAnalyzer();

//3、创建 MultiFieldQueryParser实例对象

MultiFieldQueryParser mParser = new MultiFieldQueryParser(fields, analyzer);

Query query = mParser.parse("lucene教程");

doSearch(query);

} catch (Exception e) {

e.printStackTrace();

}

Jasin Yip

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
mysql lucene怎么读_Lucene：一、入门

1 Lucene简介Lucene是apache下的一个开源的全文检索引擎工具包。1.1 全文检索(Full-text Search)1.1.1 定义全文检索就是先分词创建索引，再执行搜索的过程。分词：就是将一段文字分成一个个单词全文检索就将一段文字分成一个个单词去查询数据！！！1.1.2 应用场景1.1.2.1 搜索引擎(了解)搜索引擎是一个基于全文检索、能独立运行、提供搜索服务的软件系统。1.2...
复制链接

扫一扫