在说全文检索之前,先说说数据库搜索,数据库中的搜索很容易实现，通常都是使用sql语句进行查询，而且能很快的得到查询结果。
为什么数据库搜索很容易？
因为数据库中的数据存储是有规律的，有行有列而且数据格式、数据长度都是固定的。
数据分类
我们生活中的数据总体分为两种：结构化数据和非结构化数据。
结构化数据：指具有固定格式或有限长度的数据，如数据库，元数据等。
非结构化数据：指不定长或无固定格式的数据，如邮件，word文档等磁盘上的文件
非结构化数据查询方法
1.顺序扫描法(Serial Scanning)
所谓顺序扫描，比如要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每一个文档，从头看到尾，如果此文档包含此字符串，则此文档为我们要找的文件，接着看下一个文件，直到扫描完所有的文件。如利用windows的搜索也可以搜索文件内容，只是相当的慢。
2.全文检索(Full-text Search)
将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。
例如：字典。字典的拼音表和部首检字表就相当于字典的索引，对每一个字的解释是非结构化的，如果字典没有音节表和部首检字表，在茫茫辞海中找一个字只能顺序扫描。然而字的某些信息可以提取出来进行结构化处理，比如读音，就比较结构化，分声母和韵母，分别只有几种可以一一列举，于是将读音拿出来按一定的顺序排列，每一项读音都指向此字的详细解释的页数。我们搜索时按结构化的拼音搜到读音，然后按其指向的页数，便可找到我们的非结构化数据——也即对字的解释。
这种先建立索引，再对索引进行搜索的过程就叫全文检索(Full-text Search)。
虽然创建索引的过程也是非常耗时的，但是索引一旦创建就可以多次使用，全文检索主要处理的是查询，所以耗时间创建索引是值得的。
如何实现全文检索
可以使用Lucene实现全文检索。Lucene是apache下的一个开放源代码的全文检索引擎工具包。提供了完整的查询引擎和索引引擎，部分文本分析引擎。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能。
全文检索的应用场景
对于数据量大、数据结构不固定的数据可采用全文检索方式搜索，比如百度、Google等搜索引擎、论坛站内搜索、电商网站站内搜索等。但是百度是收钱的,给钱就往前面拍.
但是我们使用肯定不是做百度这类型的搜索,主要做的是电商项目种种的搜索.
Lucene官网:http://lucene.apache.org/
索引和搜索流程图,在经过左边创建索引的过程后,索引库种会把原始文档和索引存到索引库当中去,后期就算把原始文档删掉也能搜到结果.
创建索引
对文档索引的过程，将用户要搜索的文档内容进行索引，索引存储在索引库（index）中。
这里我们要搜索的文档是磁盘上的文本文件，根据案例描述：凡是文件名或文件内容包括关键字的文件都要找出来，这里要对文件名和文件内容创建索引。
获得原始文档
原始文档是指要索引和搜索的内容。原始内容包括互联网上的网页、数据库中的数据、磁盘上的文件等。
本案例中的原始内容就是磁盘上的文件，如下图：
从互联网上、数据库、文件系统中等获取需要搜索的原始信息，这个过程就是信息采集，信息采集的目的是为了对原始内容进行索引。
在Internet上采集信息的软件通常称为爬虫或蜘蛛，也称为网络机器人，爬虫访问互联网上的每一个网页，将获取到的网页内容存储起来。 Lucene不提供信息采集的类库，需要自己编写一个爬虫程序实现信息采集，也可以通过一些开源软件实现信息采集，如下：
Nutch（http://lucene.apache.org/nutch）, Nutch是apache的一个子项目，包括大规模爬虫工具，能够抓取和分辨web网站数据。
jsoup（http://jsoup.org/ ），jsoup 是一款Java 的HTML解析器，可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。
heritrix（http://sourceforge.net/projects/archive-crawler/files/），Heritrix 是一个由 java 开发的、开源的网络爬虫，用户可以使用它来从网上抓取想要的资源。其最出色之处在于它良好的可扩展性，方便用户实现自己的抓取逻辑。
本案例我们要获取磁盘上文件的内容，可以通过文件流来读取文本文件的内容，对于pdf、doc、xls等文件可通过第三方提供的解析工具读取文件内容，比如Apache POI读取doc和xls的文件内容。
从网上爬取数据只是爬里面的文本信息,从而建立索引,而不爬图片,这几个爬虫都是java写的
创建文档对象
获取原始内容的目的是为了索引，在索引前需要将原始内容创建成文档（Document），文档中包括一个一个的域（Field），域中存储内容。
这里我们可以将磁盘上的一个文件当成一个document，Document中包括一些Field（file_name文件名称、file_path文件路径、file_size文件大小、file_content文件内容），如下图：每个详细信息都可以创建一个域,这里的域就相当于数据库的字段,java对象的属性,只是叫法不一样而已.
注意：每个Document可以有多个Field，不同的Document可以有不同的Field，同一个Document可以有相同的Field（域名和域值都相同）
每个文档都有一个唯一的编号，就是文档id。id的增长方式是自增的从0开始自增1.这个编号不是域.这个编号我们不能进行操作,而其它域可以.
分析文档
将原始内容创建为包含域（Field）的文档（document），需要再对域中的内容进行分析，分析的过程是经过对原始文档提取单词、将字母转为小写、去除标点符号、去除停用词等过程生成最终的语汇单元，可以将语汇单元理解为一个一个的单词。
比如下边的文档经过分析如下：
原文档内容：
Lucene is a Java full-text search engine. Lucene is not a complete
application, but rather a code library and API that can easily be used
to add search capabilities to applications.
分析后得到的语汇单元：
lucene、java、full、search、engine。。。。
每个单词叫做一个Term，不同的域中拆分出来的相同的单词是不同的term。term中包含两部分一部分是文档的域名，另一部分是单词的内容。
例如：文件名中包含apache和文件内容中包含的apache是不同的term。
创建索引
如下图,每个文档创建索引都会走一遍左边的流程,如果两个文档分析的时候有相同的term的时候,会在索引库只保存一份,但是在索引后面会跟上文档对象的编号,这样就能减少索引库的压力,当查询的时候,会直接找到索引后面的编号找文档对象然后反馈回去.而不是整个查一遍.
注意：创建索引是对语汇单元索引，通过词语找文档，这种索引的结构叫倒排索引结构。
传统方法是根据文件找到该文件的内容，在文件内容中匹配搜索关键字，这种方法是顺序扫描方法，数据量大、搜索慢。
倒排索引结构是根据内容（词语）找文档，倒排索引结构也叫反向索引结构，包括索引和文档两部分，索引即词汇表，它的规模较小，而文档集合较大。
下载Lucene Jdk要求：1.7以上
解压后打开,找到这么几个包,io的和junit的自己去maven官网下吧
下面这个是Field的实现类,为什么会分这么多呢?因为根据实际情况,比如文件大小,这个域你分析的话就没必要,因为分出来什么也不是,没人根据这个东西来查找,再比如商品编号,这个东西不能进行分析,但是得保存成索引,这又是一种情况,所以得根据不同情况自定义与对象.
下面开始一个小demo,自己先准备好一些文件,这个是创建索引的demo
/**
*
*/
package com.buba.lucene;import java.io.File;
import org.apache.commons.io.FileUtils;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.document.TextField;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.LongField;
import org.apache.lucene.document.StoredField;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.junit.Test;public class FirstLucene {
@Test
public void testIndex() throws Exception{
// //创建一个索引库位置随便写
Directory directory = FSDirectory.open(new File("F:\\temp\\index"));
//Directory directory2 = new RAMDirectory(); 这是内存索引库存到内存中,但是一关机就没了,不建议使用
//这个是官方推荐的标准分词器,对英文分的准对中文不行,
Analyzer analyzer = new StandardAnalyzer();
//指定一个分析器，对文档内容进行分析。第一个参数是版本号,如果导了多个lucene的话使用最新的
IndexWriterConfig config = new IndexWriterConfig(Version.LATEST,analyzer );
//创建一个流往索引库存数据时用,
IndexWriter indexWriter = new IndexWriter(directory, config);
//
// 第三步：创建field对象，将field添加到document对象中。 域对象放到文档对象
File f = new File("F:\\searchsource\\searchsource");//我这个路径是文本位置
File[] listFiles = f.listFiles();
for(File file : listFiles) {
// 创建document对象。
Document document = new Document();
//这里面获取的具体信息可以写别的自己加就可以
//文件名称
String file_name = file.getName();
Field fileNameField = new TextField("fileName",file_name,Store.YES);//第一个参数是域名字,第二个域值,第三个是否保存
//文件大小
long fiel_size = FileUtils.sizeOf(file);
Field fileSizeField = new LongField("fileSize", fiel_size, Store.YES);
//文件路径
String file_path = file.getPath();
Field filePathField = new StoredField("filePath",file_path);
//文件内容
String file_content = FileUtils.readFileToString(file);
Field fileContentField = new TextField("fileContent", file_content, Store.YES);
document.add(fileNameField);
document.add(fileSizeField);
document.add(filePathField);
document.add(fileContentField);
// 使用indexwriter对象将document对象写入索引库，此过程进行索引创建。并将索引和document对象写入索引库。
indexWriter.addDocument(document);
}// 关闭IndexWriter对象。
indexWriter.close();
}
}
运行完后去索引库可以看到生成的索引文件 ,是打不开的需要借助工具才能看到里面的东西
下载地址https://download.csdn.net/download/kxj19980524/10867071
解压后点击bat文件,就可了
选中索引库目录
英文单词也不是太难的应该能理解,可以按着我框的点一下看看
搜索索引过程：
根据查询语法在倒排索引词典表中分别找出对应搜索词的索引，从而找到索引所链接的文档链表。
比如搜索语法为“fileName:lucene”表示搜索出fileName域中包含Lucene的文档。
搜索过程就是在索引上查找域为fileName，并且关键字为Lucene的term，并根据term找到文档id列表。
渲染结果
以一个友好的界面将查询结果展示给用户，用户根据搜索结果找自己想要的信息，为了帮助用户很快找到自己的结果，提供了很多展示的效果，比如搜索结果中将关键字高亮显示，百度提供的快照等。
搜索类的实现类,也是根据不同情况写不同实现类
@Test
public void testSearch()throws Exception{
// 第一步：创建一个Directory对象，也就是索引库存放的位置。
Directory directory = FSDirectory.open(new File("F:\\temp\\index"));
// 第二步：创建一个indexReader对象，需要指定Directory对象。
IndexReader indexReader = DirectoryReader.open(directory);
// 第三步：创建一个indexsearcher对象，需要指定IndexReader对象 这是搜索对象
IndexSearcher indexsearcher = new IndexSearcher(indexReader);
// 第四步：创建一个TermQuery对象，指定查询的域和查询的关键词。
Query query = new TermQuery(new Term("fileName","apache"));//这个是精准查询,域名和域值
// 第五步：执行查询。
TopDocs topDocs = indexsearcher.search(query, 2); //2是查询个数
// 第六步：返回查询结果。遍历查询结果并输出。
ScoreDoc[] scoreDocs = topDocs.scoreDocs;
for(ScoreDoc s:scoreDocs) {
int doc = s.doc; //这个返回的是term后面跟的id值
Document doc2 = indexsearcher.doc(doc); //转成dom对象后获取出来当初存的域值
//文件名称
String fileName = doc2.get("fileName");
System.out.println(fileName);
//文件大小
String fileContent = doc2.get("fileContent");
System.out.println(fileContent);
//文件大小
String fileSize = doc2.get("fileSize");
System.out.println(fileSize);
//文件路径
String filePath = doc2.get("filePath");
System.out.println(filePath);
System.out.println("------------------");
}
// 第七步：关闭IndexReader对象
indexReader.close();
}
接下来说说这个标准分词器,因为毕竟是外国人开发的,肯定是按照英文分的,如果分中文的话就一个字一个字分了所以很不好.
//查看标准分析器的分词效果
@Test
public void testTokenStream() throws Exception {
//创建一个标准分析器对象
Analyzer analyzer = new StandardAnalyzer();
//获得tokenStream对象
//第一个参数：域名，可以随便给一个
//第二个参数：要分析的文本内容
//TokenStream tokenStream = analyzer.tokenStream("test", "The Spring Framework provides a comprehensive programming and configuration model.");
TokenStream tokenStream = analyzer.tokenStream("test", "全文检索概念\r\n" +
"全文检索是将整本书java、整篇文章中的任意内容信息");
//添加一个引用，可以获得每个关键词
CharTermAttribute charTermAttribute = tokenStream.addAttribute(CharTermAttribute.class);
//添加一个偏移量的引用，记录了关键词的开始位置以及结束位置
OffsetAttribute offsetAttribute = tokenStream.addAttribute(OffsetAttribute.class);
//将指针调整到列表的头部
tokenStream.reset();
//遍历关键词列表，通过incrementToken方法判断列表是否结束
while(tokenStream.incrementToken()) {
//关键词的起始位置
System.out.println("start->" + offsetAttribute.startOffset());
//取关键词
System.out.println(charTermAttribute);
//结束位置
System.out.println("end->" + offsetAttribute.endOffset());
}
tokenStream.close();
}
换成支持中日韩的试试,然而效果也不好
Analyzer analyzer = new CJKAnalyzer();
有一个提供给apache的,效果还是但是扩展性差,不能与时俱进,不能添加
最后使用一个IKAnalyzer分词器下载地址https://code.google.com/p/ik-analyzer/貌似现在谷歌上不去了,反正我是访问不了,所以我自己上传了一个https://download.csdn.net/download/kxj19980524/10867301
导入包后替换就行,把下面这句替换旧行
Analyzer analyzer = new IKAnalyzer();
它最强大的功能就是可以扩展,引入jar包和配置文件后,把这注释打开,然后创建两个文件,一个里面写扩展的词汇一个里面写,禁止的词汇
要记住一点,建立索引和查询索引必须使用同一个分词器不然查出来的结果不在预料之内
删除全部索引
public IndexWriter getIndexWriter() throws Exception{
//创建一个索引库位置随便写
Directory directory = FSDirectory.open(new File("F:\\temp\\index"));
//Directory directory2 = new RAMDirectory(); 这是内存索引库存到内存中,但是一关机就没了,不建议使用
//这个是官方推荐的标准分词器,对英文分的准对中文不行,
Analyzer analyzer = new StandardAnalyzer();
//指定一个分析器，对文档内容进行分析。第一个参数是版本号,如果导了多个lucene的话使用最新的
IndexWriterConfig config = new IndexWriterConfig(Version.LATEST,analyzer );
//创建一个流往索引库存数据时用,
return new IndexWriter(directory, config);
}
//删除全部索引
@Test
public void deleteAllIndex() throws Exception {
IndexWriter indexWriter = getIndexWriter();
indexWriter.deleteAll();
indexWriter.close();
}
根据条件删除,剩下的我就不截图了,自己试试看下结果吧,记得再把索引添加上
//根据条件删除
@Test
public void testDelete() throws Exception {
IndexWriter indexWriter = getIndexWriter();
Query query = new TermQuery(new Term("fileName","apache"));
indexWriter.deleteDocuments(query);
indexWriter.close();
}
修改索引,修改就是,删一个添加一个 ,它这个删除修改不会把id也删掉,只会把文档内容清空,可以在工具里看看.
//修改
@Test
public void testUpdate() throws Exception {
IndexWriter indexWriter = getIndexWriter();
Document doc = new Document();
doc.add(new TextField("fileN","测试文件名",Store.YES));
doc.add(new TextField("fileC","测试文件内容",Store.YES));
indexWriter.updateDocument(new Term("fileName","apache"), doc,new IKAnalyzer());
indexWriter.close();
}
查询所有
//IndexReader IndexSearcher
public IndexSearcher getIndexSearcher() throws Exception{
// 第一步：创建一个Directory对象，也就是索引库存放的位置。
Directory directory = FSDirectory.open(new File("D:\\temp\\index"));// 磁盘
// 第二步：创建一个indexReader对象，需要指定Directory对象。
IndexReader indexReader = DirectoryReader.open(directory);
// 第三步：创建一个indexsearcher对象，需要指定IndexReader对象
return new IndexSearcher(indexReader);
}
//执行查询的结果
public void printResult(IndexSearcher indexSearcher,Query query)throws Exception{
// 第五步：执行查询。
TopDocs topDocs = indexSearcher.search(query, 10); //根据自己索引库有多少对象然后定义这个数字
// 第六步：返回查询结果。遍历查询结果并输出。
ScoreDoc[] scoreDocs = topDocs.scoreDocs;
for (ScoreDoc scoreDoc : scoreDocs) {
int doc = scoreDoc.doc;
Document document = indexSearcher.doc(doc);
// 文件名称
String fileName = document.get("fileName");
System.out.println(fileName);
// 文件内容
String fileContent = document.get("fileContent");
System.out.println(fileContent);
// 文件大小
String fileSize = document.get("fileSize");
System.out.println(fileSize);
// 文件路径
String filePath = document.get("filePath");
System.out.println(filePath);
System.out.println("------------");
}
}
//查询所有
@Test
public void testMatchAllDocsQuery() throws Exception {
IndexSearcher indexSearcher = getIndexSearcher();
Query query = new MatchAllDocsQuery();
System.out.println(query);
printResult(indexSearcher, query);
//关闭资源
indexSearcher.getIndexReader().close();
}
根据数值范围查询,运用到按照价格筛选
//根据数值范围查询
@Test
public void testNumericRangeQuery() throws Exception {
IndexSearcher indexSearcher = getIndexSearcher();
Query query = NumericRangeQuery.newLongRange("fileSize", 47L, 200L, false, true);//这两个boolean的意思是包含47,200么?
System.out.println(query);
printResult(indexSearcher, query);
//关闭资源
indexSearcher.getIndexReader().close();
}
组合查询,多条件进行筛选
//可以组合查询条件
@Test
public void testBooleanQuery() throws Exception {
IndexSearcher indexSearcher = getIndexSearcher();
BooleanQuery booleanQuery = new BooleanQuery();
Query query1 = new TermQuery(new Term("fileName","apache"));
Query query2 = new TermQuery(new Term("fileName","lucene"));
// select * from user where id =1 or name = 'safdsa'
booleanQuery.add(query1, Occur.MUST); //这的参数看下面,意思就是必须或者,不必须的意思
booleanQuery.add(query2, Occur.SHOULD);
System.out.println(booleanQuery);
printResult(indexSearcher, booleanQuery);
//关闭资源
indexSearcher.getIndexReader().close();
}
使用queryparser查询,上面的所有查询都是通过使用query的子类查询的,这个查询是通过写表达式查询.
//条件解释的对象查询
@Test
public void testQueryParser() throws Exception {
IndexSearcher indexSearcher = getIndexSearcher();
//参数1： 默认查询的域
//参数2：采用的分析器
QueryParser queryParser = new QueryParser("fileName",new IKAnalyzer());
// *:* 域：值
Query query = queryParser.parse("fileName:lucene is apache OR fileContent:lucene is apache");//这填写的表达式在上面的query对象中都有,不妨把上面子类查询的query对象打印一下看看是什么东西,但是这个表达式不支持查询数值范围,只支持字符串,solr中支持数值,下一篇中会讲到.上面的每一种查询都可以使用表达式的形式进行查询.
printResult(indexSearcher, query);
//关闭资源
indexSearcher.getIndexReader().close();
}
查询语法
1、基础的查询语法，关键词查询：
域名+“：”+搜索的关键字
例如：content:java
- 范围查询
域名+“:”+[最小值 TO 最大值]
例如：size:[1 TO 1000]
范围查询在lucene中支持数值类型，不支持字符串类型。在solr中支持字符串类型。
- 组合条件查询
1）+条件1 +条件2：两个条件之间是并且的关系and
例如：+filename:apache +content:apache
- +条件1 条件2：必须满足第一个条件，应该满足第二个条件
例如：+filename:apache content:apache
- 条件1 条件2：两个条件满足其一即可。
例如：filename:apache content:apache
4）-条件1 条件2：必须不满足条件1，要满足条件2
例如：-filename:apache content:apache
条件解析的对象查询 多个默念域,就是多个条件而已,使用上面的单个的只要改改语法也能实现多条件的效果
//条件解析的对象查询 多个默念域
@Test
public void testMultiFieldQueryParser() throws Exception {
IndexSearcher indexSearcher = getIndexSearcher();
String[] fields = {"fileName","fileContent"};
//参数1： 默认查询的域
//参数2：采用的分析器
MultiFieldQueryParser queryParser = new MultiFieldQueryParser(fields,new IKAnalyzer());
// *:* 域：值
Query query = queryParser.parse("lucene is apache");
printResult(indexSearcher, query);
//关闭资源
indexSearcher.getIndexReader().close();
}