Lucene

最新推荐文章于 2022-07-03 15:26:15 发布
最新推荐文章于 2022-07-03 15:26:15 发布
阅读量149 收藏
点赞数
分类专栏： lucene
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yb464855952/article/details/85804790
版权

Lucene

Lucene是apache旗下的顶级项目,是一个全文检索工具包
Lucene就是一个可以创建全文检索引擎系统的一堆jar包.可以使用它来构建全文检索引擎系统,但是它不能独立运行

非结构化数据查询方法

     顺序扫描法(Serial Scanning)
     所谓顺序扫描，比如要找内容包含某一个字符串的文件，就是一个文档一个文档的看，对于每一个文档，从头看到尾，如果此文档包含此字符串，则此文档为我们要找的文件，接着看下一个文件，直到扫描完所有的文件。如利用windows的搜索也可以搜索文件内容，只是相当的慢。

     全文检索(Full-text Search)
      将非结构化数据中的一部分信息提取出来，重新组织，使其变得有一定结构，然后对此有一定结构的数据进行搜索，从而达到搜索相对较快的目的。这部分从非结构化数据中提取出的然后重新组织的信息，我们称之索引。
     例如：字典。字典的拼音表和部首检字表就相当于字典的索引，对每一个字的解释是非结构化的，如果字典没有音节表和部首检字表，在茫茫辞海中找一个字只能顺序扫描。然而字的某些信息可以提取出来进行结构化处理，比如读音，就比较结构化，分声母和韵母，分别只有几种可以一一列举，于是将读音拿出来按一定的顺序排列，每一项读音都指向此字的详细解释的页数。我们搜索时按结构化的拼音搜到读音，然后按其指向的页数，便可找到我们的非结构化数据——也即对字的解释。
这种先建立索引，再对索引进行搜索的过程就叫全文检索(Full-text Search)。

Lucene实现全文检索的流程

绿色表示索引过程，对要搜索的原始内容进行索引构建一个索引库，索引过程包括：确定原始内容即要搜索的内容->采集文档->创建文档->分析文档->索引文档

红色表示搜索过程，从索引库中搜索内容，搜索过程包括：用户通过搜索界面->创建查询->执行搜索，从索引库搜索->渲染搜索结果

创建索引
对文档索引的过程，将用户要搜索的文档内容进行索引，索引存储在索引库（index）中。
这里我们要搜索的文档是磁盘上的文本文件，根据案例描述：凡是文件名或文件内容包括关键字的文件都要找出来，这里要对文件名和文件内容创建索引。

获得原始文档
原始文档是指要索引和搜索的内容。原始内容包括互联网上的网页、数据库中的数据、磁盘上的文件等。

创建文档对象
获取原始内容的目的是为了索引，在索引前需要将原始内容创建成文档（Document），文档中包括一个一个的域（Field），域中存储内容。我们可以将磁盘上的一个文件当成一个document，Document中包括一些Field（file_name文件名称、file_path文件路径、file_size文件大小、file_content文件内容）,每个Document可以有多个Field，不同的Document可以有不同的Field，同一个Document可以有相同的Field（域名和域值都相同）

分析文档
将原始内容创建为包含域（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。
每个文档都有一个唯一的编号，就是文档id。

​​​​​​​创建索引
对所有文档分析得出的语汇单元进行索引，索引的目的是为了搜索，最终要实现只搜索被索引的语汇单元从而找到Document（文档）。
注意：创建索引是对语汇单元索引，通过词语找文档，这种索引的结构叫倒排索引结构。
传统方法是根据文件找到该文件的内容，在文件内容中匹配搜索关键字，这种方法是顺序扫描方法，数据量大、搜索慢。
倒排索引结构是根据内容（词语）找文档，如下图：

倒排索引结构也叫反向索引结构，包括索引和文档两部分，索引即词汇表，它的规模较小，而文档集合较大。

 

创建索引库实现步骤：使用indexwriter对象创建索引,使用Luke工具查看索引文件
第二步：创建一个indexwriter对象。
   指定索引库的存放位置Directory对象  
   指定一个分析器，对文档内容进行分析。
第二步：创建document对象。
第三步：创建field对象，将field添加到document对象中。
第四步：使用indexwriter对象将document对象写入索引库，此过程进行索引创建。并将索引和document对象写入索引库。
第五步：关闭IndexWriter对象。​​​​​​​
Field域的属性

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

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

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

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

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

 

查询索引实现步骤
第一步：创建一个Directory对象，也就是索引库存放的位置。
第二步：创建一个indexReader对象，需要指定Directory对象。
第三步：创建一个indexsearcher对象，需要指定IndexReader对象
第四步：创建一个TermQuery对象，指定查询的域和查询的关键词。
第五步：执行查询。
第六步：返回查询结果。遍历查询结果并输出。
第七步：关闭IndexReader对象

IndexSearcher搜索方法

​​​​​​​TopDocs

​​​​​​​分析器（Analyzer）的执行过程
如下图是语汇单元的生成过程：

从一个Reader字符流开始，创建一个基于Reader的Tokenizer分词器，经过三个TokenFilter生成语汇单元Token。
要看分析器的分析效果，只需要看Tokenstream中的内容就可以了。每个分析器都有一个方法tokenStream，返回一个tokenStream对象。

引库的查询（重点）
	对要搜索的信息创建Query查询对象，Lucene会根据Query查询对象生成最终的查询语法，类似关系数据库Sql语法一样Lucene也有自己的查询语法，比如：“name:lucene”表示查询Field的name为“lucene”的文档信息。
	可通过两种方法创建查询对象：
	1）使用Lucene提供Query子类
	Query是一个抽象类，lucene提供了很多查询对象，比如TermQuery项精确查询，NumericRangeQuery数字范围查询等。
	如下代码：
	Query query = new TermQuery(new Term("name", "lucene"));

	2）使用QueryParse解析查询表达式
	QueryParse会将用户输入的查询表达式解析成Query对象实例。
	如下代码：
	QueryParser queryParser = new QueryParser("name", new IKAnalyzer());
		Query query = queryParser.parse("name:lucene");

 

package cn.itheima.lucene;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

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.TextField;
import org.apache.lucene.document.Field.Store;
import org.apache.lucene.document.LongField;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.Term;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.apache.lucene.util.Version;
import org.junit.Test;
import org.wltea.analyzer.lucene.IKAnalyzer;

public class IndexManagerTest {
	@Test
	public void testIndexCreate() throws Exception{
		//创建文档列表,保存多个Docuemnt
		List<Document> docList = new ArrayList<Document>();
		
		//指定文件所在目录
		File dir = new File("XXX"); 
		//循环文件夹取出文件
		for(File file : dir.listFiles()){
			//文件名称
			String fileName = file.getName();
			//文件内容
			String fileContext = FileUtils.readFileToString(file);
			//文件大小
			Long fileSize = FileUtils.sizeOf(file);
			
			//文档对象,文件系统中的一个文件就是一个Docuemnt对象
			Document doc = new Document();
			
			//第一个参数:域名
			//第二个参数:域值
			//第三个参数:是否存储,是为yes,不存储为no
			/*TextField nameFiled = new TextField("fileName", fileName, Store.YES);
			TextField contextFiled = new TextField("fileContext", fileContext, Store.YES);
			TextField sizeFiled = new TextField("fileSize", fileSize.toString(), Store.YES);*/
			
			//是否分词:要,因为它要索引,并且它不是一个整体,分词有意义
			//是否索引:要,因为要通过它来进行搜索
			//是否存储:要,因为要直接在页面上显示
			TextField nameFiled = new TextField("fileName", fileName, Store.YES);
			
			//是否分词: 要,因为要根据内容进行搜索,并且它分词有意义
			//是否索引: 要,因为要根据它进行搜索
			//是否存储: 可以要也可以不要,不存储搜索完内容就提取不出来
			TextField contextFiled = new TextField("fileContext", fileContext, Store.NO);
			
			//是否分词: 要, 因为数字要对比,搜索文档的时候可以搜大小, lunene内部对数字进行了分词算法
			//是否索引: 要, 因为要根据大小进行搜索
			//是否存储: 要, 因为要显示文档大小
			LongField sizeFiled = new LongField("fileSize", fileSize, Store.YES);
			
			//将所有的域都存入文档中
			doc.add(nameFiled);
			doc.add(contextFiled);
			doc.add(sizeFiled);
			
			//将文档存入文档集合中
			docList.add(doc);
		}
		
		//创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
		Analyzer analyzer = new IKAnalyzer();
		//指定索引和文档存储的目录
		Directory directory = FSDirectory.open(new File("XXX"));
		//创建写对象的初始化对象
		IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
		//创建索引和文档写对象
		IndexWriter indexWriter = new IndexWriter(directory, config);
		
		//将文档加入到索引和文档的写对象中
		for(Document doc : docList){
			indexWriter.addDocument(doc);
		}
		//提交
		indexWriter.commit();
		//关闭流
		indexWriter.close();
	}
	
	@Test
	public void testIndexDel() throws Exception{
		//创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
		Analyzer analyzer = new IKAnalyzer();
		//指定索引和文档存储的目录
		Directory directory = FSDirectory.open(new File("E:\\dic"));
		//创建写对象的初始化对象
		IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
		//创建索引和文档写对象
		IndexWriter indexWriter = new IndexWriter(directory, config);
		
		//删除所有
		//indexWriter.deleteAll();
		
		//根据名称进行删除
		//Term词元,就是一个词, 第一个参数:域名, 第二个参数:要删除含有此关键词的数据
		indexWriter.deleteDocuments(new Term("fileName", "apache"));
		
		//提交
		indexWriter.commit();
		//关闭
		indexWriter.close();
	}
	
	/**
	 * 更新就是按照传入的Term进行搜索,如果找到结果那么删除,将更新的内容重新生成一个Document对象
	 * 如果没有搜索到结果,那么将更新的内容直接添加一个新的Document对象
	 * @throws Exception
	 */
	@Test
	public void testIndexUpdate() throws Exception{
		//创建分词器,StandardAnalyzer标准分词器,标准分词器对英文分词效果很好,对中文是单字分词
		Analyzer analyzer = new IKAnalyzer();
		//指定索引和文档存储的目录
		Directory directory = FSDirectory.open(new File("E:\\dic"));
		//创建写对象的初始化对象
		IndexWriterConfig config = new IndexWriterConfig(Version.LUCENE_4_10_3, analyzer);
		//创建索引和文档写对象
		IndexWriter indexWriter = new IndexWriter(directory, config);
		
		
		//根据文件名称进行更新
		Term term = new Term("fileName", "web");
		//更新的对象
		Document doc = new Document();
		doc.add(new TextField("fileName", "xxxxxx", Store.YES));
		doc.add(new TextField("fileContext", "think in java xxxxxxx", Store.NO));
		doc.add(new LongField("fileSize", 100L, Store.YES));
		
		//更新
		indexWriter.updateDocument(term, doc);
		
		//提交
		indexWriter.commit();
		//关闭
		indexWriter.close();
	}
}

package cn.itheima.lucene;

import java.io.File;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.BooleanClause.Occur;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.MatchAllDocsQuery;
import org.apache.lucene.search.NumericRangeQuery;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TermQuery;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.FSDirectory;
import org.junit.Test;
import org.wltea.analyzer.lucene.IKAnalyzer;

public class IndexSearchTest {

	@Test
	public void testIndexSearch() throws Exception{
		
		//创建分词器(创建索引和所有时所用的分词器必须一致)
		Analyzer analyzer = new IKAnalyzer();
		//创建查询对象,第一个参数:默认搜索域, 第二个参数:分词器
		//默认搜索域作用:如果搜索语法中指定域名从指定域中搜索,如果搜索时只写了查询关键字,则从默认搜索域中进行搜索
		QueryParser queryParser = new QueryParser("fileContext", analyzer);
		//查询语法=域名:搜索的关键字
		Query query = queryParser.parse("fileName:web");
		
		//指定索引和文档的目录
		Directory dir = FSDirectory.open(new File("E:\\dic"));
		//索引和文档的读取对象
		IndexReader indexReader = IndexReader.open(dir);
		//创建索引的搜索对象
		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
		//搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
		TopDocs topdocs = indexSearcher.search(query, 5);
		//一共搜索到多少条记录
		System.out.println("=====count=====" + topdocs.totalHits);
		//从搜索结果对象中获取结果集
		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
		
		for(ScoreDoc scoreDoc : scoreDocs){
			//获取docID
			int docID = scoreDoc.doc;
			//通过文档ID从硬盘中读取出对应的文档
			Document document = indexReader.document(docID);
			//get域名可以取出值 打印
			System.out.println("fileName:" + document.get("fileName"));
			System.out.println("fileSize:" + document.get("fileSize"));
			System.out.println("============================================================");
		}
		
	}
	
	@Test
	public void testIndexTermQuery() throws Exception{
		//创建分词器(创建索引和所有时所用的分词器必须一致)
		Analyzer analyzer = new IKAnalyzer();
		
		//创建词元:就是词,   
		Term term = new Term("fileName", "apache");
		//使用TermQuery查询,根据term对象进行查询
		TermQuery termQuery = new TermQuery(term);
		
		
		//指定索引和文档的目录
		Directory dir = FSDirectory.open(new File("E:\\dic"));
		//索引和文档的读取对象
		IndexReader indexReader = IndexReader.open(dir);
		//创建索引的搜索对象
		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
		//搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
		TopDocs topdocs = indexSearcher.search(termQuery, 5);
		//一共搜索到多少条记录
		System.out.println("=====count=====" + topdocs.totalHits);
		//从搜索结果对象中获取结果集
		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
		
		for(ScoreDoc scoreDoc : scoreDocs){
			//获取docID
			int docID = scoreDoc.doc;
			//通过文档ID从硬盘中读取出对应的文档
			Document document = indexReader.document(docID);
			//get域名可以取出值 打印
			System.out.println("fileName:" + document.get("fileName"));
			System.out.println("fileSize:" + document.get("fileSize"));
			System.out.println("============================================================");
		}
	}
	
	@Test
	public void testNumericRangeQuery() throws Exception{
		//创建分词器(创建索引和所有时所用的分词器必须一致)
		Analyzer analyzer = new IKAnalyzer();
		
		//根据数字范围查询
		//查询文件大小,大于100 小于1000的文章
		//第一个参数:域名      第二个参数:最小值,  第三个参数:最大值, 第四个参数:是否包含最小值,   第五个参数:是否包含最大值
		Query query = NumericRangeQuery.newLongRange("fileSize", 100L, 1000L, true, true);		
		
		//指定索引和文档的目录
		Directory dir = FSDirectory.open(new File("E:\\dic"));
		//索引和文档的读取对象
		IndexReader indexReader = IndexReader.open(dir);
		//创建索引的搜索对象
		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
		//搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
		TopDocs topdocs = indexSearcher.search(query, 5);
		//一共搜索到多少条记录
		System.out.println("=====count=====" + topdocs.totalHits);
		//从搜索结果对象中获取结果集
		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
		
		for(ScoreDoc scoreDoc : scoreDocs){
			//获取docID
			int docID = scoreDoc.doc;
			//通过文档ID从硬盘中读取出对应的文档
			Document document = indexReader.document(docID);
			//get域名可以取出值 打印
			System.out.println("fileName:" + document.get("fileName"));
			System.out.println("fileSize:" + document.get("fileSize"));
			System.out.println("============================================================");
		}
	}
	
	@Test
	public void testBooleanQuery() throws Exception{
		//创建分词器(创建索引和所有时所用的分词器必须一致)
		Analyzer analyzer = new IKAnalyzer();
		
		//布尔查询,就是可以根据多个条件组合进行查询
		//文件名称包含apache的,并且文件大小大于等于100 小于等于1000字节的文章
		BooleanQuery query = new BooleanQuery();
		
		//根据数字范围查询
		//查询文件大小,大于100 小于1000的文章
		//第一个参数:域名      第二个参数:最小值,  第三个参数:最大值, 第四个参数:是否包含最小值,   第五个参数:是否包含最大值
		Query numericQuery = NumericRangeQuery.newLongRange("fileSize", 100L, 1000L, true, true);
		
		//创建词元:就是词,   
		Term term = new Term("fileName", "apache");
		//使用TermQuery查询,根据term对象进行查询
		TermQuery termQuery = new TermQuery(term);
		
		//Occur是逻辑条件
		//must相当于and关键字,是并且的意思
		//should,相当于or关键字或者的意思
		//must_not相当于not关键字, 非的意思
		//注意:单独使用must_not  或者 独自使用must_not没有任何意义
		query.add(termQuery, Occur.MUST);
		query.add(numericQuery, Occur.MUST);
		
		//指定索引和文档的目录
		Directory dir = FSDirectory.open(new File("E:\\dic"));
		//索引和文档的读取对象
		IndexReader indexReader = IndexReader.open(dir);
		//创建索引的搜索对象
		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
		//搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
		TopDocs topdocs = indexSearcher.search(query, 5);
		//一共搜索到多少条记录
		System.out.println("=====count=====" + topdocs.totalHits);
		//从搜索结果对象中获取结果集
		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
		
		for(ScoreDoc scoreDoc : scoreDocs){
			//获取docID
			int docID = scoreDoc.doc;
			//通过文档ID从硬盘中读取出对应的文档
			Document document = indexReader.document(docID);
			//get域名可以取出值 打印
			System.out.println("fileName:" + document.get("fileName"));
			System.out.println("fileSize:" + document.get("fileSize"));
			System.out.println("============================================================");
		}
	}
	
	@Test
	public void testMathAllQuery() throws Exception{
		//创建分词器(创建索引和所有时所用的分词器必须一致)
		Analyzer analyzer = new IKAnalyzer();
		
		//查询所有文档
		MatchAllDocsQuery query = new MatchAllDocsQuery();
		
		//指定索引和文档的目录
		Directory dir = FSDirectory.open(new File("E:\\dic"));
		//索引和文档的读取对象
		IndexReader indexReader = IndexReader.open(dir);
		//创建索引的搜索对象
		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
		//搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
		TopDocs topdocs = indexSearcher.search(query, 5);
		//一共搜索到多少条记录
		System.out.println("=====count=====" + topdocs.totalHits);
		//从搜索结果对象中获取结果集
		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
		
		for(ScoreDoc scoreDoc : scoreDocs){
			//获取docID
			int docID = scoreDoc.doc;
			//通过文档ID从硬盘中读取出对应的文档
			Document document = indexReader.document(docID);
			//get域名可以取出值 打印
			System.out.println("fileName:" + document.get("fileName"));
			System.out.println("fileSize:" + document.get("fileSize"));
			System.out.println("============================================================");
		}
	}
	
	@Test
	public void testMultiFieldQueryParser() throws Exception{
		//创建分词器(创建索引和所有时所用的分词器必须一致)
		Analyzer analyzer = new IKAnalyzer();
		
		String [] fields = {"fileName","fileContext"};
		//从文件名称和文件内容中查询,只有含有apache的就查出来
		MultiFieldQueryParser multiQuery = new MultiFieldQueryParser(fields, analyzer);
		//输入需要搜索的关键字
		Query query = multiQuery.parse("apache");
		
		//指定索引和文档的目录
		Directory dir = FSDirectory.open(new File("E:\\dic"));
		//索引和文档的读取对象
		IndexReader indexReader = IndexReader.open(dir);
		//创建索引的搜索对象
		IndexSearcher indexSearcher = new IndexSearcher(indexReader);
		//搜索:第一个参数为查询语句对象, 第二个参数:指定显示多少条
		TopDocs topdocs = indexSearcher.search(query, 5);
		//一共搜索到多少条记录
		System.out.println("=====count=====" + topdocs.totalHits);
		//从搜索结果对象中获取结果集
		ScoreDoc[] scoreDocs = topdocs.scoreDocs;
		
		for(ScoreDoc scoreDoc : scoreDocs){
			//获取docID
			int docID = scoreDoc.doc;
			//通过文档ID从硬盘中读取出对应的文档
			Document document = indexReader.document(docID);
			//get域名可以取出值 打印
			System.out.println("fileName:" + document.get("fileName"));
			System.out.println("fileSize:" + document.get("fileSize"));
			System.out.println("============================================================");
		}
	}
}

 

  

查询语法
1、基础的查询语法，关键词查询：
域名+“：”+搜索的关键字
例如：content:java
2、范围查询
域名+“:”+[最小值 TO 最大值]
例如：size:[1 TO 1000]
范围查询在lucene中不支持数值类型，支持字符串类型。在solr中支持数值类型。
3、组合条件查询
1）+条件1 +条件2：两个条件之间是并且的关系and
例如：+filename:apache +content:apache
2）+条件1 条件2：必须满足第一个条件，应该满足第二个条件
例如：+filename:apache content:apache
3）条件1 条件2：两个条件满足其一即可。
例如：filename:apache content:apache
4）-条件1 条件2：必须不满足条件1，要满足条件2
例如：-filename:apache content:apache
Occur.MUST 查询条件必须满足，相当于and	+（加号）
Occur.SHOULD 查询条件可选，相当于or
	空（不用符号）
Occur.MUST_NOT 查询条件不能满足，相当于not非	-（减号）

第二种写法：
条件1 AND 条件2
条件1 OR 条件2
条件1 NOT 条件2

 

索引:

域名:词  这样的形式,

它里面有指针执行这个词来源的文档

 

索引库: 放索引的文件夹(这个文件夹可以自己随意创建,在里面放索引就是索引库)

Term词元: 就是一个词, 是lucene中词的最小单位

文档:

Document对象,一个Document中可以有多个Field域对象,Field域对象中是key-value键值对的形式:有域名和域值,

一个document就是数据库表中的一条记录, 一个Filed域对象就是数据库表中的一行一列

这是一个通用的存储结构.

 

创建索引和所有时所用的分词器必须一致

 

域的详细介绍

是否分词:

分词的作用是为了索引

需要分词: 文件名称, 文件内容

不需要分词: 不需要索引的域不需要分词,还有就是分词后无意义的域不需要分词

  比如: id, 身份证号

 

是否索引:

索引的的目的是为了搜索.

需要搜索的域就一定要创建索引,只有创建了索引才能被搜索出来

不需要搜索的域可以不创建索引

需要索引: 文件名称, 文件内容, id, 身份证号等

不需要索引: 比如图片地址不需要创建索引, e:\\xxx.jpg

因为根据图片地址搜索无意义

 

是否存储:

存储的目的是为了显示.

是否存储看个人需要,存储就是将内容放入Document文档对象中保存出来,会额外占用磁盘空间, 如果搜索的时候需要马上显示出来可以放入document中也就是要存储,这样查询显示速度快, 如果不是马上立刻需要显示出来,则不需要存储,因为额外占用磁盘空间不划算.

 

域的各种类型

 

注意:lucene底层的算法,钱数是要分词的,因为要根据价钱进行对比

例如: 大于12.5元的小于100元的商品搜索出来

 

 

 

文档的更新

更新就是按照传入的Term进行搜索,如果找到结果那么删除,将更新的内容重新生成一个Document对象

如果没有搜索到结果,那么将更新的内容直接添加一个新的Document对象

 

文档的删除

可以根据某个域的内容进行删除

还可以一次删除所有

 

搜索

TermQuery:

根据词进行搜索(只能从文本中进行搜索)

QueryParser:

根据域名进行搜索,可以设置默认搜索域,推荐使用. (只能从文本中进行搜索)

NumericRangeQuery:

从数值范围进行搜索

BooleanQuery:

组合查询,可以设置组合条件,not and or.从多个域中进行查询

must相当于and关键字,是并且的意思

should,相当于or关键字或者的意思

must_not相当于not关键字, 非的意思

注意:单独使用must_not  或者 独自使用must_not没有任何意义

MatchAllDocsQuery:

查询出所有文档

MultiFieldQueryParser:

可以从多个域中进行查询,只有这些域中有关键词的存在就查询出来.

 

 

  1. 中文分析器----Lucene自带中文分词器
    StandardAnalyzer：单字分词：就是按照中文一个字一个字地进行分词。如：“我爱中国”，效果：“我”、“爱”、“中”、“国”。
    CJKAnalyzer  二分法分词：按两个字进行切分。如：“我是中国人”，效果：“我是”、“是中”、“中国”“国人”。
                          上边两个分词器无法满足需求。
    SmartChineseAnalyzer  对中文支持较好，但扩展性差，扩展词库，禁用词库和同义词库等不好处理
    第三方中文分析器
     paoding： 庖丁解牛最新版在 https://code.google.com/p/paoding/ 中最多支持Lucene 3.0，且最新提交的代码在 2008-06-                     03，在svn中最新也是2010年提交，已经过时，不予考虑。
          mmseg4j：最新版已从 https://code.google.com/p/mmseg4j/ 移至 https://github.com/chenlb/mmseg4j-solr，支持Lucene                       4.10，且在github中最新提交代码是2014年6月，从09年～14年一共有：18个版本，也就是一年几乎有3个大                      小版本，有较大的活跃度，用了mmseg算法。
      IK-analyzer： 最新版在https://code.google.com/p/ik-analyzer/上，支持Lucene 4.10从2006年12月推出1.0版开始，                                   IKAnalyzer已经推出了4个大版本。最初，它是以开源项目Luence为应用主体的，结合词典分词和文法分                             析算法的中文分词组件。从3.0版本开 始，IK发展为面向Java的公用分词组件，独立于Lucene项目，同时                             提供了对Lucene的默认优化实现。在2012版本中，IK实现了简单的分词 歧义排除算法，标志着IK分词器从                          单纯的词典分词向模拟语义分词衍化。 但是也就是2012年12月后没有在更新。
       ansj_seg：最新版本在 https://github.com/NLPchina/ansj_seg tags仅有1.1版本，从2012年到2014年更新了大小6次，但                        是作者本人在2014年10月10日说明：“可能我以后没有精力来维护ansj_seg了”，现在由”nlp_china”管理。                           2014年11月有更新。并未说明是否支持Lucene，是一个由CRF（条件随机场）算法所做的分词算法。
       imdict-chinese-analyzer：最新版在 https://code.google.com/p/imdict-chinese-analyzer/ ， 最新更新也在2009年5月，下                                              载源码，不支持Lucene 4.10 。是利用HMM（隐马尔科夫链）算法。
        cseg：最新版本在git.oschina.net/lionsoul/jcseg，支持Lucene 4.10，作者有较高的活跃度。利用mmseg算法。



    索引时使用Analyzer
    输入关键字进行搜索，当需要让该关键字与文档域内容所包含的词进行匹配时需要对文档域内容进行分析，需要经过Analyzer分析器处理生成语汇单元（Token）。分析器分析的对象是文档中的Field域。当Field的属性tokenized（是否分词）为true时会对Field值进行分析，如下图：

    搜索时使用Analyzer
          对搜索关键字进行分析和索引分析一样，使用Analyzer对搜索关键字进行分析、分词处理，使用分析后每个词语进行搜索。比如：搜索关键字：spring web ，经过分析器进行分词，得出：spring  web拿词去索引词典表查找 ，找到索引链接到Document，解析Document内容。对于匹配整体Field域的查询可以在搜索时不分析，比如根据订单号、身份证号查询等。 注意：搜索使用的分析器要和索引使用的分析器一致。



    索引库的维护
    向索引库中添加document对象。
    第一步：先创建一个indexwriter对象
    第二步：创建一个document对象
    第三步：把document对象写入索引库
    第四步：关闭indexwriter。

 

曲终人散开
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lucene.sql
05-15
用于测试库，用来使用和了解elasticsearch的功能。如果有其他测试与调试需要也可以使用，sql文件中会创建一个产品表并插入大量数据。
全文检索与Lucene学习
weixin_30952535的博客
09-12 230
全文检索与Lucene学习 本文是我最近针对Lucene3.3.0进行的总结，并提供了大量的实现Demo，常用的基本都有，下载地址：http://download.csdn.net/detail/a_2cai/3594154 全文检索与Lucene学习（一） 1 概述... 1 2 Lucene概述... 3 3 Lucene的索引和检索... 5 4 查询方式总结... 8 4....
Lucene同步SQL数据方案
情怀中的释然~
07-07 534
Lucene使用文档 1、可视化工具 Luke 2、同步方案 同步双写 异步双写(MQ) 异步双写(WORKER) BinLog方式 **参考链接：**http://www.pbdata.cn/?p=201 3、可能存在的问题 具体同步方案 见同步方案 原数据库中数据修改 或者 删除后 如何重新建立索引 (如何保证 数据库中的数据修改或删除后 Lucene中也要进行更新) 4、保证数据同步的方法 需要同步的表中增加update_time字段 每次修改操作后 更新update_time字段 第一
lucene 按照匹配度排序_SQL基础知识（2）—条件查询、排序查询
weixin_39626298的博客
12-04 345
文章导览：条件查询：条件表达式、逻辑表达式、范围查询、空值判断、模糊查询（like、匹配符）排序查询：语法、执行顺序、特点、不同使用方式示例一、条件查询（where子句）数据库表中包含大量的数据，在实际应用中，通常只会根据需要查询特定数据。在select语句中，数据根据where子句指定的筛选条件进行过滤。语法：select <查询列表> from <表名> where &...
Lucene结合Sql建立索引
04-17
Lucene（这里用到的是Lucene.net版本也成为DotLucene）是一个信息检索的函数库(Library),利用它你可以为你的应用加上索引和搜索的功能. Lucene的使用者不需要深入了解有关全文检索的知识,仅仅学会使用库中的一个类,你就为你的应用实现全文检索的功能. 不过千万别以为Lucene是一个象google那样的搜索引擎,Lucene甚至不是一个应用程序,它仅仅是一个工具,一个Library.你也可以把它理解为一个将索引,搜索功能封装的很好的一套简单易用的API.利用这套API你可以做很多有关搜索的事情,而且很方便. 本源码演示了Lucene结合Sql建立索引，把Sql中的数据通过建立索引用Lucene来检索 支持简单的中文分词，同时提供了Lucene.Net-2.0-004版本的源码给大家
jieba-lucene-analiysis:jieba的lucene中文分析器和令牌生成器
05-10
jieba-lucene-analysis是将jieba分词库与Apache Lucene搜索引擎库相结合的项目，旨在为Lucene提供更适应中文处理的分析器和令牌生成器。这个项目的主要目的是解决在Lucene中对中文文本进行索引和搜索时的效率和准确...
lucene-core-7.2.1-API文档-中文版.zip
07-12
赠送jar包：lucene-core-7.2.1.jar； 赠送原API文档：lucene-core-7.2.1-javadoc.jar； 赠送源代码：lucene-core-7.2.1-sources.jar； 赠送Maven依赖信息文件：lucene-core-7.2.1.pom； 包含翻译后的API文档：lucene...
lucene-core-7.7.0-API文档-中文版.zip
07-13
赠送jar包：lucene-core-7.7.0.jar； 赠送原API文档：lucene-core-7.7.0-javadoc.jar； 赠送源代码：lucene-core-7.7.0-sources.jar； 赠送Maven依赖信息文件：lucene-core-7.7.0.pom； 包含翻译后的API文档：lucene...
lucene-analyzers-smartcn-7.7.0-API文档-中文版.zip
07-13
赠送jar包：lucene-analyzers-smartcn-7.7.0.jar； 赠送原API文档：lucene-analyzers-smartcn-7.7.0-javadoc.jar； 赠送源代码：lucene-analyzers-smartcn-7.7.0-sources.jar； 赠送Maven依赖信息文件：lucene-...
lucene-inmemory-index:使用Lucene在内存中搜索索引
03-27
《使用Lucene构建内存搜索索引的深度解析》 在当今大数据时代，高效的数据检索技术变得至关重要。Apache Lucene作为一款强大的开源全文搜索引擎库，被广泛应用于各种信息检索场景。本文将深入探讨如何利用Lucene在...
Lucene与SQL对比学习
10-16
Lucene与SQL对比学习，适用于新手
Lucene数据存储实现：LSQL行存&列存
weixin_44253169的博客
03-14 679
Lucene作为最强大的开源的全文检索引擎，其倒排索引机制可以快速的根据term值找到docid，此外lucene也可以保存明细数据，通过docid将明细数据返回，并且有两种方式-行存、列存。 一次查询的流程 上图是lucene一次查询的流程，首先是从倒排索引中获取docid，之后再从行存或者列存中找到数据。只有建立索引的字段才会生成term和term对应的docid列表。当然，如果字段需...
SQL数据库与Lucene数据库性能测试报告
mituan1234567的专栏
04-24 3184
http://www.cnitblog.com/cockerel/archive/2007/07/30/30911.html SQL数据库与Lucene数据库性能测试报告 一、       测试目的 本测试试图对用相同数据制作的SQL数据库与Lucene数据库对语义相同的查询语句的性能作一个简单的比较与分析，以找出各自的优缺点，并讨论其各自的适用场合。   二、       测试环境
lucene学习笔记
何小杰的博客
10-09 6472
1 Lucene 全文检索技术 2 lucene介绍 2.1 什么是lucene Lucene是Apache的一个全文检索引擎工具包，通过lucene可以让程序员快速开发一个全文检索功能。 引擎：核心组件 工具包：jar包、类库 2.2 全文检索的应用场景 2.2.1 搜索引擎 2.2.2 站内搜索（关注） 2.2.3 文件系统的搜索 2.2.4 总结 Lucene和搜索引擎不是一回事 Lu...
一款支持SQL+Lucene语法的实时数据匹配引擎够不够酷？
colorknight的专栏
07-03 997
任何技术其实酷不酷不是最重要的，最重要的是实用。早在几年前，笔者实现了兼容Lucene语法的实时匹配引擎Tripod后，就曾考虑过是否会有这样一种场景，同时需要使用SQL+Lucene两种语法的能力来描述匹配条件，对数据进行实时匹配？因为事情较多，一时没有想到，就此搁下。 一晃差不多三年过去了，最近在一个项目中碰到了我的老本行--“安全日志分析”的需求。如今的日志分析已经有了专门的检测规则共享格式— sigma, 与我们早期无法打破安全知识与工程实现间的鸿沟相比，已经截然不同。工程实现者不用再
lucene的分组查询（类似sql的group by）的解决方法
waltertan1988的博客
04-26 382
通过lucene搜索去除相同结果。 在网上找了很久到没有答案，到apache看了文档，http://lucene.apache.org/java/2_4_1/queryparsersyntax.html 搜索语法之中是没有类似group by的。只好换个思路，想到了过滤器。 结果发现了org.apache.lucene.search.DuplicateFilter这 个类。对此类的解释如下：
Lucene查询语法和使用
Zhang Phil
06-14 4319
Lucene查询语法和使用（一）（1）直接输入单词查询，比如输入Windows：也可以根据一个关键词（key） 配上该关键词的值，精确查找，如选择关键词为ip，查找一个已知的ip地址： 也可以这样查询，假设已经某条日志数据中key为bytes的值为7000: "key":value，精确匹配。（2） 可以一次同时搜索多个单词，用 and 连接，比如 Windows and Chorme and GET，相当于编程中的&&逻辑判断：and 和 or都是Lucene的逻辑判断，可以组合起来使用。（3）通配符。
luncene（汤阳光）
抬头30°的微笑的专栏
08-15 1526
1. Eclipse 中实用快捷键  alt+ 内容提示 == 如：syso 按此快捷键之后生成 System.out.println(); Ctrl+Alt+↓ 复制当前行到下一行(复制增加) Ctrl+Alt+↑ 复制当前行到上一行(复制增加) -- 经常会使用到的 ctrl+shift+o 批量导入需要的类、接口之类的，比较常用 ctrl+1 错误帮助，一般用此快捷键创建某个方法
lucene使用与优化
阿福的专栏
12-13 1962
1 lucene简介1.1 什么是luceneLucene是一个全文搜索框架，而不是应用产品。因此它并不像www.baidu.com 或者google Desktop那么拿来就能用，它只是提供了一种工具让你能实现这些产品。1.2 lucene能做什么要回答这个问题，先要了解lucene的本质。实际上lucene的功能很单一，说到底，就是你给它若干个字符串，然后它为你提供一个全文搜索服务，告
Lucene深入解析
"Lucene in Action 是一本由Erik Hatcher和Otis Gospodnetic合著的关于Apache Lucene的权威指南。这本书由Manning出版社出版，详细介绍了Lucene这一强大的全文搜索引擎库的使用和实现。" 《Lucene in Action》这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值