Solr 查询,索引

豆包ko

环境
Solr: apache-solr-3.6.2
Tomcat:Tomcat 6.0
JDK: jdk1.6
pc : windows7

Solr的安装和配置

首先 安装 jdk  --> 然后 tomcat  
下载solr 下载地址：http://apache.etoak.com/lucene/solr/1.4.1/ 详情请见：http://wiki.apache.org/solr/Solr1.4
解压缩
solr 到   E:\solr
tomcat:   C:\Tomcat 6.0


Solr 在jetty 中启动

一般下载solr都自带 jetty serlvet 服务器,可以直接使用启动.
cd E:\solr\apache-solr-3.6.2\example
java -jar start.jar   //这样就可以启动了
http://localhost:8080/solr/admin   只要看到 solr的控制台页面 solr 就成功 启动了

有关 jetyy 的 端口配置  在  E:\solr\apache-solr-3.6.2\example\etc  这个目录下的 jetty.xml  可以修改端口


Solr 在  tomcat中的启动

//1.修改tomcat 的编码格式   
cd   C:\Tomcat 6.0\conf\server.xml
加上   URIEncoding="UTF-8"
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" URIEncoding="UTF-8" />
//2.拷贝 E:\solr\apache-solr-3.6.2\example\webapps\solr.war 到 C:\Tomcat 6.0\webapps
//3.配置solr.home
在  C:\Tomcat 6.0\conf\Catalina\localhost 新建 solr.xml
<?xml version="1.0" encoding="UTF-8"?>
<Context docBase="C:\Tomcat 6.0\webapps\solr.war" debug="0" crossContext="true">
<Environment name="solr/home" type="java.lang.String" value="E:\solr\apache-solr-3.6.2\example\solr" override="true"/>
</Context>
//3.5配置 solr.home 的 方法二
修改 solr.war 中的  web.xml   添加 如下配置 也可以(一般web.xml中已经包含了只需取消注释就可以了)
<env-entry>
<env-entry-name>solr/home</env-entry-name>
<env-entry-value>E:\solr\apache-solr-3.6.2\example\solr</env-entry-value>
<env-entry-type>java.lang.String</env-entry-type>
</env-entry>
然后重新打包
java -cvf  solr.war  *.*  将 解压后的sole.war  重新打包部署
//4.启动 tomcat就 然后 访问 http://localhost:8080/solr/admin
//5 进入控制台   默认使用  "*:*" 查询所有 文档   这个 可以在  E:\solr\apache-solr-3.6.2\example\solr\conf\solrconfig.xml 中 修改
<defaultQuery>*:*</defaultQuery>  一般 不建议修改


使用 post.jar 提交 doc  到 solr
//使用  solr自带的各种文件 建立索引
solr自带的 所有实例文档  在  E:\solr\apache-solr-3.6.2\example\exampledocs
可以看出  solr 可以使用个json, csb .xml 各种各样的文档 建立索引
还有一个 重要的post .jar  
cd E:\solr\apache-solr-3.6.2\example\exampledocs
java   -jar -Durl=http://localhost:8080/solr/update  -Dcommit=yes post.jar  *.xml
将所有的  xml文件 加入 solr中
然后回到 控制台  使用 "*:*" 就可以执行各种查询了.


solr 的两个主要配置文件

E:\solr\apache-solr-3.6.2\example\solr\conf
schema.xml : 是索引的schema ,包含了域的定义 和相关 analyzer链  还有solr中支持的一些 基本类型 以及  对应我们 javabean 中的一些  field  fieldtype  等
solrconfig.xml: 该文件是 solr的主配置文件,


mmseg4j中文分词的配置

1) 下载分词器：http://code.google.com/p/mmseg4j/
2) 下载词库：http://code.google.com/p/mmseg4j/downloads/detail?name=data.zip&can=2&q=
3) 加入 :mmseg4j 目录下的 dist 中的jar  到  C:\Tomcat 6.0\webapps\solr\web-inf\lib\
4) 在E:\solr\apache-solr-3.6.2\example\solr\ 下 建立dic 目录用户存放分词目录 容纳然后见下载 mmseg4j的分词库 中的  chars.dic units.dic words.dic words-my.dic 放入到 dic 目录
5) 修改E:\solr\apache-solr-3.6.2\example\solr\conf\ schema.xml 加入 mmseg4j的配置
用户 替换  solr中默认的 "text" "fieldtype"
在 <typs> 中添加  需要注意的是 dicPath 的值 是我们刚刚建立的 dic 目录
<fieldType name="textComplex" class="solr.TextField" positionIncrementGap="100" >  
<analyzer>  
<tokenizer class="com.chenlb.mmseg4j.solr.MMSegTokenizerFactory" mode="complex" dicPath="dic"/>  
<filter class="solr.LowerCaseFilterFactory"/>  
</analyzer>  
</fieldType>  
<fieldType name="textMaxWord" class="solr.TextField" positionIncrementGap="100" >  
<analyzer>  
<tokenizer class="com.chenlb.mmseg4j.solr.MMSegTokenizerFactory" mode="max-word" dicPath="dic"/>  
<filter class="solr.LowerCaseFilterFactory"/>  
</analyzer>  
</fieldType>  
<fieldType name="textSimple" class="solr.TextField" positionIncrementGap="100" >  
<analyzer>  
<tokenizer class="com.chenlb.mmseg4j.solr.MMSegTokenizerFactory" mode="simple" dicPath="dic"/>  
<filter class="solr.LowerCaseFilterFactory"/>  
</analyzer>  
</fieldType>  

然后在 <fields>中 添加  
<!-- mmseg4j fields -->
<field name="simple" type="textSimple" indexed="true" stored="true" multiValued="true"/>  
<field name="complex" type="textComplex" indexed="true" stored="true" multiValued="true"/>  
<field name="text" type="textMaxWord" indexed="true" stored="true" multiValued="true"/>
然后在</schema> 里面添加  
<!-- mmseg4j coypField-->
<copyField source="text" dest="simple" />  
<copyField source="text" dest="complex" />
配置好后 启动服务  
访问
http://192.168.10.85:18080/solr/admin/analysis.jsp 就可以看到 mmseg4j的分词效果,在 filed拉下中选择  name 也就是我们配置的 filed 类型
输入一句话  ,然后点击  analyzer 就可以看到效果了
如果要是外置程序也能够利用 这个 分词来更新索引 需要添加这个配置
在 solrconfig.xml：
<requesthandler name="/mmseg4j" class="com.chenlb.mmseg4j.solr.MMseg4jHandler"><lst name="defaults">
<str name="dicPath">
<str name="dicPath"> dic </str>
</str>
</lst>
</requesthandler>


IK Analyzer 中文分词 的使用个

和上面的步骤类似
2.1 下载地址
GoogleCode 开源项目 ：http://code.google.com/p/ik-analyzer/
GoogleCode  下载：http://code.google.com/p/ik-analyzer/downloads/list
加入 IKAnalyzer的jar 到 web-inf/lib 下
然后 修改  schema.xml文件 加入 fieldtype
<!-- IK Analyzer types-->
<fieldType name="text_ik" class="solr.TextField">
<analyzer class="org.wltea.analyzer.lucene.IKAnalyzer"/>
<analyzer type="index">
<tokenizer class="org.wltea.analyzer.solr.IKTokenizerFactory" isMaxWordLength="false"/>
<filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" />
<filtr class="solr.WordDelimiterFilterFactory"
generateWordParts="1"
generateNumberPats="1"
catenateWords="1"
catenateNumbers="1"
catenateAll="0"
splitOnCaseChange="1"/>
<filter class="solr.LowerCaseFilterFactory"/>
<filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
<filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
</analyzer>
<analyzer type="query">
<tokenizer class="org.wltea.analyzer.solr.IKTokenizerFactory"
isMaxWordLength="false"/>
<filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>
<filtr class="solr.WordDelimiterFilterFactory"
generateWordParts="1"
generateNumberPats="1"
catenateWords="1"
catenateNumbers="1"
catenateAll="0"
splitOnCaseChange="1"/>
<filter class="solr.LowerCaseFilterFactory"/>
<filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
<filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
</analyzer>
</fieldType>

加入 field
<!--IK Analyzer filed-->
<field name="text" type="text_ik" indexed="true" stored="false" multiValued="true" required="true"/>

然后在c:\tomcat6.0\webapps\solr\WEB-INF\classes 中加入 IKAnalyzer.cfg.xml 和 扩展字典 和 停止 字典 文件
然后访问
http://localhost:8080/solr/admin/analysis.jsp
操作类是于 mmseg4j


使用DataImportHandler 的从不同的文件中对数据进行 索引的添加

1.不用说首先加入 jar 到  web-inf\lib中啦
2.然后在  E:\solr\apache-solr-3.6.2\example\solr\conf\db\data-config.xml 中加入 与数据的连接配置和 field映射
<dataConfig>
<dataSource type="JdbcDataSource" name="ds-1" driver="oracle.jdbc.driver.OracleDriver" url="jdbc:oracle:thin:@192.168.1.242:1521:ora11g" user="bjdata"  password="bjdata"/>
<!--
<dataSource type="JdbcDataSource" name="ds-1" driver="com.mysql.jdbc.Driver" url="jdbc:mysql://db1-host/dbname" user="db_username" password="db_password"/>  <dataSource type="JdbcDataSource" name="ds-2" driver="com.mysql.jdbc.Driver" url="jdbc:mysql://db2-host/dbname" user="db_username" password="db_password"/>

-->
<document>
<entity dataSource="ds-1" name="bi_baoliao"
query="select id,userid,username,prodname,tags,createtime from bi_baoliao"
deltaQuery="select id from bi_baoliao where createtime > '${dataimporter.last_index_time}'">
<field column="Id" name="id" />
<field column="USERID"  name="userid" />
<field column="USERNAME"  name="username"/>
<field column="PRODNAME"  name="prodname"/>
<field column="TAGS"  name="tags"/>
<field column="CREATETIME"  name="createtime" dateTimeFormat="yyyy-MM-dd HH:mm:ss"/>
</entity>
</document>
</dataConfig>

然后 在 solrconfig.xml中添加
<!--DataImportHandler -->
<requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler">
<lst name="defaults">
<str name="config">./db/data-config.xml</str>
</lst>
</requestHandler>

然后启动 服务  
然后使用 http请求 创建 全量索引   增量索引
http://localhost:8080/solr/dataimport?command=full-import 全量索引
对应 data-config.xml中的 entity 中  query sql语句  
http://localhost:8080/solr/dataimport?command=delta-import  增量索引
对应 data-config.xml中的 entity 中  deltaQuery   sql语句  
还有一些 command 的参数
full-import : "完全导入"
clean : (default 'true'). 决定在建立索引之前，删除以前的索引。
commit: (default 'true'). 决定这个操作之后是否要commit
optimize: (default 'true'). 决定这个操作之后是否要优化。
debug : (default false). 工作在debug模式下。
delta-import : 当遇到一些增量的输入，
status : 想要知道命令执行的状态 ,
reload-config : 如果data-config.xml已经改变，你不希望重启solr，而要重新加载配置时，运行一下的命令http://:/solr/dataimport?command=reload-config
abort : 你可以通过访问 url http://:/solr/dataimport?command=abort 来终止一个在运行的操作
还可以在 这个配置文件中 配置  json   xml  rss 不同类型数据源的导入  

更多请看下面有关 DIH
http://wiki.apache.org/solr/DataImportHandler
solr的查询 粘贴一个文章来 看
http://www.doc88.com/p-008848668417.html
http://wiki.apache.org/solr/CoreQueryParameters

常用
q - 查询字符串，必须的。
fl - 指定返回那些字段内容，用逗号或空格分隔多个。
start - 返回第一条记录在完整找到结果中的偏移位置，0开始，一般分页用。
rows - 指定返回结果最多有多少条记录，配合start来实现分页。
sort - 排序，格式：sort=<field name>+<desc|asc>[,<field name>+<desc|asc>]… 。示例：（inStock desc, price asc）表示先 “inStock” 降序, 再 “price” 升序，默认是相关性降序。
wt - (writer type)指定输出格式，可以有 xml, json, php, phps, 后面 solr 1.3增加的，要用通知我们，因为默认没有打开。
fq - （filter query）过虑查询，作用：在q查询符合结果中同时是fq查询符合的，例如：q=mm&fq=date_time:[20081001 TO 20091031]，找关键字mm，并且date_time是20081001到20091031之间的。官方文档：http://wiki.apache.org/solr/CommonQueryParameters
不常用
q.op - 覆盖schema.xml的defaultOperator（有空格时用"AND"还是用"OR"操作逻辑），一般默认指定
df - 默认的查询字段，一般默认指定
qt - （query type）指定那个类型来处理查询请求，一般不用指定，默认是standard。
其它
indent - 返回的结果是否缩进，默认关闭，用 indent=true|on 开启，一般调试json,php,phps,ruby输出才有必要用这个参数。
version - 查询语法的版本，建议不使用它，由服务器指定默认值。
[Solr的检索运算符]
“:” 指定字段查指定值，如返回所有值*:*²
“?”²表示单个任意字符的通配
“*” 表示多个任意字符的通配（不能在检索的项开始使用*或者?符号）²
“~”²表示模糊检索，如检索拼写类似于”roam”的项这样写：roam~将找到形如foam和roams的单词；roam~0.8，检索返回相似度在0.8以上的记录。
²邻近检索，如检索相隔10个单词的”apache”和”jakarta”，”jakarta apache”~10
“^”²控制相关度检索，如检索jakarta apache，同时希望去让”jakarta”的相关度更加好，那么在其后加上”^”符号和增量值，即jakarta^4 apache
布尔操作符AND、||²
布尔操作符OR、²&&
布尔操作符NOT、!、-²（排除操作符不能单独与项使用构成查询）
“+” 存在操作符，要求符号”+”后的项必须在文档相应的域中存在²
( ) 用于构成子查询²
² [] 包含范围检索，如检索某时间段记录，包含头尾，date:[200707 TO 200710]
{}²不包含范围检索，如检索某时间段记录，不包含头尾
date:{200707 TO 200710}
" 转义操作符，特殊字符包括+ -² && || ! ( ) { } [ ] ^ ” ~ * ? : "

Solr 删除全部索引：http://localhost:8080/solr/update/?stream.body=<delete><query>*:*</query></delete>&stream.contentType=text/xml;charset=utf-8&commit=true

Solr 查询索引记录：http://localhost:8080/solr/select/?q=%E5%85%A8%E6%96%87&version=2.2&start=0&rows=10&indent=on
日期查询
Approvetime:[NOW/DAY-1DAY TO NOW/DAY]
Approvetime:[NOW-1DAY TO NOW]
Approvetime:[NOW-7DAY TO NOW]
Approvetime:[NOW-1MONTH TO NOW]
createdate:[1995-12-31\T23:59:59.999\Z TO 2007-03-06\T00:00:00\Z]


我想到这里你已经够用了 哈哈
solrj

//加入 solr中的jar  在 下载的 solr中 dist中有个  solrj  
apache-solr-core-3.6.2.jar
apache-solr-dataimporthandler-3.6.2.jar
apache-solr-solrj-3.6.2.jar
bjdata-common.jar
bjdata-util.jar
commons-codec-1.6.jar
commons-httpclient-3.1.jar
commons-io-2.1.jar
geronimo-stax-api_1.0_spec-1.0.1.jar
IKAnalyzer2012_u6.jar
IKAnalyzer3.2.8.jar
jcl-over-slf4j-1.6.1.jar
log4j-1.2.14.jar
ojdbc6.jar
pinyin4j-2.5.0.jar
poi-3.7-20101029.jar
slf4j-api-1.6.1.jar
slf4j-log4j12-1.7.5.jar
wstx-asl-3.2.7.jar

//各种测试案例

package com.sh.test;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.xml.registry.infomodel.User;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrQuery.ORDER;
import org.apache.solr.client.solrj.SolrRequest.METHOD;
import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.beans.DocumentObjectBinder;
import org.apache.solr.client.solrj.embedded.EmbeddedSolrServer;
import org.apache.solr.client.solrj.impl.HttpSolrServer;
import org.apache.solr.client.solrj.response.FacetField;
import org.apache.solr.client.solrj.response.FacetField.Count;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.client.solrj.response.TermsResponse;
import org.apache.solr.client.solrj.response.TermsResponse.Term;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.SolrInputDocument;
import org.apache.solr.common.SolrInputField;
import org.apache.solr.common.params.ModifiableSolrParams;
import org.apache.solr.common.params.SolrParams;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.sh.baoliao.model.BiSearchBaoLiao;
public class ServerTest {
private SolrServer server;  //有 HttpSolrServer EmbeddedSolrServer 两个
private static final String DEFAULT_URL="http://localhost:8983/solr";
private HttpSolrServer solrServer;  //CommonsHttpSolrServer solrServer; 过时
private EmbeddedSolrServer esolrServer;
@Before
public void init(){
try {
server =new HttpSolrServer(DEFAULT_URL);
solrServer=new HttpSolrServer(DEFAULT_URL);
//Server的有关配置选项参数
solrServer.setSoTimeout(1000); //socket read timeout
solrServer.setConnectionTimeout(100);
solrServer.setDefaultMaxConnectionsPerHost(100);
solrServer.setMaxTotalConnections(100);
solrServer.setFollowRedirects(false); // defaults to false
solrServer.setAllowCompression(true);
//solr 1.2 需要显示设置返回的类型
//solrServer.setParser(new XMLResponseParser());
//solrServer.setRequestWriter(new BinaryRequestWriter());
} catch (Exception e) {
e.printStackTrace();
}
}
@After
public void destory(){
server=null;
solrServer=null;
System.runFinalization();
System.gc();
}
public final void fail(Object o){
System.out.println(o);
}
/**
* 测试连接创建serve对象成功
*/
@Test  
public void test() {
//测试前先删除所有索引
try {
server.deleteByQuery( "*:*" );
} catch (SolrServerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
fail(server);
fail(solrServer);
}
/**
* 根据query参数查询索引
* @param query
*/
@Test
public void query(String query){
if(query==null)
query="id:373";
SolrParams params=new SolrQuery(query);
try {
QueryResponse response=server.query(params);
SolrDocumentList list=response.getResults();
for (int i = 0; i < list.size(); i++) {
fail(list.get(i));
}
} catch (SolrServerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//4、 利用SolrJ完成Index Document的添加操作
@Test
public void addDoc() {
//创建doc文档
SolrInputDocument doc = new SolrInputDocument();
doc.addField("id", 1);
doc.addField("name", "Solr Input Document");
doc.addField("manu", "this is SolrInputDocument content");
try {
//添加一个doc文档
UpdateResponse response = server.add(doc);
fail(server.commit());//commit后才保存到索引库
fail(response);
fail("query time：" + response.getQTime());
fail("Elapsed Time：" + response.getElapsedTime());
fail("status：" + response.getStatus());
} catch (SolrServerException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
query("name:solr");
}
//5、 利用SolrJ添加多个Document，即添加文档集合
/**
* <b>function:</b> 添加docs文档集合
* @author hoojo
* @createDate 2011-10-21 上午09:55:01
*/
@Test
public void addDocs() {
Collection<SolrInputDocument> docs = new ArrayList<SolrInputDocument>();
SolrInputDocument doc = new SolrInputDocument();
doc.addField("id", 2);
doc.addField("name", "Solr Input Documents 1");
doc.addField("manu", "this is SolrInputDocuments 1 content");
docs.add(doc);
doc = new SolrInputDocument();
doc.addField("id", 3);
doc.addField("name", "Solr Input Documents 2");
doc.addField("manu", "this is SolrInputDocuments 3 content");
docs.add(doc);
try {
//add docs
UpdateResponse response = server.add(docs);
//commit后才保存到索引库
fail(server.commit());
fail(response);
} catch (SolrServerException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
query("solr");
}
//7、 添加Bean集合
@Test
public void addBean() {
//Index需要添加相关的Annotation注解，便于告诉solr哪些属性参与到index中
BiSearchBaoLiao index = new BiSearchBaoLiao();
index.setId(4l);
index.setUserid(21l);
index.setUsername("add bean index");
index.setProdname("添加Index Bean到索引库");
try {
//添加Index Bean到索引库
UpdateResponse response = server.addBean(index);
fail(server.commit());//commit后才保存到索引库
fail(response);
} catch (SolrServerException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
queryAll();
}
//8、 删除索引Document
/**
* <b>function:</b> 删除索引操作
* @author hoojo
* @createDate 2011-10-21 上午10:04:28
*/
@Test
public void remove() {
try {
//删除id为1的索引
server.deleteById("1");
server.commit();
query("id:1");
//根据id集合，删除多个索引
List<String> ids = new ArrayList<String>();
ids.add("2");
ids.add("3");
server.deleteById(ids);
server.commit(true, true);
query("id:3 id:2");
//删除查询到的索引信息
server.deleteByQuery("id:4 id:6");
server.commit(true, true);
queryAll();
} catch (SolrServerException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
//9、 查询索引
@Test
public void queryAll() {
ModifiableSolrParams params = new ModifiableSolrParams();
// 查询关键词，*:*代表所有属性、所有值，即所有index
params.set("q", "*:*");
// 分页，start=0就是从0开始，，rows=5当前返回5条记录，第二页就是变化start这个值为5就可以了。
params.set("start", 0);
params.set("rows", Integer.MAX_VALUE);
// 排序，，如果按照id 排序，，那么将score desc 改成 id desc(or asc)
params.set("sort", "score desc");
// 返回信息 * 为全部 这里是全部加上score，如果不加下面就不能使用score
params.set("fl", "*,score");
try {
QueryResponse response = server.query(params);
SolrDocumentList list = response.getResults();
for (int i = 0; i < list.size(); i++) {
fail(list.get(i));
}
} catch (SolrServerException e) {
e.printStackTrace();
}
}

//10、 其他和Server有关方法
/**
* <b>function:</b> 其他server相关方法测试
* @author hoojo
* @createDate 2011-10-21 上午10:02:03
*/
@Test
public void otherMethod() {
fail(server.getBinder());
try {
fail(server.optimize());//合并索引文件，可以优化索引、提供性能，但需要一定的时间
fail(server.ping());//ping服务器是否连接成功
BiSearchBaoLiao index = new BiSearchBaoLiao();
index.setId(4l);
index.setUserid(21l);
index.setUsername("add bean index");
index.setProdname("添加Index Bean到索引库");
UpdateResponse response = server.addBean(index);
fail("response: " + response);
queryAll();
//回滚掉之前的操作，rollback addBean operation
fail("rollback: " + server.rollback());
//提交操作，提交后无法回滚之前操作；发现addBean没有成功添加索引
fail("commit: " + server.commit());
queryAll();
} catch (SolrServerException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
//11、 文档查询
/**
* <b>function:</b> query 基本用法测试
* @author hoojo
* @createDate 2011-10-20 下午04:44:28
*/
@Test
public void queryCase() {
//AND 并且
SolrQuery params = new SolrQuery("name:apple AND manu:inc");
//OR 或者
params.setQuery("name:apple OR manu:apache");
//空格 等同于 OR
params.setQuery("name:server manu:dell");
//params.setQuery("name:solr - manu:inc");
//params.setQuery("name:server + manu:dell");
//查询name包含solr apple
params.setQuery("name:solr,apple");
//manu不包含inc
params.setQuery("name:solr,apple NOT manu:inc");
//50 <= price <= 200
params.setQuery("price:[50 TO 200]");
params.setQuery("popularity:[5 TO 6]");
//params.setQuery("price:[50 TO 200] - popularity:[5 TO 6]");
//params.setQuery("price:[50 TO 200] + popularity:[5 TO 6]");
//50 <= price <= 200 AND 5 <= popularity <= 6
params.setQuery("price:[50 TO 200] AND popularity:[5 TO 6]");
params.setQuery("price:[50 TO 200] OR popularity:[5 TO 6]");
//过滤器查询，可以提高性能 filter 类似多个条件组合，如and
//params.addFilterQuery("id:VA902B");
//params.addFilterQuery("price:[50 TO 200]");
//params.addFilterQuery("popularity:[* TO 5]");
//params.addFilterQuery("weight:*");
//0 < popularity < 6  没有等于
//params.addFilterQuery("popularity:{0 TO 6}");
//排序
params.addSortField("id", ORDER.asc);
//分页：start开始页，rows每页显示记录条数
//params.add("start", "0");
//params.add("rows", "200");
//params.setStart(0);
//params.setRows(200);
//设置高亮
params.setHighlight(true); // 开启高亮组件
params.addHighlightField("name");// 高亮字段
params.setHighlightSimplePre("<font color='red'>");//标记，高亮关键字前缀
params.setHighlightSimplePost("</font>");//后缀
params.setHighlightSnippets(1);//结果分片数，默认为1
params.setHighlightFragsize(1000);//每个分片的最大长度，默认为100
//分片信息
params.setFacet(true)
.setFacetMinCount(1)
.setFacetLimit(5)//段
.addFacetField("name")//分片字段
.addFacetField("inStock");
//params.setQueryType("");
try {
QueryResponse response = server.query(params);
/*List<Index> indexs = response.getBeans(Index.class);
for (int i = 0; i < indexs.size(); i++) {
fail(indexs.get(i));
}*/
//输出查询结果集
SolrDocumentList list = response.getResults();
fail("query result nums: " + list.getNumFound());
for (int i = 0; i < list.size(); i++) {
fail(list.get(i));
}
//输出分片信息
List<FacetField> facets = response.getFacetFields();
for (FacetField facet : facets) {
fail(facet);
List<Count> facetCounts = facet.getValues();
for (FacetField.Count count : facetCounts) {
System.out.println(count.getName() + ": " + count.getCount());
}
}
} catch (SolrServerException e) {
e.printStackTrace();
}
}
//12、 分片查询、统计
/**
* <b>function:</b> 分片查询， 可以统计关键字及出现的次数、或是做自动补全提示
* @author hoojo
* @createDate 2011-10-20 下午04:54:25
*/
@Test
public void facetQueryCase() {
SolrQuery params = new SolrQuery("*:*");
//排序
params.addSortField("id", ORDER.asc);
params.setStart(0);
params.setRows(200);
//Facet为solr中的层次分类查询
//分片信息
params.setFacet(true)
.setQuery("*:*")
.setFacetMinCount(1)
.setFacetLimit(5)//段
//.setFacetPrefix("electronics", "cat")
.setFacetPrefix("cor")//查询manu、name中关键字前缀是cor的
.addFacetField("manu")
.addFacetField("name");//分片字段
try {
QueryResponse response = server.query(params);
//输出查询结果集
SolrDocumentList list = response.getResults();
fail("Query result nums: " + list.getNumFound());
for (int i = 0; i < list.size(); i++) {
fail(list.get(i));
}
fail("All facet filed result: ");
//输出分片信息
List<FacetField> facets = response.getFacetFields();
for (FacetField facet : facets) {
fail(facet);
List<Count> facetCounts = facet.getValues();
for (FacetField.Count count : facetCounts) {
//关键字 - 出现次数
fail(count.getName() + ": " + count.getCount());
}
}
fail("Search facet [name] filed result: ");
//输出分片信息
FacetField facetField = response.getFacetField("name");
List<Count> facetFields = facetField.getValues();
for (Count count : facetFields) {
//关键字 - 出现次数
fail(count.getName() + ": " + count.getCount());
}
} catch (SolrServerException e) {
e.printStackTrace();
}
}
//分片查询在某些统计关键字的时候还是很有用的，可以统计关键字出现的次数，可以通过统计的关键字来搜索相关文档的信息。

/**
* <b>function:</b> 创建SolrInputDocument
* @author hoojo
* @createDate 2011-10-21 下午03:38:20
*/
@Test
public void createDoc() {
SolrInputDocument doc = new SolrInputDocument();
doc.addField("id", System.currentTimeMillis());
doc.addField("name", "SolrInputDocument");
doc.addField("age", 22, 2.0f);
doc.addField("like", new String[] { "music", "book", "sport" });
doc.put("address", new SolrInputField("guangzhou"));
doc.setField("sex", "man");
doc.setField("remark", "china people", 2.0f);
fail(doc);
}
/**
* <b>function:</b> 利用DocumentObjectBinder对象将SolrInputDocument 和 User对象相互转换
* @author hoojo
* @createDate 2011-10-21 下午03:38:40
*/
@Test
public void docAndBean4Binder() {
SolrDocument doc = new SolrDocument();
doc.addField("id", 456);
doc.addField("name", "SolrInputDocument");
doc.addField("likes", new String[] { "music", "book", "sport" });
doc.put("address", "guangzhou");
doc.setField("sex", "man");
doc.setField("remark", "china people");
DocumentObjectBinder binder = new DocumentObjectBinder();
BiSearchBaoLiao user = new BiSearchBaoLiao();
user.setId(222l);
user.setUsername("JavaBean");
//user.setLike(new String[] { "music", "book", "sport" });
user.setProdname("guangdong");
fail(doc);
// User ->> SolrInputDocument
fail(binder.toSolrInputDocument(user));
// SolrDocument ->> User
fail(binder.getBean(User.class, doc));
SolrDocumentList list = new SolrDocumentList();
list.add(doc);
list.add(doc);
//SolrDocumentList ->> List
fail(binder.getBeans(User.class, list));
}
/**
* <b>function:</b> SolrInputDocument的相关方法
* @author hoojo
* @createDate 2011-10-21 下午03:44:30
*/
@Test
public void docMethod() {
SolrInputDocument doc = new SolrInputDocument();
doc.addField("id", System.currentTimeMillis());
doc.addField("name", "SolrInputDocument");
doc.addField("age", 23, 1.0f);
doc.addField("age", 22, 2.0f);
doc.addField("age", 24, 0f);
fail(doc.entrySet());
fail(doc.get("age"));
//排名有用，类似百度竞价排名
doc.setDocumentBoost(2.0f);
fail(doc.getDocumentBoost());
fail(doc.getField("name"));
fail(doc.getFieldNames());//keys
fail(doc.getFieldValues("age"));
fail(doc.getFieldValues("id"));
fail(doc.values());
}
/**
* 自动补全功能
* @param q
* @param limit
* @return
*/
private List<Term> query(String q, int limit) {  
List<Term> items = null;  
SolrQuery query = new SolrQuery();  
query.addTermsField("spell");  
query.setTerms(true);  
query.setTermsLimit(limit);  
query.setTermsLower(q);  
query.setTermsPrefix(q);  
query.setQueryType("/terms");  
try {  
QueryResponse qr = server.query(query);  
TermsResponse resp = qr.getTermsResponse();  
items = resp.getTerms("spell");  
} catch (SolrServerException e) {  
items = null;  
}  
return items;  
}
public void  spell(){
List<Term> list = new ArrayList<Term>();  
QueryResponse queryResponse = new QueryResponse();  
SolrQuery query = new SolrQuery();  
// fl=id,name&rows=0&q=*:*&facet=true&facet.field=searchText&facet.  
// mincount=1&facet.prefix=sony  
//facet=true&rows=0&fl=id%2Cname&facet.prefix=sony&facet.field=searchText  
try {  
query.setFacet(true);  
query.setRows(0);  
query.setQuery("*:*");  
query.setFacetPrefix("sony");  
query.addFacetField("searchText");  
System.out.println(query.toString());  
queryResponse =solrServer.query(query, METHOD.POST);  
} catch (Exception e) {  
// TODO: handle exception  
e.printStackTrace();  
}  
}
}