lucene学习教程

1Lucene的介绍

　　①Lucene是什么：

是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎　　

　　②Lucene有什么用

Lucene是一个高性能、可伸缩的信息搜索(IR)库。它可以为你的应用程序添加索引和搜索能力,和对搜索词进行分析过滤

　　③Lucene怎么用

//        Lucene使用步骤
//        1创建索引
//        1.1创建索引目录
Directory directory=FSDirectory.open(new File("indexDir"));
//        1.2创建indexWriter
IndexWriterConfig conf=new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35));
IndexWriter indexWriter=new IndexWriter(directory, conf);
//        1.3创建document
Document document=new Document();
//        1.4为document指定不同的域（Field）
document.add(new Field("fileName","java.txt",Store.YES,Index.ANALYZED));
document.add(new NumericField("creatDate",Store.YES,true).setLongValue(new Date().getTime()));
document.add(new NumericField("size",Store.YES,true).setDoubleValue(10101.22));
document.add(new Field("content",FileUtils.readFileToString(new File("java.txt")),Store.NO,Index.ANALYZED));
//        1.5使用indexWriter.add(doc)方法，添加索引
indexWriter.addDocument(document);
//        1.6关闭indexWriter
indexWriter.close();
//        2搜索索引
//        2.1指定索引存放位置
Directory indexDirectory=FSDirectory.open(new File("indexDir"));
//        2.2创建indexReader
IndexReader indexReader=IndexReader.open(indexDirectory);
//        2.3创建indexSearcher
IndexSearcher indexSearcher=new IndexSearcher(indexReader);
//        2.4创建query
Query query=new TermQuery(new Term("fileName","java"));
//        2.5根据indexSearcher.seacher(query,maxDoc);获取topDocs
TopDocs topDocs = indexSearcher.search(query, 100);
//        2.6根据topDocs获取ScoreDocs[]
ScoreDoc[] scoreDocs=topDocs.scoreDocs;
//        2.7遍历ScoreDocs[]获取docId
for (ScoreDoc scoreDoc : scoreDocs) {
int docId=scoreDoc.doc;
//            2.8根据docId调用indexSearcher.doc(docId)方法获取一个document
Document doc = indexSearcher.doc(docId);
//            2.9对document进行解析，获取需要的值
System.out.println("fileName-->"+document.get("fileName")+"createDate--->"+new Date(Long.parseLong(doc.get("createDate"))));
}
//        3.0关闭indexSearcher和indexReader
indexSearcher.close();
indexReader.close();

2Lucene的组成

　　①索引

　　　　I索引建立的主要流程

//        1指定索引的存放目录
Directory directory=FSDirectory.open(new File("paht"));//硬盘
//        //OR
Directory directory2=new RAMDirectory();//内存
//        2创建indexWriter
IndexWriterConfig conf=new IndexWriterConfig(Version.LUCENE_35, new StandardAnalyzer(Version.LUCENE_35));
IndexWriter indexWriter=new IndexWriter(directory, conf);
//        3创建文档（document）（对于数据库而言，一个条记录就是一个文档，对于文件而言，一个文件就是一个文档）
//        1.3创建document
Document document=new Document();
//        4为文档指定域（Field）（对于数据库而言，域相当于字段，对于文件而言域相当于属性）
document.add(new Field("fileName","java.txt",Store.YES,Index.ANALYZED));
document.add(new NumericField("creatDate",Store.YES,true).setLongValue(new Date().getTime()));
document.add(new NumericField("size",Store.YES,true).setDoubleValue(10101.22));
document.add(new Field("content",FileUtils.readFileToString(new File("java.txt")),Store.NO,Index.ANALYZED));
//        5添加索引
indexWriter.addDocument(document);

　　II、重要类的介绍

　directory

是用来指定索引的存放位置，可以是内存也可以是硬盘，FSDirectory.open(new File("paht")),会根据本地文件系统，自动选择一种最合适的方式存储索引

　　indexWriter　

是用来对索引的进行增删改的重要操作类

Document

document对象对于数据库而言，一个条记录就是一个document，对于文件而言，一个文件就是一个document

　Field

Field对象对于数据库而言，Field相当于字段(例如 name、age、、、、)，对于文件而言Field相当于属性（例如文件名（name）..）
子类NumericField是用来存储数据类型的的字段的值，例如int 、long、double、,还有日期可以转换为long型后存储

　II索引的增删改
　　①增加索引

indexWriter.addDocument(document);

　②删除索引

//删除索引
indexWriter.deleteDocuments(new Term("fileName","java"));//删除文件名等于Java的document--删除后只是放在一个临时文档里，不被检索，并没有真正删除
indexWriter.forceMergeDeletes();//强制把删除的document删除掉

　　③更新索引

//更新索引--索引的更新原理：1根据query删除掉对应document，然后再把新的document放进去
indexWriter.updateDocument(new Term("fileName","java"), document);

　III索引的权重

//①对于默认情况下，索引的排序是按照评分来排序的，评分公式是Score=Score*Boot  ,
//分数*权重，只要保证Boot的足够大，那么对应搜索的document就会排在第一位
//设置权重的办法是：
document.setBoost(1000F);

　　②分词
　　　I分词运行流程分析

①searchWord首先会被Tokenizer分成一个一个的语汇单元，
②然后会经过一系列的TokenFilter（分词过滤器），过滤掉没意义的分词，例如“的，啊 ”这些感叹词
③经过一系列TokenFilter后，返回一个TokenStream，就是一个分词字符流，流里存有分词个各种信息

　　　如下图：
　　　


　　　II分词的类介绍
　　　　1Analyzer:分词器，是一个抽象类　　

//其主要包含两个接口，用于生成TokenStream：
TokenStream tokenStream(String fieldName, Reader reader);
TokenStream reusableTokenStream(String fieldName, Reader reader) ;
//为了提高性能，在同一个线程中无需再生成新的TokenStream对象，旧的可以被重用，reusableTokenStream是获取当前线程TokenSteam。　　　

　　　　2Tokenizer　

Tokenizer继承与TokenStream，是用来对searchWord的reader流进行分词，把searchWord分成一个一个的语汇单元

　　　　3TokenFilter　

TokenFilter,过滤分词后的语汇单元，
主要方法incrementToken(),可以依次遍历语汇单元的信息

　　　　4TokenStream

分词字符流，流里存有分词个各种信息
例如：CharTermAttribute、OffsetAttribute、PositionIncrementAttribute、TypeAttribute、、等等

　　 III扩展分词器

　　　　基本原理：就是使用自定义分词器的扩展原生analyzer的构造方法，然后用analyzer对应的Tokenizer分词，然后再使用自定义的TokenFilter过滤业务逻辑数据，　　　

　　　　1自定义一个类继承analyzer

public class MyAnalyzer extends Analyzer {}

　　　　2实现tokenStream方法

public class MyAnalyzer extends Analyzer {
@Override
public TokenStream tokenStream(String arg0, Reader reader) {
return null;
}
}

　　　　3自定义TokenFilter

package com.lucence.analyzer;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

import org.apache.lucene.analysis.TokenFilter;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
/**
* 自定义分词过滤器
* 1自定义类继承TokenFilter
* 2实现指定的方法-incrementToken
* 3在incrementToken里会遍历所有被分词的词汇单元，
* 4实现自己的业务逻辑
*
*/
public class MyAnalyzerFilter extends TokenFilter {
private CharTermAttribute cta;
private PositionIncrementAttribute pia;
private State state;
private Stack<String> sameWordStack;
protected MyAnalyzerFilter(TokenStream input) {
super(input);
this.cta=input.addAttribute(CharTermAttribute.class);
this.pia=input.addAttribute(PositionIncrementAttribute.class);
sameWordStack=new Stack<String>();
}

@Override
public boolean incrementToken() throws IOException {
if(sameWordStack.size()>0){
String pop = sameWordStack.pop();
//恢复状态
restoreState(state);
cta.setEmpty();
cta.append(pop);
pia.setPositionIncrement(0);
//System.out.print("["+cta+"]"+pia.getPositionIncrement());

System.out.println(state.hashCode());
return true;
}
if (!input.incrementToken()) {
return false;
}
if(getSameWorder(cta.toString())){
//捕获当前状态
state=captureState();
}
return true;
}
/**
* 同义词处理--数据
*/
private Boolean getSameWorder(String key){
//1申明一个map存放同义词---模拟数据库
Map<String, String[]> map=new HashMap<String, String[]>();
map.put("我",new String[]{"咱","吾","俺"});
map.put("中国",new String[]{"大陆","天朝"});
String[] strings = map.get(key);
if(strings!=null&&strings.length>0){
for (int i = 0; i < strings.length; i++) {
sameWordStack.push(strings[i]);
}
return true;
}else{
return false;
}
}
}

　　4使用自定义的TokenFilter返回处理后的TokenStream

public class MyAnalyzer extends Analyzer {
@Override
public TokenStream tokenStream(String arg0, Reader reader) {
return new MyAnalyzerFilter(new IKTokenizer(reader,false));
}
}

　　③搜索

　　　I搜索的运行流程

//        1.1指定索引存放位置
Directory indexDirectory=FSDirectory.open(new File("indexDir"));
//        1.2创建indexReader---indexReader.openIfChanged(oldReader)，监听索引是否有改变,若索引有改变则重新获取indexReader
IndexReader indexReader=IndexReader.open(indexDirectory);
//        1.3创建indexSearcher
IndexSearcher indexSearcher=new IndexSearcher(indexReader);
//        1.4创建query
Query query=new TermQuery(new Term("fileName","java"));
//        1.5根据indexSearcher.seacher(query,maxDoc);获取topDocs
TopDocs topDocs = indexSearcher.search(query, 100);
//        1.6根据topDocs获取ScoreDocs[]
ScoreDoc[] scoreDocs=topDocs.scoreDocs;
//        1.7遍历ScoreDocs[]获取docId
for (ScoreDoc scoreDoc : scoreDocs) {
int docId=scoreDoc.doc;
//            1.8根据docId调用indexSearcher.doc(docId)方法获取一个document
Document doc = indexSearcher.doc(docId);
//            1.9对document进行解析，获取需要的值
System.out.println("fileName-->"+doc.get("fileName")+"createDate--->"+new Date(Long.parseLong(doc.get("createDate"))));
}
//        2.0关闭indexSearcher和indexReader
indexSearcher.close();
indexReader.close();

　　 IIquery类的介绍

①termQuery:精确查询 new term(field,value)
②termRangeQuery:字符串范围查询new TermRangeQuery(field, lowerTerm, upperTerm, includeLower, includeUpper)
③NumericRange:数字范围查询，NumericRangeQuery.newTRange(field, min, max, minInclusive, maxInclusive)--T代表泛型
④QueryParser:
⑤prefixQuery:前缀查询--new PrefixQuery(new term(field,prefix))
⑥wildCartQuery:通配符查询--new wildCartQuery(new term(field,value))---value已经包含通配符，例如"*bb*",查找包含bb的数据
⑦BooleanQuery:条件查询，可以连接多个多个条件
例如：

BooleanQuery booleanQuery=new BooleanQuery();
booleanQuery.add(query1,occur)
booleanQuery.add(query2,occur)
booleanQuery.add(query3,occur)

occur的值说明
must:一定，必须有，相当于数据库的and
should:可能有，，相当于数据库的or
MUST_NOT:一定没有，不存在，相当于数据库的不等于

⑧FuzzyQuery：模糊查询，

new FuzzyQuery(term, minimumSimilarity),可以 设置minimumSimilarity来设置匹配程度，越高匹配程度越高，
new FuzzyQuery(new term("name","bbcs"), minimumSimilarity)---含有bbc或者bbXs会被匹配出来

⑨phraseQuery:语义查询，对于中文，使用作用不大，

PhraseQuery phraseQuery=new PhraseQuery();
// 1设置跳跃的范围
phraseQuery.setSlop(2);
//2设置开始的单词
phraseQuery.add(new Term("content","i"));
// 3设置结束的单词
phraseQuery.add(new Term("content","you"));
//例如包含i love you的内容将会出来

　　 III扩展queryParse类

package com.lucence.query;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.util.Version;

/**
* 扩展queryParse类
* queryParse的查询的原理：先对查询的字符串进行分析，然后再使用对应的query去查询，
* 例如有通配符字符，就添加wildCartQuery去查询 ，如果*这些的，就添加FuzzyQuery去查询
* 也就说，如果我们想扩展queryParse的查询，那么可以自定义一个类，然后继承queryParse的，然后重构对应的getxxxquery()方法，并且在里面实现业务逻辑，则就可以实现扩展queryParse的功能
*/
//1第一步自定义类继承Lucene的queryParse
public class myQueryParse extends QueryParser {

//2选择一个重写一个构造方法
public myQueryParse(Version matchVersion, String f, Analyzer a) {
super(matchVersion, f, a);
}
//3重写对应的getXXQuery方法--并且在方法里实现业务逻辑
/**
* field--搜索域
* termStr---搜索值
*/
@Override
protected org.apache.lucene.search.Query getWildcardQuery(String field,
String termStr) throws ParseException {
if(termStr.indexOf("?")!=-1){
throw new ParseException("不能使用通配符查询");
}
return super.getWildcardQuery(field, termStr);
}
/**
* field--搜索域
* termStr---搜索值
*/
@Override
protected org.apache.lucene.search.Query getFuzzyQuery(String field,
String termStr, float minSimilarity) throws ParseException {
return super.getFuzzyQuery(field, termStr, minSimilarity);
}
}

　　 IV排序与分页

　　排序：

//①排序：默认是根据score排序，score默认是=score（关联性）*boot(权重)
SortField sortField1=new SortField("fileName",SortField.STRING,true);//content--"字段名称", ,SortField.STRING-"字段在存放时的类型",true--是否反转
SortField sortField2=new SortField("size",SortField.INT,false);//content--"字段名称", ,SortField.BYTE-"字段在存放时的类型",true--是否反转
Sort sort=new Sort(sortField1,sortField2);
TopDocs topDocs = searcher.search(query,10,sort);

　　分页：　　　

//1searchAfter(scoreDocAfter, query, pagezie)方法是每次返回scoreDocAfter后面的document，
int docId=(pagezie-1)*pageNumber-1;//每次查询是记录开始行
ScoreDoc scoreDocAfter=new ScoreDoc(docId,0f);
TopDocs topDocs = searcher.searchAfter(scoreDocAfter, query, pagezie);

　　 V搜索过滤器

　　

package com.lucence.searchFilter;

import java.io.IOException;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.AbstractAllTermDocs;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.Term;
import org.apache.lucene.index.TermDocs;
import org.apache.lucene.search.DocIdSet;
import org.apache.lucene.search.Filter;
import org.apache.lucene.util.OpenBitSet;
/**
* 自定义搜索过滤器
* 1新建一个类继承Lucene的Filter
* 2实现getDocIdSet方法
* 3根据indexReader获取到返回的document
* 4根据自己的业务逻辑处理后返回DocIdSet
* @author Jeremy
*
*/
public class MySearchFilter extends Filter {

@SuppressWarnings("unused")
@Override
public DocIdSet getDocIdSet(IndexReader indexReader)
throws IOException {
// TODO Auto-generated method stub
int maxDoc = indexReader.maxDoc();//获取返回document的数目
OpenBitSet docIdSet=new OpenBitSet(maxDoc);//默认是64位大小，但是如果超出没报异常，所以一般在indexReader里获取返回document的大小
//docIdSet是一个相当于一个列表--如下面
//status    document
// 0         docId
// 1         docId
//若status是0 ，则document将不会被显示出来，
//也就说，我们在filter把不需要的document可以过滤掉
//1填满列表---默认是空
docIdSet.set(0, maxDoc);
//2获取返回的document
//2.1直接使用indexReader来获取符合过滤条件的document
//TermDocs---存储了两个变量，一个是返回的docId数组，一个每个document出现"javass.txt"的频率次数
TermDocs termDocs =indexReader.termDocs(new Term("content","jeremy"));
while (termDocs.next()) {
System.out.println(termDocs.doc());
Document document = indexReader.document(termDocs.doc());
System.out.println("fileName"+document.get("fileName")+"---出现频率："+termDocs.freq()+"---被过滤掉了");
docIdSet.clear(termDocs.doc());//clear()方法相当于把status设置为0
}
return docIdSet;
}

}

　　 VI自定义评分

　　实现步骤：

　　* 自定义评分
　　* 默认的评分机制是 score=score*Root = 分数*索引的权重
　　* 自定义评分的实现流程
　　* 1新建一个类及承诺CustomScoreQuery
　　* 2覆盖CustomScoreQuery(Query subQuery, ValueSourceQuery valSrcQuery)的构造方法--ValueSourceQuery：评分域查询对象
　　* 3覆盖 getCustomScoreProvider(IndexReader reader)方法
　　* 4新建一个类继承CustomScoreProvider
　　* 5覆盖CustomScoreProvider的customScore(int doc, float subQueryScore, float valSrcScore)方法，
　　* --------doc:docId,subQueryScore:原有评分，valSrcScore：我们自定义传入的评分
　　* 6在customScore(int doc, float subQueryScore, float valSrcScore)方法里返回经过业务逻辑处理的的自定义评分
　　* 7在getCustomScoreProvider返回自定的义的MyCustomScoreProvider对象
　　* 8在查询中使用MyCustomerScroeQuery

　　代码示例：

package com.lucence.scoreQuery;

import java.io.IOException;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.search.Query;
import org.apache.lucene.search.function.CustomScoreProvider;
import org.apache.lucene.search.function.CustomScoreQuery;
import org.apache.lucene.search.function.ValueSourceQuery;
/**
* 自定义评分
* 默认的评分机制是  score=score*Root =  分数*索引的权重
* 自定义评分的实现流程
* 1新建一个类及承诺CustomScoreQuery
* 2覆盖CustomScoreQuery(Query subQuery, ValueSourceQuery valSrcQuery)的构造方法--ValueSourceQuery：评分域查询对象
* 3覆盖 getCustomScoreProvider(IndexReader reader)方法
* 4新建一个类继承CustomScoreProvider
* 5覆盖CustomScoreProvider的customScore(int doc, float subQueryScore, float valSrcScore)方法，
* --------doc:docId,subQueryScore:原有评分，valSrcScore：我们自定义传入的评分
* 6在customScore(int doc, float subQueryScore, float valSrcScore)方法里返回经过业务逻辑处理的的自定义评分
* 7在getCustomScoreProvider返回自定的义的MyCustomScoreProvider对象
* 8在查询中使用MyCustomerScroeQuery
* @author Jeremy
*
*/
// 1新建一个类及承诺CustomScoreQuery
public class MyCustomerScroeQuery extends CustomScoreQuery {
//2覆盖CustomScoreQuery(Query subQuery, ValueSourceQuery valSrcQuery)的构造方法--ValueSourceQuery：评分域查询对象
public MyCustomerScroeQuery(Query subQuery, ValueSourceQuery valSrcQuery) {
super(subQuery, valSrcQuery);
}
public MyCustomerScroeQuery(Query subQuery) {
super(subQuery);
}
@Override
//3覆盖 getCustomScoreProvider(IndexReader reader)方法
protected CustomScoreProvider getCustomScoreProvider(IndexReader reader)throws IOException {
//7在getCustomScoreProvider返回自定的义的MyCustomScoreProvider对象
return new MyCustomScoreProvider(reader);
}

}

package com.lucence.scoreQuery;

import java.io.IOException;

import org.apache.lucene.document.Document;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.search.function.CustomScoreProvider;
// 4新建一个类继承CustomScoreProvide
public class MyCustomScoreProvider extends CustomScoreProvider{

public MyCustomScoreProvider(IndexReader reader) {
super(reader);
}
@Override
/**
*  5覆盖CustomScoreProvider的customScore(int doc, float subQueryScore, float valSrcScore)方法，
*  --------doc:docId,subQueryScore:原有评分，valSrcScore：我们自定义传入的评分
*/
//subQueryScore * valSrcScore;---默认的评分是原有的评分乘以评分域的的值
public float customScore(int doc, float subQueryScore, float valSrcScore)
throws IOException {
//6在customScore方法里返回业务逻辑处理后的自定义评分
System.out.println(subQueryScore+"------"+valSrcScore);
Document document = reader.document(doc);
if(document.get("fileName").endsWith(".txt")){//文件类型为。txt的优先排序
return subQueryScore*valSrcScore*100;
}
return super.customScore(doc, subQueryScore, valSrcScore);
}
}

　　使用代码示例：

public void test01(){
//3.1指定搜索目录
try {
Directory directory=FSDirectory.open(new File("C:/lucence/index"));
//3.2创建索引读取器(IndexReader)
IndexReader indexReader=IndexReader.open(directory);
//3.3根据IndexReader创建索引搜索器(indexSeacher)
IndexSearcher searcher=new IndexSearcher(indexReader);
//3.4创建查询器query----使用QueryParser的parser()方法创建--创建query
Query query=null;
QueryParser parser=new QueryParser(Version.LUCENE_35,"content",new StandardAnalyzer(Version.LUCENE_35));
query=parser.parse("spring");
//            //3.4.2c创建评分域---可以使用评分域去评分，也可以不使用----评分域的得类型必须是数据类型---
//            FieldScoreQuery fieldScoreQuery=new FieldScoreQuery("fileName",Type.BYTE);
//            //3.4.3使用MyCustomerScroeQuery来构建query
//            MyCustomerScroeQuery myCustomerScroeQuery = new MyCustomerScroeQuery(query, fieldScoreQuery);
MyCustomerScroeQuery myCustomerScroeQuery=new MyCustomerScroeQuery(query);
//3.5使用自定义的myCustomerScroeQuery进行查询过，IndexSeacher执行查询，并获取返回TopDocs---文档集合
TopDocs topDocs = searcher.search(myCustomerScroeQuery,100);
//3.6根据TopDocs(文档集合)获取scoreDocs---分数文档
ScoreDoc[] scoreDocs=topDocs.scoreDocs;
for (ScoreDoc scoreDoc : scoreDocs) {
//3.7根据ScoreDocs的doc Id在indexSeacher(索引搜索器)中获取文档对象，
Document doc = searcher.doc(scoreDoc.doc);
//3.8解析文档对象，获取对应的值
System.out.println(doc.get("fileName")+"["+doc.get("dir")+"]"+doc.getBoost());
}

//3.9关闭索引读取器
indexReader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}