java lucene 模糊查询_Lucene全文搜索分组，精确查找，模糊查找

最新推荐文章于 2021-03-02 04:56:04 发布

带带带麻烦

最新推荐文章于 2021-03-02 04:56:04 发布

阅读量483

点赞数

文章标签： java lucene 模糊查询

本文链接：https://blog.csdn.net/weixin_36299790/article/details/114540583

版权

http://zm603380946.iteye.com/blog/1827318

完全个人理解，如有更好的方法，欢迎一起讨论

LuceneUtils.java

package com.zbiti.lucene;

import java.io.File;

import java.io.IOException;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import net.sf.json.JSONArray;

import net.sf.json.JSONObject;

import org.apache.lucene.analysis.standard.StandardAnalyzer;

import org.apache.lucene.document.Document;

import org.apache.lucene.document.Field;

import org.apache.lucene.index.CorruptIndexException;

import org.apache.lucene.index.IndexWriter;

import org.apache.lucene.index.IndexWriterConfig;

import org.apache.lucene.index.Term;

import org.apache.lucene.index.IndexWriter.MaxFieldLength;

import org.apache.lucene.queryParser.MultiFieldQueryParser;

import org.apache.lucene.queryParser.ParseException;

import org.apache.lucene.queryParser.QueryParser;

import org.apache.lucene.search.CachingWrapperFilter;

import org.apache.lucene.search.Filter;

import org.apache.lucene.search.IndexSearcher;

import org.apache.lucene.search.Query;

import org.apache.lucene.search.QueryWrapperFilter;

import org.apache.lucene.search.TopDocs;

import org.apache.lucene.store.Directory;

import org.apache.lucene.store.FSDirectory;

import org.apache.lucene.store.LockObtainFailedException;

import org.apache.lucene.util.Version;

import org.wltea.analyzer.lucene.IKAnalyzer;

import com.zbiti.util.sys.JsonUtils;

/**

* Lucene 辅助类

* @author 张明

public class LuceneUtils {

//读取数据放入的地址

private static String IndexPath = "C:\\update\\index";

static Directory dir = null;

//初始化静态代码块

static{

try {

dir = FSDirectory.open(new File(IndexPath));

} catch (IOException e) {

e.printStackTrace();

}

/**

* 创建本地文件

* @param list 传递过来的数据是一个list

* @throws Exception

public static boolean createData(List list){

try {

Directory dir =FSDirectory.open(new File(IndexPath));

IndexWriterConfig writerConfig=new IndexWriterConfig(Version.LUCENE_36, new IKAnalyzer());

//设置每次创建都重新创建

writerConfig.setOpenMode(IndexWriterConfig.OpenMode.CREATE);

IndexWriter writer = new IndexWriter(dir, writerConfig) ;

//循环处理将数据放入Lucene中

for(int i=0; i< list.size(); i++){

Information information = list.get(i);

Document doc = new Document();

//设置字段

setField(information, doc);

writer.addDocument(doc);

}

//提交

writer.optimize();

writer.commit();

writer.close();

return true;

} catch (CorruptIndexException e) {

e.printStackTrace();

return false;

} catch (LockObtainFailedException e) {

e.printStackTrace();

return false;

} catch (IOException e) {

e.printStackTrace();

return false;

}

/**

* 创建一条数据

* @param information 一条数据,传送过来的数据必须是完整的数据

* @return

public static boolean createData(Information information){

try {

Directory dir =FSDirectory.open(new File(IndexPath));

IndexWriterConfig writerConfig=new IndexWriterConfig(Version.LUCENE_36, new IKAnalyzer());

IndexWriter writer = new IndexWriter(dir, writerConfig);

Document doc = new Document();

//设置字段

setField(information, doc);

writer.addDocument(doc);

writer.optimize();

writer.commit();

writer.close();

return true;

} catch (CorruptIndexException e) {

e.printStackTrace();

return false;

} catch (LockObtainFailedException e) {

e.printStackTrace();

return false;

} catch (IOException e) {

e.printStackTrace();

return false;

}

/**

* 更新一条信息

* @param information 根据bjStorageId的唯一性来更新数据

* 传送过来的数据必须是完整的数据，Lucene的更新不同于sql更新，更新是一天信息的完整更新

* @return

public static boolean updateData(Information information){

try {

Directory dir =FSDirectory.open(new File(IndexPath));

//第三个参数代表更新的时候不重新创建原本的数据

IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(Version.LUCENE_CURRENT), false, MaxFieldLength.UNLIMITED);

Document doc = new Document();

//设置字段

setField(information, doc);

Term term = new Term("bjStorageId",information.getBjStorageId().toString());

writer.updateDocument(term,doc);

writer.optimize();

writer.commit();

writer.close();

return true;

} catch (CorruptIndexException e) {

e.printStackTrace();

return false;

} catch (LockObtainFailedException e) {

e.printStackTrace();

return false;

} catch (IOException e) {

e.printStackTrace();

return false;

}

/**

* 删除一条数据

* @return 根据bjStorageId的唯一性来删除数据

public static boolean deleteData(String bjStorageId){

try {

Directory dir =FSDirectory.open(new File(IndexPath));

//第三个参数代表更新的时候不重新创建原本的数据

IndexWriter writer = new IndexWriter(dir, new StandardAnalyzer(Version.LUCENE_CURRENT), false, MaxFieldLength.UNLIMITED);

Term term = new Term("bjStorageId", bjStorageId);

writer.deleteDocuments(term);

writer.optimize();

writer.commit();

writer.close();

return true;

} catch (CorruptIndexException e) {

e.printStackTrace();

return false;

} catch (LockObtainFailedException e) {

e.printStackTrace();

return false;

} catch (IOException e) {

e.printStackTrace();

return false;

}

/**

* 查询数据

* @param searchStr 即将要查询的字符串

* @param fieldStr 需要查询的字段数组

* @param flag 是否统计标志

* @param groupStr 分组字段数组

* @param flagAcc 是否根据条件精确查询

* @param mapFilter查询条件

* @return

public static Map getDataList(String

searchStr, String[] fieldArray, boolean flag, String[] groupArray,

boolean flagAcc, Map mapFilter){

try {

IndexSearcher search = new IndexSearcher(dir);

System.out.println("lucene中的数据总数为：------->>>" + search.maxDoc());

QueryParser qp=new MultiFieldQueryParser(Version.LUCENE_36, fieldArray, new IKAnalyzer());

Query query=qp.parse(searchStr);

//一次查询多少个结果

//TopDocs tDocs=search.search(query,1000000);

TopDocs tDocs = null;

//是否二次查询,根据多条件精确查找

if(flagAcc){

LuceneFilter luceneFilter = new LuceneFilter();

Set keySet = mapFilter.keySet();

for (String key : keySet)

luceneFilter.addFilter(key, mapFilter.get(key).toString());

query=luceneFilter.getFilterQuery(query);//结果过滤

tDocs = search.search(query,1000000);

}else{

tDocs=search.search(query,1000000);

}

int numTotalHits = tDocs.totalHits;

System.out.println("lucene中的搜索出来的数据总数为：------->>>" + numTotalHits);

Map map = new HashMap();

map.put("information", tDocs);

map.put("search", search);

//是否同时查询分组统计数据

if(flag){

for(int j=0; j < groupArray.length; j++){

JSONArray jsonArr = new JSONArray();

JSONObject jsonObj = new JSONObject();

Map groupMap = getDataByGroupBy(search, query, groupArray[j]);

Set keySet = groupMap.keySet();

for (String key : keySet) {

jsonObj.put("id",key);

jsonObj.put("count", groupMap.get(key));

jsonArr.add(jsonObj);

}

map.put(groupArray[j],jsonArr);

}

//解析数据

//Document doc = null;

//for(int i=0; i

//int k = tDocs.scoreDocs[i].doc ; //文档内部编号

//doc = search.doc(k);

//System.out.println(doc.get("name") +"--" + doc.get("id") + "-----" + doc.get("type") + "---" + doc.get("testField"));

//}

//search.close();

return map;

} catch (CorruptIndexException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} catch (ParseException e) {

e.printStackTrace();

}

return null;

}

/**

* 根据field指定的字段来进行分组统计总数

* @param search

* @param query

* @param field

public static Map getDataByGroupBy(IndexSearcher search, Query query, String field){

try {

GroupCollector myCollector = new GroupCollector();

myCollector.setF(field);

search.search(query, myCollector);

GroupField gf = myCollector.getGroupField();

List values = gf.getValues();

//读取数据

Map map = new HashMap();

for (String value : values) {

map.put(value, gf.getCountMap().get(value));

}

return map;

} catch (IOException e) {

e.printStackTrace();

return null;

}

/**

* 设置字段信息

* @param information

* NOT_ANALYZED不支持模糊查找， ANALYZED支持模糊查找

public static void setField(Information information, Document doc){

doc.add(new Field("actualStorageId",

information.getActualStorageId()!=null?information.getActualStorageId().toString():"",