项目中需要实时的返回一下统计的东西，因此就要进行分组，在获取一些东西，代码拿不出来，因此分享一篇，还是很使用的。
facet搜索
/**
*
* 搜索功能优化-关键词搜索
* 搜索范围:商品名称、店铺名称
*
* @param keywords
* @param skip
* @param size
* @return
*/
@Override
public List<KeywordSearchByName> searchByName(String keywords, Integer skip, Integer size) { solrServer = SolrContext.getServer();
SolrQuery query = new SolrQuery();// 建立一个新的查询
query.setQuery(keywords);
query.setFacet(true);// 设置facet=on
query.addFacetField(new String[] {"v1_groupId"});// 设置需要facet的字段
query.setFacetLimit(20);// 限制facet返回的数量
query.setFacetMissing(false);// 不统计null的值
query.setFacetMinCount(1);// 设置返回的数据中每个分组的数据最小值，比如设置为1，则统计数量最小为1，不然不显示 QueryResponse response = null;
try {
response = solrServer.query(query);
System.out.println("查询时间：" + response.getQTime()); List<FacetField> facets = response.getFacetFields();// 返回的facet列表
for (FacetField facet : facets) {
// 获取分组字段FacetField
System.out.println(facet.getName());
System.out.println("----------------");
List<FacetField.Count> counts = facet.getValues();
for (FacetField.Count count : counts) { System.out.println(count.getName() + ":" + count.getCount());
}
System.out.println();
}
} catch (SolrServerException e) {
e.printStackTrace();
}
return null;
}
group搜索
/**
*
* 搜索功能优化-关键词搜索
* 搜索范围:商品介绍、店铺介绍、服务地址
*
* @param keywords
* @param skip
* @param size
* @return
*/
@Override
public List<KeywordSearchByOther> searchByOther(String keywords, Integer skip, Integer size) { solrServer = SolrContext.getServer();
SolrQuery query = new SolrQuery();// 建立一个新的查询
query.setQuery(keywords);
query.setParam(GroupParams.GROUP,true);//是否分组
query.setParam(GroupParams.GROUP_FIELD,"v1_teacherId");//分组的域
query.setParam(GroupParams.GROUP_LIMIT,"100");//每组显示的个数，默认为1
query.setStart(skip); //起始索引值
query.setRows(size);//显示几条数据
QueryResponse response = null;
try {
response = solrServer.query(query, SolrRequest.METHOD.POST);
Map<String, Integer> info = new HashMap<String, Integer>();
GroupResponse groupResponse = response.getGroupResponse();
if(groupResponse != null) {
List<GroupCommand> groupList = groupResponse.getValues();
for(GroupCommand groupCommand : groupList) {
List<Group> groups = groupCommand.getValues();
for(Group group : groups) {
info.put(group.getGroupValue(), (int)group.getResult().getNumFound());
System.out.println(group.getGroupValue()+(int)group.getResult().getNumFound());
}
}
}
}catch (SolrServerException e) {
e.printStackTrace();
}
return null;
}
solr的group搜索
按组查询的字段不能是int类型，必须是string类型，不然会包空指针异常，并且必须有q元素的查询，直接group.query不行
solr查询非法字符处理
非法字符串有这些
&& || ! ( ) { } [ ] ^ " ~ * ? : \ /
过滤的方法很简单，用 \ 进行转义
solr 官方的处理方法
https://svn.apache.org/repos/asf/lucene/dev/trunk/solr/solrj/src/java/org/apache/solr/client/solrj/util/ClientUtils.java
public static String escapeQueryChars(String s) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
// These characters are part of the query syntax and must be escaped
if (c == '\\' || c == '+' || c == '-' || c == '!' || c == '(' || c == ')' || c == ':'
|| c == '^' || c == '[' || c == ']' || c == '\"' || c == '{' || c == '}' || c == '~'
|| c == '*' || c == '?' || c == '|' || c == '&' || c == ';' || c == '/'
|| Character.isWhitespace(c)) {
sb.append('\\');
}
sb.append(c);
}
return sb.toString();
}solr的facet搜索
facet的字段string获取名称乱码，int类型不乱吗
solr搜索注意事项
v1_modle：类型为int，下面搜索能搜索出数据
<str name="q">普通 && v1_modle:1 && v1_fullpath:运动</str>
v1_modle：类型为string，下面搜索不能搜索出数据
<str name="q">普通 && v1_modle:1 && v1_fullpath:运动</str>
solr按分类搜索结果集分页解决方案：
// 服务
if (count.getName().equals("1")) {
// 按14个类目搜索返回条数
long[] array = categroySearch(1, keywords);
if (null != array && array.length > 0) {
long totalnum = 0;
for (int i = 0; i < array.length; i++) {
totalnum = totalnum + array[i];
if (array[i] > 0) {
if (skip == 0) {
// 判断size
if (totalnum >= size) {
// 获取下标i前的所有分类数据
// 按分类、关键词、group老师Id分组查询
System.out.print("skip = 0 ; break"+"===下标:"+i);
break;
} else {
continue;
}
}
if (skip > 0) {
// 判断skip、size
if ((totalnum - skip) > 0) {
if ((totalnum - skip) >= size) {
// 获取下标i前的所有分类数据
// 按分类、关键词、group老师Id分组查询
System.out.print("skip > 0 ; break"+"===下标:"+i);
break;
} else {
continue;
}
}
}
}
}
if(totalnum == 0 || totalnum < skip){
System.out.print("null");
}else {
System.out.print("all");
}
}
}
solr 高亮显示
要用response.getHighlighting()接受转换高亮结果
/**
* solrJ搜索 高亮显示
*
* @author pudongping
*
* @param server
* solr客户端
* @param queryString
* 查询串
* @param pageNum
* 分页 页码
* @param pageSize
* 每页显示大小
* @return
*/
public static Page<QzoneArticle> queryComHighlight(SolrServer server, String queryString, int pageNum,int pageSize){
SolrQuery query = new SolrQuery();
query.setQuery(queryString);
query.setHighlight(true);//开启高亮功能
query.addHighlightField("description");//高亮字段
query.addHighlightField("keywords");
query.setHighlightSimplePre("<font color='red'>");//渲染标签
query.setHighlightSimplePost("</font>");//渲染标签
query.setStart((pageNum-1)*pageSize);
query.setRows(pageSize);
QueryResponse response = null;
try {
response = server.query(query);
} catch (SolrServerException e) {
e.printStackTrace();
return null;
}
//查询结果集
SolrDocumentList lists = response.getResults(); //对象结果集
List<QzoneArticle> items = new ArrayList<QzoneArticle>(); //查询到的记录总数
long totalRow = Long.valueOf(response.getResults().getNumFound()).intValue(); String tmpId = ""; Map<String,Map<String,List<String>>> highlightMap=response.getHighlighting();
for (SolrDocument solrDocument : lists) {
QzoneArticle at = new QzoneArticle();
tmpId=solrDocument.getFieldValue("id").toString();
at.setId(tmpId);
at.setAuthor(solrDocument.getFieldValue("author").toString());
List<String> descList=highlightMap.get(tmpId).get("description");
List<String> keywsList=highlightMap.get(tmpId).get("keywords");
if(descList!=null && descList.size()>0){
at.setDescription(descList.get(0));
}else{
//获取并设置高亮的字段title
at.setDescription(solrDocument.getFieldValue("description").toString());
}
if(keywsList!=null && keywsList.size()>0){
at.setKeywords(keywsList.get(0));
}else{
at.setKeywords(solrDocument.getFieldValue("keywords").toString());
}
items.add(at);
} //填充page对象
return new Page<QzoneArticle>(pageNum, pageSize, totalRow, items); }
solr高亮，文本太多，想截取关键词前后多少字的一段文本
hl.fl
hl.fl
是说明你要关键字的摘要在那个field中取，我们一般是content字段。 hl.useFastVectorHighlighter
该参数很重要，如果你不看代码，是很难发现他的好处，默认是false，即文本段的划分是按每50个字符来划分，然后在这个50个字符中取关键字相关的摘要，摘要长度为100，参考后面的参数（hf.fragsize)，如果我们在参数中指定值为true，那么SOLR会根据关键词的在文本中的偏移量来计算摘要信息，前提是你的field要加上 termPositions="true" termOffsets="true"
这两项。
hl.snippetshl.snippets
参数是返回高亮摘要的段数，因为我们的文本一般都比较长，含有搜索关键字的地方有多处，如果hl.snippets
的值大于1的话，会返回多个摘要信息，即文本中含有关键字的几段话，默认值为1，返回含关键字最多的一段描述。solr会对多个段进行排序。
hl.fragsizehl.fragsize
参数是摘要信息的长度。默认值是100，这个长度是出现关键字的位置向前移6个字符，再往后100个字符，取这一段文本。
hl.boundaryScanner、hl.bs.maxScan、hl.bs.charsboundaryScanner
是边界扫描，就是怎么取我们高亮摘要信息的起始位置和结束位置，这个是我们摘要信息的关键，因为我们模式高亮摘要的开始和结束可能是某句话中截段的。上面这三个参数需要放在一起来说明，因为后两个是在我们没有给hl.boundaryScanner
设定值，即默认值时才会有效，对应的class为：SimpleBoundaryScanner，上面讲了hl.fragsize
参数，SimpleBoundaryScanner会根据hl.fragsize
参数决定的关键字的起始偏移量和结束偏移量，重新计算摘要的起始偏移量，首先说开始偏移量，源码如下：
public int findStartOffset(StringBuilder buffer, int start) {
// avoid illegal start offset
if( start > buffer.length() || start < 1 ) return start;
//maxScan是hl.bs.maxScan的值，它是说明从关键字出现的位置往前6个字符开始向前，在maxScan个字符内找是否出 现一个
//一个由参数hl.bs.chars指定的分界符。即从这里作为摘要的起始偏移。 如果往前maxScan个字符内没有发现指定的字符，
//则按起始便宜为start，即关键词往前的6个字符。
int offset, count = maxScan;
for( offset = start; offset > 0 && count > 0; count-- ){
// found?
if( boundaryChars.contains( buffer.charAt( offset - 1 ) ) ) return offset;
offset--;
}
// if we scanned up to the start of the text, return it, its a "boundary"
if (offset == 0) {
return 0;
}
// not found
return start;
}结束便宜量和计算起始偏移量是一样的，只不过是从关键词的位置往后100个字符的位置往后找分隔符，maxScan的默认值为10，hl.sc.chars
的默认值为.,!?hl.boundaryScanner
参数我们不指定值时，按上面的算法计算高亮摘要信息，但solr还提供了一种算法，即breakIterator，我们在请求参数中添加&hl.boundaryScanner=breakIterator时生效，这是solr通过java jdk的BreakIterator来计算分界符的。他相关的参数为，hl.bs.type，这个是主要的参数，决定BreakIterator怎么划分界定符，值有：CHARACTER, WORD, SENTENCE and LINE，SENTENCE 是按句子来划分，即你高亮摘要信息是一个完整的句子，而不会被截断。
solr高亮的配置参数说明
参数详细说明：hl.fl
: 用空格或逗号隔开的字段列表。要启用某个字段的highlight功能，就得保证该字段在schema中是stored。如果该参数未被给出，那么就会高亮默认字段 standard handler会用df参数，dismax字段用qf参数。你可以使用星号去方便的高亮所有字段。如果你使用了通配符，那么要考虑启用hl.requiredFieldMatch选项。hl.requireFieldMatch
:如果置为true，除非该字段的查询结果不为空才会被高亮。它的默认值是false，意味着它可能匹配某个字段却高亮一个不同的字段。如果hl.fl使用了通配符，那么就要启用该参数。尽管如此，如果你的查询是all字段（可能是使用copy-field 指令），那么还是把它设为false，这样搜索结果能表明哪个字段的查询文本未被找到hl.usePhraseHighlighter:如果一个查询中含有短语（引号框起来的）那么会保证一定要完全匹配短语的才会被高亮。hl.highlightMultiTerm如果使用通配符和模糊搜索，那么会确保与通配符匹配的term会高亮。默认为false，同时hl.usePhraseHighlighter要为true。hl.snippets
：这是highlighted片段的最大数。默认值为1，也几乎不会修改。如果某个特定的字段的该值被置为0（如f.allText.hl.snippets=0），这就表明该字段被禁用高亮了。你可能在hl.fl=*时会这么用。hl.fragsize:每个snippet返回的最大字符数。默认是100.如果为0，那么该字段不会被fragmented且整个字段的值会被返回。大字段时不会这么做。hl.mergeContiguous
:如果被置为true，当snippet重叠时会merge起来。
hl.maxAnalyzedChars
:会搜索高亮的最大字符，默认值为51200，如果你想禁用，设为-1hl.alternateField
:如果没有生成snippet（没有terms 匹配），那么使用另一个字段值作为返回。hl.maxAlternateFieldLength
:如果hl.alternateField启用，则有时需要制定alternateField的最大字符长度，默认0是即没有限制。所以合理的值是应该为hl.snippets * hl.fragsize这样返回结果的大小就能保持一致。hl.formatter
:一个提供可替换的formatting算法的扩展点。默认值是simple，这是目前仅有的选项。显然这不够用，你可以看看org.apache.solr.highlight.HtmlFormatter.java 和 solrconfig.xml中highlighting元素是如何配置的。注意在不论原文中被高亮了什么值的情况下，如预先已存在的em tags，也不会被转义，所以在有时会导致假的高亮。hl.fragmenter
:这个是solr制定fragment算法的扩展点。gap是默认值。regex是另一种选项，这种选项指明highlight的边界由一个正则表达式确定。这是一种非典型的高级选项。为了知道默认设置和fragmenters (and formatters)是如何配置的，可以看看solrconfig.xml中的highlight段。regex 的fragmenter有如下选项：hl.regex.pattern
:正则表达式的patternhl.regex.slop
:这是hl.fragsize能变化以适应正则表达式的因子。默认值是0.6，意思是如果hl.fragsize=100那么fragment的大小会从40-160.
solr搜索只关键词高亮，分类关键词不高亮实现
关键词在高亮的前面先setQuery（“keywords”），然后在高亮封装完的后面query.setFilterQueries("过滤的分类词")
public Map<String,List<PlayService>> searchPlayCategory(String keywords, Integer cursor, Integer skip, Integer size) {
Map<String,List<PlayService>> mapplays = new HashMap<String,List<PlayService>>();
List<String> strlist = getCategoryNameBycursorPlay(cursor);
if (null != strlist && strlist.size() > 0) {
for (int j = 0; j < strlist.size(); j++) {
List<PlayService> plays = new ArrayList<>();
StringBuffer sb = new StringBuffer(128);
sb.append("'\"" + keywords + "\"' && v1_modle:2 ");
SolrQuery query = new SolrQuery();// 建立一个新的查询
query.setQuery(sb.toString());
query.setHighlight(true).setHighlightSimplePre("<span style='color:#FA022C;'>")
.setHighlightSimplePost("</span>");
query.addHighlightField("v1_serviceTitle");//高亮字段
query.setParam("hl.fragsize","15");
query.setParam("hl.usePhraseHighlighter","true");
query.setFilterQueries(" v1_fullpath:" + strlist.get(j));
QueryResponse response = null;
try {
response = SolrContext.getServer().query(query, SolrRequest.METHOD.POST);
Map<String, Map<String, List<String>>> hightlight = response.getHighlighting();
plays = response.getBeans(PlayService.class);
for (int i = 0; i < plays.size(); i++) {
//hightlight的键为Item的id，值唯一，我们设置的高亮字段为title
if (null != hightlight.get(plays.get(i).getServiceSkuId()).get("v1_serviceTitle")) {
String hlString = hightlight.get(plays.get(i).getServiceSkuId()).get("v1_serviceTitle").toString();
if (null != hlString) {
plays.get(i).setServiceName(hlString.replaceAll("[\\[\\]]",""));
}
}
}
} catch (SolrServerException e) {
e.printStackTrace();
}
if (null != plays && plays.size() > 0) {
mapplays.put(strlist.get(j), plays);
}
}
}
return mapplays;
}作者：wangxiaoda
链接：https://www.jianshu.com/p/41364bf865fc