❶ 如何使solr查询结果带score
一、 查询参数说明
在做solr查询的时候，solr提供了很多参数来扩展它自身的强大功能！以下是使用频率最高的一些参数！
1、常用
q - 查询字符指卖串，这个是必须的。如果查询所有*:* ，唯带逗根据指行歼定字段查询（Name:张三 AND Address:北京）
fq - （filter query）过虑查询，作用：在q查询符合结果中同时是fq查询符合的，例如：q=Name:张三&fq=CreateDate:[20081001 TO 20091031],找关键字mm，并且CreateDate是20081001
fl - 指定返回那些字段内容，用逗号或空格分隔多个。
❷ 如何大幅优化solr的查询性能
提升软件性能，通常喜欢去调整各种启动参数，这没有多大意义，小伎俩。 性能优化要从架构和策略入手，才有可能得到较大的收益
Solr的查询是基于Field的，以Field为基本单元，例如一个文章站要索引
classArticle
{
String title;
String content;
String tags;
}
查询参数: q=title:big && content:six
Solr会顺序执行两次 field查询 ，这个开销非常大。 实际例子 ：50万条记录，一次在6，7个字段上检索，24 core的服务器也需要10-20ms
如果把title和content 合并，那只需要查询一次，性能可以提升50%
在生成索引xml的时候，把title和content填入同一个字段，就能达到这种效果，但是产生新的问问题
无法对title和content的查询分别指定权重了，一般来说，title的权重要高于content
Solr给出一种解决方法:在schema中使用 Field
上述的纤空Article Schema可以写成如下这种格式，就能达到效果
<fieldname="title"type="text_general"indexed="true"stored="true"/>
<fieldname="content"type="text_general"indexed="true"stored="true"/>
<fieldname="tags"type="text_general"indexed="true"stored="true"/>
<fieldname="text"type="text_general"indexed="true"stored="false"multiValued="true"/>
<Fieldsource="title"dest="text"/>
<Fieldsource="content"dest="text"/>
<Fieldsource="tags"dest="text"/>此备
这种schema定义方式，既可以对单个field指定查询权重森竖毁，也可以在泛查询的时候提升性能，同时生成索引数据的时候不需要多写任何代码
❸ solr不能过滤负数吗，为什么12345都可以，但是fq=id:-1就报错呢
Esoir不能过滤负数吗为什么12345都可以但是fg=ID冒号减一就报错呢这是算法算错了
❹ Solr的使用 — 检索
本文是延续 Solr的使用 系列，前一篇文章已经讲了 Solr 的部署和数据推送，这里主要以示例方式讲述 Solr 的常见查询语法，同时介绍如何使用 PHP 语言的客户端 solarium 同 Solr 集群进行数据交互。
想要详细地了解 Solr 查询语法，可参考 官方wiki 。
用于示例的数据，我已经推送到了 Solr ， 见这里 。数据 Core 为 rooms，数据格式形如：
通过向 Solr 集群 GET 请求 /solr/core-name/select?query 形式的查询 API 完成查询，其中 core-name 为查询的 Core 名称。查询语句 query 由以下基本元素项组成，按使用频率先后排序：
wt 设置结果集格式，支持 json、xml、csv、php、ruby、pthyon，序列化的结果集，常使用 json 格式。
fl 指定返回的字段，多指使用“空格”和“,”号分埋蔽雹割，但只支持设置了 stored=true 的字段。 * 表示返回全部字段，一般情况不需要返回文档的全部字段。
字段别名 ：使用 displayName:fieldName 形式指定字段的别名，例如：
函数 ：fl 还支持使用 Solr 内置函数 ，例如根据单价算总价：
fq 过滤弯帆查询条件，可充分利用 cache，所以可以利用 fq 提高检索性能。
sort 指定结果集的排序规则，格式为 <fieldName>+<sort> ，支持 asc 和 desc 两种排序规则。例如按照价格倒序排列：
也可以多字段排序，价格和面积排序：
查询字符串 q 由以下元素项组成，字段条件形如 fieldName:value 格式：
以上元素项的默认值由 solrconfig.xml 配置文件定义。通常查询时设置 q=*:* ，然后通过 fq 过滤条件来完成查询，通过缓存提高查询性能。
Solr 的模糊查询使用占位符来描述查询规则，如下：
查询小区名称中包含“嘉”的房源信息：
Solr 的模糊查询为：
单精确值查询是最简单的查询，类似于 SQL 中 = 操作符。查询小区 id 为 1111027377528 的房源信息：
Solr 中查询为：
多精确值查询是单精确值查询的扩展，格式为 (value1 value2 ...) ，功能类似于 SQL 的 IN 操作符。查询小区 id 为 1111027377528 或者 1111047349969 的房源信息：
Solr 中查询为：
范围查询是查询指定范围的值（数字和时间），格式为 [value1 TO value2] ，类似于 SQL 的 BETWEEN 操作符。查询价格在 [2000, 3000] 的房源信息：
Solr 中范围查询为：
几个特殊的范围查询：并渣
将基本查询结合布尔查询，就可以实现大部分复杂的检索场景。布尔查询支持以下几种布尔操作：
查询北京市价格区间在 [2000, 3000] 或者上海市价格区间在 [1500, 2000] 的房源信息：
转换为逻辑与布尔查询：
在实际中分组查询比较常见，当然 Solr 也支持分组查询。分组查询语句由以下基本元素项组成（常用部分）：
查询西二旗内价格最便宜小区的房源信息：
Group 分组查询为：
结果为：
在大多数情况下，Group 分组已经能满足我们的需求，但是如果待分组字段为多值，Group 分组已经无能为力了，这时使用 Facet 就能轻松解决。
Solr 的 Facet 语句由以下基本元素构成（常用）：
例如，统计每个商圈的房源分布情况并倒序排列，由于 bizcircleCode 字段为多值，Facet 查询为：
结果如下：
Solr 的 geofilt 过滤器可以实现 LBS 检索，但要在 schema.xml 配置中将需检索字段的字段类型设置为 solr.LatLonType 类型。geofilt 过滤器参数列表如下：
示例中的 location 字段，值为 “40.074203,116.315445”，类型配置为：
则检索坐标点 40.074203,116.315445 附近 2 公里的房源信息：
Solr 提供一些函数以实现逻辑或数学运算。其中常用 数学运算 函数列表如下：
常用的 逻辑运算 函数：
这些函数可以使用在返回值或者查询条件上。例如返回每个房源的每平方米价格信息：
PHP 可以使用 solarium 客户端，实现 Solr 数据源的检索，详细使用说明 见这里 。
solarium 客户端需要配置 Solr 的基本信息。如下：
solarium 提供的查询方法较丰富，整理后如下表所示：
查询北京市的所有房源信息，如下：
solarium 提供的分组查询方法如下表所示（常用）：
获取西二旗每个小区的房源分布信息，如下：
solarium 提供的 Facet 查询方法，如下表（常用）：
获取北京市每个商圈的房源分布信息，如下：
到这里，Solr 系列就整理完毕了，未涉及的部分后续接触时再补充。这两天利用休息时间充电，自己在 Solr 方面的技能也算是上了一个台阶了。
❺ 求助：solr如何通过指定条件修改数据
修改主方法
public int saveContent(String enterpriseId, String enterpriseName, String lableType, String resouce, String pubDate,
String content) {
int state = 0;
LBHttpSolrServer server = SolrUtil.getSolrServer(ap.getEnterprisenewSolrUrl());
SolrQuery query = new SolrQuery();
query.set("q", "enterpriseId:" + enterpriseId);
try {
QueryResponse qr = server.query(query);
List<EnterpriseContentBean> contentList = qr.getBeans(EnterpriseContentBean.class);
// 设置需要保存的文章信息
for (EnterpriseContentBean bean : contentList) {
bean.setEnterpriseId(enterpriseId);
bean.setEnterpriseName(enterpriseName);
List<String> contents = new ArrayList<String>();
contents.add(content);
bean.setContent(contents);
bean.setPubDate(pubDate);
System.out.println("pubDate======>" + pubDate);
List<String> lableTypes = Arrays.asList(lableType.split(","));
bean.setLableType(lableTypes);
bean.setResource(resouce);
bean.setIsVisited_s("1");
}
server.addBeans(contentList);
server.commit();
} catch (SolrServerException e) {
state = 1;
System.out.println("修改solr数据报错");
e.printStackTrace();
} catch (IOException e) {
state = 1;
System.out.println("修改solr数据报错");
e.printStackTrace();
}
return state;
}
删除主方法
public int deletContent(String enterpriseId) {
LBHttpSolrServer server = SolrUtil.getSolrServer(ap.getEnterprisenewSolrUrl());
int state = 0;
try {
server.deleteById(enterpriseId);
server.commit();
} catch (SolrServerException e) {
state = 1;
System.out.println("删除solr数据报错");
e.printStackTrace();
} catch (IOException e) {
state = 1;
System.out.println("删除solr数据报错");
e.printStackTrace();
}
return state;
}
solr工具类
package com.dinfo.boc.utils;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.impl.LBHttpSolrServer;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import com.dinfo.boc.enterprise.bean.EnterpriseContentBean;
import com.dinfo.boc.enterprisenew.bean.SolrQueryResult;
/**
* 与Solr服务器交互的工具类
* @author qiuyj
*
*/
public class SolrUtil {
/**
* 获取与指定Solr地址的连接
* @param solrUrl
* @return
*/
public static LBHttpSolrServer getSolrServer(String solrUrl){
final int ONE_HUNDRED_MS = 10000000;
if(solrUrl == null || "".equals(solrUrl)){
throw new RuntimeException("Solr url can not be empty!");
}
LBHttpSolrServer solrServer = null;
try {
solrServer = new LBHttpSolrServer(solrUrl);
solrServer.setConnectionTimeout(ONE_HUNDRED_MS);
} catch (MalformedURLException e) {
e.printStackTrace();
} //SolrUtil.getSolrServer(solrUrl);
//solrServer.(100);
//solrServer.setMaxTotalConnections(100);
return solrServer;
}
/**
* 向指定的Solr地址添加一条数据
* @param solrUrl
* @param doc
* @throws Exception
*/
public static void add(String solrUrl, SolrInputDocument doc) throws Exception {
if(doc == null){
throw new RuntimeException("SolrInputDocument object can not be null!");
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
solr.add(doc);
solr.commit();
}
/**
* 向指定的Solr地址用JavaBean添加一条数据
* @param solrUrl
* @param obj
* @throws Exception
*/
public static void add(String solrUrl, Object obj) throws Exception {
if(obj == null){
throw new RuntimeException("Object to be inserted can not be null!");
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
solr.addBean(obj);
solr.commit();
}
/**
* 向指定Solr地址批量添加数据
* @param solrUrl
* @param docs
* @throws Exception
*/
@SuppressWarnings("unchecked")
public static void addAll(String solrUrl, Collection<? extends Object> objs) throws Exception {
if(objs == null){
throw new RuntimeException("Object collection can not be null!");
}
if(objs.size() == 0){
return;
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
if(objs.iterator().next() instanceof SolrInputDocument){
solr.add((Collection<SolrInputDocument>)objs);
} else {
solr.addBeans(objs);
}
solr.commit();
}
/**
* 根据给定的id，从solr中删除对应信息
* @param solrUrl
* @param ids
*/
public static void deleteByIds(String solrUrl, String ... ids) throws Exception {
if(ids == null || ids.length == 0){
throw new RuntimeException("Ids can not be empty!");
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
solr.deleteById(Arrays.asList(ids));
solr.commit();
}
public static void deleteByIds(String solrUrl, Integer ... ids) throws Exception {
if(ids == null || ids.length == 0){
throw new RuntimeException("Ids can not be empty!");
}
List<String> stringIdList = new ArrayList<>(ids.length);
for(Integer id : ids){
stringIdList.add("" + id);
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
solr.deleteById(stringIdList);
solr.commit();
}
/**
* 删除指定Solr路径下符合指定查询条件的数据
* @param solrUrl
* @param condition
* @throws Exception
*/
public static void deleteByCondition(String solrUrl, String condition) throws Exception {
if(condition == null || "".equals(condition)){
throw new RuntimeException("Condition can not be empty!");
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
solr.deleteByQuery(condition);
solr.commit();
}
/**
* 删除指定Solr路径下的所有数据
* @param solrUrl
* @throws Exception
*/
public static void deleteAll(String solrUrl) throws Exception {
deleteByCondition(solrUrl, "*:*");
}
/**
* 根据 指定查询条件从Solr中查询数据，并以SolrDocument的List形式返回
* @param solrUrl
* @param query
* @return
* @throws Exception
*/
public static SolrDocumentList queryAndGetSolrDocumentList(String solrUrl, SolrQuery query) throws Exception {
if(query == null){
throw new RuntimeException("SolrQuery object can not be null!");
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
QueryResponse resp = solr.query(query);
return resp.getResults();
}
/**
* 根据 指定查询条件从Solr中查询数据，并以QueryResponse形式返回
* @param solrUrl
* @param query
* @return
* @throws Exception
*/
public static QueryResponse queryAndGetSolrQueryResponse(String solrUrl, SolrQuery query) throws Exception {
if(query == null){
throw new RuntimeException("SolrQuery object can not be null!");
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
QueryResponse resp = solr.query(query);
return resp;
}
/**
* 根据 指定查询条件从Solr中查询数据，并以Java Bean的List形式返回
* @param solrUrl
* @param query
* @param returnClass 返回的List集合的泛型
* @return
* @throws Exception
*/
public static <T> List<T> queryAndGetBeanList(String solrUrl, SolrQuery query, Class<T> returnClass) throws Exception {
if(query == null){
throw new RuntimeException("SolrQuery object can not be null!");
}
if(returnClass == null){
throw new RuntimeException("Return class can not be null!");
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
QueryResponse resp = solr.query(query);
return resp.getBeans(returnClass);
}
/**
* 根据 指定查询条件从Solr中查询数据，并以SolrQueryResult对象的形式返回，其中包含List对象和totalCount
* @param solrUrl
* @param query
* @param returnClass 返回的List集合的泛型
* @return
* @throws Exception
*/
public static <T> SolrQueryResult<T> queryAndGetSolrQueryResult(String solrUrl, SolrQuery query, Class<T> returnClass) throws Exception {
SolrQueryResult<T> result = new SolrQueryResult<T>();
if(query == null){
throw new RuntimeException("SolrQuery object can not be null!");
}
if(returnClass == null){
throw new RuntimeException("Return class can not be null!");
}
LBHttpSolrServer solr = getSolrServer(solrUrl);
solr.setConnectionTimeout(10000);
QueryResponse resp = solr.query(query);
List<T> resultList = resp.getBeans(returnClass);
long totalCount = resp.getResults().getNumFound();
result.setResultList(resultList);
result.setTotalCount(totalCount);
return result;
}
/**
* 根据 指定查询条件从Solr中查询数据，并以SolrQueryResult对象的形式返回，其中包含List对象和totalCount
* @param solrUrl
* @param query
* @param returnClass 返回的List集合的泛型
* @return
* @throws Exception
*/
public static <T> SolrQueryResult<T> queryAndGetSolrQueryResult(LBHttpSolrServer solr, SolrQuery query, Class<T> returnClass) throws Exception {
SolrQueryResult<T> result = new SolrQueryResult<T>();
if(query == null){
throw new RuntimeException("SolrQuery object can not be null!");
}
if(returnClass == null){
throw new RuntimeException("Return class can not be null!");
}
QueryResponse resp = solr.query(query);
List<T> resultList = resp.getBeans(returnClass);
long totalCount = resp.getResults().getNumFound();
result.setResultList(resultList);
result.setTotalCount(totalCount);
return result;
}
/**
* 用以过滤一些影响Solr查询的特殊字符，如左右括号、星号等
* @param str
* @return
*/
public static String filterSpecialCharacters(String str){
if(str == null){
return str;
}
str = str.replace("(", "\\(");
str = str.replace(")", "\\)");
str = str.replace("*", "\\*");
return str;
}
public static void updateSolrById(LBHttpSolrServer server){
SolrQuery query = new SolrQuery();
String id="";
int state=0;
String name="新疆金风科技股份有限公司";
query.set("q", "enterpriseId:"+id);
try {
QueryResponse qr = server.query(query);
List<EnterpriseContentBean> contentList = qr.getBeans(EnterpriseContentBean.class);
//设置需要保存的文章信息
for(EnterpriseContentBean bean:contentList){
// bean.setEnterpriseId(enterpriseId);
bean.setEnterpriseName(name);
bean.setResource("东方财富网港股频道");
}
server.addBeans(contentList);
server.commit();
} catch (SolrServerException e) {
state = 1;
e.printStackTrace();
} catch (IOException e) {
state = 1;
e.printStackTrace();
}
}
public static void main(String[] args) {
try {
=new LBHttpSolrServer("http://115.182.226.165:8008/solr/enterprisenew");
enterpriseServer.setConnectionTimeout(10000000);
updateSolrById(enterpriseServer);
System.out.println("over");
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
❻ 教你使用solr搭建你的全文检索
Solr 是一个可供企业使用的 基于 Lucene 的开箱即用的搜索服务器 对Lucene不熟？那么建议先看看下面两篇文档
实战Lucene 第 部分 初识 Lucene lo lucene /
用Lucene加速Web搜索应用程序的开发 lucene /
一 solr介绍
solr是基于Lucene Java搜索库的企业级全文搜索引擎 目前是apache的一个项目 它的官方网址在 solr需要运行在一个servlet 容器里 例如tomcat solr在lucene的上层提供了一个基于HTTP/XML的Web Services 我们的应用需要通过这个服务与兄斗祥solr进行交互
二 solr安装和配置
关于solr的安装和配置 这里也有两篇非常好的文档 作者同时也是 Lucene Java 项目的提交人和发言人
使用Apache Solr实现更加灵巧的搜索 solr /l
solr /l
下面主要说说需要注意的地方
Solr的安装非常简单 下载solr的zip包后解压缩将dist目录下的war文件改名为solr war直接复制到tomcat 的webapps目录即可 注意一定要设置solr的主位置 有三种方法 我采用的是在tomcat里配置java p/env/solr/home的一个JNDI指向solr的主目录（example目录下） 建立/tomcat /conf/Catalina/localhost/solr xml文件
<Context docBase= D:/solr war debug= crossContext= true ><Environment name= solr/home type= java lang String value= D:/solr/solr override= true /></Context>
观察这销燃个指定的solr主位置 里面存在两个文件夹 conf和data 其中conf里存放了对solr而言最为重要的两个配置文件schema xml和solrconfig xml data则用于存放索引文件
schema xml主要包括types fields和其他的一些缺省设置
solrconfig xml用来配置Solr的一些系统属性 例如与索引和查询处理有关的一些常见的配置选项 以及缓存 扩展等等
上面的文档对这两个文件羡搏有比较详细的说明 非常容易上手 注意到schema xml里有一个
<uniqueKey>url</uniqueKey>
的配置 这里将url字段作为索引文档的唯一标识符 非常重要
三 加入中文分词
对全文检索而言 中文分词非常的重要 这里采用了qieqie庖丁分词（非常不错 ）） 集成非常的容易 我下载的是 alpha 版本 其中它支持最多切分和按最大切分 创建自己的一个中文TokenizerFactory继承自solr的BaseTokenizerFactory
/** * Created by IntelliJ IDEA * User: ronghao * Date: * Time: : : * 中文切词 对庖丁切词的封装 */ public class ChineseTokenizerFactory extends BaseTokenizerFactory { /** * 最多切分 默认模式 */ public static final String MOST_WORDS_MODE = most words ; /** * 按最大切分 */ public static final String MAX_WORD_LENGTH_MODE = max word length ; private String mode = null; public void setMode(String mode) { if (mode==null||MOST_WORDS_MODE equalsIgnoreCase(mode) || default equalsIgnoreCase(mode)) { this mode=MOST_WORDS_MODE; } else if (MAX_WORD_LENGTH_MODE equalsIgnoreCase(mode)) { this mode=MAX_WORD_LENGTH_MODE; } else { throw new IllegalArgumentException( 不合法的分析器Mode 参数设置: + mode); } } @Override public void init(Map args) { super init(args); setMode(args get( mode )); } public TokenStream create(Reader input) { return new PaodingTokenizer(input PaodingMaker make() createTokenCollector()); } private TokenCollector createTokenCollector() { if( MOST_WORDS_MODE equals(mode)) return new MostWordsTokenCollector(); if( MAX_WORD_LENGTH_MODE equals(mode)) return new MaxWordLengthTokenCollector(); throw new Error( never happened ); } }
在schema xml的字段text配置里加入该分词器
<fieldtype name= text class= solr TextField positionIncrementGap= >
< *** yzer type= index >
<tokenizer class= ronghao fulltextsearch *** yzer ChineseTokenizerFactory mode= most words /><filter class= solr StopFilterFactory ignoreCase= true words= stopwords txt />
<filter class= solr WordDelimiterFilterFactory generateWordParts= generateNumberParts= catenateWords= catenateNumbers= catenateAll= />
<filter class= solr LowerCaseFilterFactory />
<filter class= solr />
</ *** yzer>
< *** yzer type= query >
<tokenizer class= ronghao fulltextsearch *** yzer ChineseTokenizerFactory mode= most words />
<filter class= solr SynonymFilterFactory synonyms= synonyms txt ignoreCase= true expand= true />
<filter class= solr StopFilterFactory ignoreCase= true words= stopwords txt />
<filter class= solr WordDelimiterFilterFactory generateWordParts= generateNumberParts= catenateWords= catenateNumbers= catenateAll= />
<filter class= solr LowerCaseFilterFactory />
<filter class= solr />
</ *** yzer>
</fieldtype>
完成后重启tomcat 即可在
体验到庖丁的中文分词 注意要将paoding *** ysis jar复制到solr的lib下 注意修改jar包里字典的home
四 与自己应用进行集成
Solr安装完毕 现在可以将自己的应用与solr集成 其实过程非常的简单 应用增加数据——>根据配置的字段构建add的xml文档——>post至solr/update
应用删除数据à根据配置的索引文档唯一标识符构建delete的xml文档——>post至solr/update
检索数据à构建查询xml—>get至/solr/select/——>对solr返回的xml进行处理——>页面展现
具体的xml格式可以在solr网站找到 另外就是solr支持高亮显示 非常方便
关于中文 solr内核支持UTF 编码 所以在tomcat里的server xml需要进行配置
<Connector port= maxHttpHeaderSize= URIEncoding= UTF …/>
另外 向solr Post请求的时候需要转为utf 编码 对solr 返回的查询结果也需要进行一次utf 的转码 检索数据时对查询的关键字也需要转码 然后用 + 连接
String[] array = StringUtils split(query null ); for (String str : array) { result = result + URLEncoder encode(str UTF ) + + ; }
lishixin/Article/program/Java/hx/201311/25984
❼ solr查询某个字段最大值，如何实现
q:查询的关键字，此参数最为重要，例如，q=id:1，默认为q=*:*，类似于sql中的where 1=1。
fq（filter query）:过滤查询，提供一个可选的筛选器查询。返回在q查询符合结果中同时符合的fq条件的查询结果，例如：q=id:1&fq=sort:[1 TO 5]&fq=section:0，找关键字id为1 的，并且sort是1到5之间,section=0的。还能写成fq=+sort[1 TO 5] +section:0]。性能方面的考虑:每个fq下面的记录都会单独缓存。可以考虑把经常在一起的fq条件用+方式写。
sort:排序方式，例如id desc 表示按照 “id” 降序。id desc, price asc先按id降序，再按price升序。sum(x_f, y_f) desc按x_f和y_f字段的和降序。
start,rows:分页参数，类似于start，limite的功能。啥都不输的话默认值分别为start=0,limit=10。
❽ Solr的查询结果去重
Group将具有公共字段值的文档进行分组，并返回每个组的顶部文档（可以指定排序）。但是最终的结果是展示在 grouped 这个结果集中。
Collapsing 和 Expand 组件结合起来，可以在 Solr 搜索结果中根据指定字段折叠，从而对文档分组去重的效果。
Collapsing常规用法是写在fq中，最简单的启用方式如下示例：
Collapsing功能是在每个shard搜索上进行折叠，但是在最终汇总结果时并没有再次按照相应的折叠方式进行合并，导致可能出现的情况就是同一个分组出现多次。
在索引数据时使用路由，使用折携租岁叠字段作为路由字段，这样型弊就可以把具有相同值的文档索引到同一个分片（但是这样也有坏处，可能会导致索引数据分布不均，海量数据下影响不大）。
在创建collection时使用以下两个辩睁参数
❾ solr怎么设置才能像数据库中的like模糊查询
可以试握运试：
使用SolrQuery对象，
SolrQuery solrQuery = new SolrQuery();
//组装查询条件段前梁
solrQuery.setQuery("*:*");
String key = "java3";
solrQuery.addFilterQuery("content:" + "*"悔孙+key+"*" ）;试试吧