Solr 查询,索引

环境
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();  
        }  
    }
}