solr过滤
Ⅰ Solr 查询速度优化
优化数据访问
查询性能低下的最基本的原因是访问的数据太多，对于低效的查询，可以从下面两个步骤来分析：
（1）确认应用程序是否在检索大量超过需要的行，这通常意味着访问了太多的行，但有时候也有可能访问了太多的列。
（2）确认MySQL服务器层是否在分析大量超过需要的数据行。
一些典型的情况：
（1） 查询不需要的记录。这样的查询上应该加上LIMIT
（2） 多表关联时返回了全部列。应该只取需要的列。
（3） 总是取出全部的列：SELECT *
（4） 重复查询需要的数据。较好的解决方案是使用数据缓存。
确认MySQL只返回了需要的数据之后，接下来应该看看查询是否扫描了过多的数据，最简单的衡量查询开销的三个指标如下：
（1）响应时间
（2）扫描的行数
（3）返回的行数
响应时间=排队时间+服务时间
理性情况下的扫描的行数和返回的行数应该是相等的。
访问类型：MySQL有好几种方式可以查找并返回一行结果，Explain的type列反应了访问类型，访问类型有全表扫描、索引扫描、范围扫描、唯一索引查询、常数引用等，这些速度从慢到块，扫描的行数从大到小。Using Where表示MySQL将通过Where条件来筛选存储引擎返回的数据。MySQL能够以三种方式应用Where条件，从好到坏依次是：
（1）、在索引中使用Where来过滤数据，这是在存储引擎层实现的
（2）、使用了索引覆盖扫描（Extra列中Using index）来返回记录，直接从索引中过滤不需要的记录并返回命中的结果，这是在MySQL服务器层实现的，但是无需回表查询记录。
（3）、从数据表中返回数据，然后过滤不满足条件的记录，这是在MySQL服务器层实现的，MySQL需要先从数据库中读取记录然后过滤。
如果一个查询需要扫描大量的数据但是只返回少数的行，那么通常可以尝试下面的技巧去优化：
（1）、使用索引覆盖扫描，即把所有需要的列都放到索引中，这样存储引擎无需回表获取对应行就可以返回结果了。
（2）、该表库表结构，使用单独的汇总表
（3）、重写整个复杂的查询，让MySQL优化器能够以最优化的方式执行整个查询。
重构查询的方式
确定一个复杂查询还是多个简单查询更加有效
切分查询：
将一个完整的查询分散到多次小查询中（例如通过Limit）
查询执行的基础
MySQL执行查询的过程：
（1）客户端发送一条查询给服务器
（2）服务器先检查查询缓存，如果命中了缓存，则立即返回存储在缓存中的结果，否则进入下一个阶段。
（3）服务器端进行SQL解析、预处理，再由优化器生成对应的执行计划
（4）将结果返回给客户端。
Ⅱ 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如何通过指定条件修改数据
修改主方法
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中先检索fieldname，然后再在结果中检索关键字
去查询filedname? filedname都是定义好的。 没明白你的问题。
你可以直接写AND,比如 filename1:亚洲 AND filename2:XX
Ⅳ solr 名称 关键字两个字段权重设置
大家都知道，在SQL脚本中设置多字段做关键字相对比较简单，例:primary key(id1,id2) ,但用脚本建数据库就比较麻烦了专。
下面我们来介绍属一下具体的解决方法:
1.把要设置为关键字的其中一个字段设为主键。
2.在设为主键的字段上右键单击选择索引/健,出现索引/健对话框。
3.找到常规----列,单击右边的小按钮,出现索引列对话框。
4.至此，我们就可以选择几个字段作为关键字了。
注释:第一个步骤不能省略。
Ⅵ solr不能过滤负数吗，为什么12345都可以，但是fq=id:-1就报错呢
Esoir不能过滤负数吗为什么12345都可以但是fg=ID冒号减一就报错呢这是算法算错了
Ⅶ 如何理解solr的core和collection
/****多核查询测试*@throwsException*/()throwsException{//查询a和b下面的数据，HttpSolrClientsc=newHttpSolrClient("a");Stringshards="192.168.1.215:8983/solr/a,192.168.1.214:8983/solr/b";=newModifiableSolrParams();solrParams.set("q","sname:北京奇虎科技有限公司");//solrParams.set("q.op","AND");//设置查询关系.set("fl","*,score");//设置过滤solrParams.set("shards",shards);//设置shardQueryResponsersp=sc.query(solrParams);system.out.println("命中数量："+rsp.getResults().getNumFound());for(SolrDocumentsd:rsp.getResults()){System.out.println(sd);}sc.close();}
Ⅷ 如何监控Solr
1、将解压包中的solr-4.7.1/dist/solr-4.7.1.war复制到tomcat_dir/webapps/目录，并命名为solr.war。
2、将solr-4.7.1/example/lib/ext/目录下的jar文件复制到tomcat/lib目录下，将solr-4.7.1/example/resources/下的log4j.properties文件复制到tomcat_dir/lib目录下;
切把 solr-4.7.1/example/solr，复制到tomcat_dir/bin下。
3、修改tomcat_dir/conf/server.xml
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443"
URIEncoding="UTF-8" />
4、创建solr.xml，存放在路径：tomcat/conf/Catalina/localhost/solr.xml，内容：
<Context path="/solr" docBase="C:\Tomcat 7.0\webapps\solr.war"
debug="0" crossContext="true">
<Environment name="solr/home" type="java.lang.String" value="C:\Tomcat 7.0\bin\solr\" override="true" />
</Context>
PS：上面的docBase和value路径中不能存在中文字符，否则会出现404错误。
5、将C:\Tomcat 7.0\webapps下的solr.war包，启动项目解压；然后再添加几个jar包：
solr-4.7.1\dist\solr-dataimporthandler-4.7.1.jar;
solr-4.7.1\dist\solr-dataimporthandler-extras-4.7.1.jar;
还要加载数据库驱动包：mysql-connector-java-3.1.13-bin.jar
6、在C:\Tomcat 7.0\bin\solr\collection1\conf 下的solrconfig.xml增加以下数据库配置：
<requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler">
<lst name="defaults">
<str name="config">data-config.xml</str>
</lst>
</requestHandler>
7、将tomcat\bin\solr\collection1\conf下增加data-config.xml文件，内容如下：
<dataConfig>
<dataSource type="JdbcDataSource"
driver="com.mysql.jdbc.Driver"
url="jdbc:mysql://192.168.1.221:3306/tmsdb"
user="root"
password="123456"/>
<document name="content">
<entity name="node" query="select id,author,title,content from solrdb">
<field column="id" name="id" />
<field column="author" name="author" />
<field column="title" name="title" />
<field column="content" name="content" />
</entity>
</document>
</dataConfig>
8、增加中文分词器，ik-analyzer的配置如下：
①目前的中文分词主要有两种
1，基于中科院ICTCLAS的隐式马尔科夫hhmm算法的中文分词器，例如smartcn等。（不支持自定义扩展词库）
2，基于正向迭代最细粒度切分算法（正向最大匹配并且最细分词）例如IK，庖丁等（支持自定义扩展词库）
安装分词前，可以去下载IK的分词包 ：
IK-Analyzer-4.7.1-0.0.1-SNAPSHOT.jar
下载完毕后，将此包放进tomcat\solr的\WEB-INF\lib下面：tomcat\webapps\solr\WEB-INF\lib 。
下面需要在solr的schemal.xml进行分词器注册:
<!-- 配置IK分词器 -->
<fieldType name="text_ik" class="solr.TextField" positionIncrementGap="100">
<analyzer type="index">
<!-- 分词-->
<tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory"/>
<!-- 禁用词过滤根据情况使用-->
<!-- <filter class="org.wltea.analyzer.lucene.IKStopFilterFactory"/> -->
</analyzer>
<analyzer type="query">
<!-- 分词-->
<tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory"/>
<!-- 禁用词过滤根据情况使用-->
<!-- <filter class="org.wltea.analyzer.lucene.IKStopFilterFactory"/>-->
</analyzer>
</fieldType>
最后还得配置一个引用字段就OK了
<field name="ik" type="text_ik" indexed="true" stored="true" multiValued="true"/>
②它的安装部署十分简单，将IKAnalyzer2012.jar部署亍项目的lib目录中；IKAnalyzer.cfg.xml不stopword.dic文件放置在class根目录（对于web项目，通常是WEB-I NF/classes目彔，同hibernate、log4j等配置文件相同）下即可 ；然后配置solr4.7中schema.xml配置解析器：
<schema name="example" version="1.1">
……
<fieldType name="text" class="solr.TextField">
<analyzer class="org.wltea.analyzer.lucene.IKAnalyzer"/>
</fieldType>
……
</schema>
Ⅸ solrj如何自动定期更新索引,管理页面如何对用户屏蔽 http://localhost:8080/solr/admin
你会编程么？ 可以采用过滤器 当请求用户角色为普通用户时 提示操作或者转向链接