solr配置学习



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


Solr的安装和配置

Java代码  

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

首先 安装 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 中启动

Java代码  

1. 一般下载solr都自带 jetty serlvet 服务器,可以直接使用启动.  
2.   
3. cd E:\solr\apache-solr-3.6.2\example  
4.   
5. java -jar start.jar   //这样就可以启动了  
6.   
7. http://localhost:8080/solr/admin   只要看到 solr的控制台页面 solr 就成功 启动了  
8.   
9.   
10. 有关 jetyy 的 端口配置  在  E:\solr\apache-solr-3.6.2\example\etc  这个目录下的 jetty.xml  可以修改端口   

一般下载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中的启动

Java代码  

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

//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

Java代码  

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

//使用  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 的两个主要配置文件

Java代码  

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

E:\solr\apache-solr-3.6.2\example\solr\conf

schema.xml : 是索引的schema ,包含了域的定义 和相关 analyzer链  还有solr中支持的一些 基本类型 以及  对应我们 javabean 中的一些  field  fieldtype  等 

solrconfig.xml: 该文件是 solr的主配置文件,

mmseg4j中文分词的配置

Xml代码  

1. 1) 下载分词器：http://code.google.com/p/mmseg4j/  
2. 2) 下载词库：http://code.google.com/p/mmseg4j/downloads/detail?name=data.zip&can=2&q=  
3.   
4. 3) 加入 :mmseg4j 目录下的 dist 中的jar  到  C:\Tomcat 6.0\webapps\solr\web-inf\lib\   
5.   
6. 4) 在E:\solr\apache-solr-3.6.2\example\solr\ 下 建立dic 目录用户存放分词目录 容纳然后见下载 mmseg4j的分词库 中的  chars.dic units.dic words.dic words-my.dic 放入到 dic 目录  
7.   
8. 5) 修改E:\solr\apache-solr-3.6.2\example\solr\conf\ schema.xml 加入 mmseg4j的配置   
9.  用户 替换  solr中默认的 "text" "fieldtype"   
10. 在 <typs> 中添加  需要注意的是 dicPath 的值 是我们刚刚建立的 dic 目录  
11.   
12. <fieldType name="textComplex" class="solr.TextField" positionIncrementGap="100" >    
13.         <analyzer>    
14.             <tokenizer class="com.chenlb.mmseg4j.solr.MMSegTokenizerFactory" mode="complex" dicPath="dic"/>    
15.             <filter class="solr.LowerCaseFilterFactory"/>    
16.         </analyzer>    
17.     </fieldType>    
18.     <fieldType name="textMaxWord" class="solr.TextField" positionIncrementGap="100" >    
19.         <analyzer>    
20.             <tokenizer class="com.chenlb.mmseg4j.solr.MMSegTokenizerFactory" mode="max-word" dicPath="dic"/>    
21.             <filter class="solr.LowerCaseFilterFactory"/>    
22.         </analyzer>    
23.     </fieldType>    
24.   
25.     <fieldType name="textSimple" class="solr.TextField" positionIncrementGap="100" >    
26.         <analyzer>    
27.             <tokenizer class="com.chenlb.mmseg4j.solr.MMSegTokenizerFactory" mode="simple" dicPath="dic"/>    
28.             <filter class="solr.LowerCaseFilterFactory"/>    
29.         </analyzer>    
30.     </fieldType>    
31.   
32.   
33. 然后在 <fields>中 添加    
34.   
35. <!-- mmseg4j fields -->  
36.     <field name="simple" type="textSimple" indexed="true" stored="true" multiValued="true"/>    
37.     <field name="complex" type="textComplex" indexed="true" stored="true" multiValued="true"/>    
38.     <field name="text" type="textMaxWord" indexed="true" stored="true" multiValued="true"/>   
39.   
40. 然后在</schema> 里面添加    
41.   
42. <!-- mmseg4j coypField-->  
43. <copyField source="text" dest="simple" />    
44. <copyField source="text" dest="complex" />   
45.   
46. 配置好后 启动服务    
47.   
48. 访问  
49. http://192.168.10.85:18080/solr/admin/analysis.jsp 就可以看到 mmseg4j的分词效果,在 filed拉下中选择  name 也就是我们配置的 filed 类型  
50.  输入一句话  ,然后点击  analyzer 就可以看到效果了  
51.   
52. 如果要是外置程序也能够利用 这个 分词来更新索引 需要添加这个配置   
53. 在 solrconfig.xml：   
54.   
55. <requesthandler name="/mmseg4j" class="com.chenlb.mmseg4j.solr.MMseg4jHandler"><lst name="defaults">  
56.   <str name="dicPath">  
57.    <str name="dicPath"> dic </str>  
58.   </str>  
59.  </lst>   
60. </requesthandler>  

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 中文分词 的使用个

Xml代码  

1. 和上面的步骤类似  
2. 2.1 下载地址   
3.   
4. GoogleCode 开源项目 ：http://code.google.com/p/ik-analyzer/   
5.   
6. GoogleCode  下载：http://code.google.com/p/ik-analyzer/downloads/list   
7.   
8. 加入 IKAnalyzer的jar 到 web-inf/lib 下  
9.   
10. 然后 修改  schema.xml文件 加入 fieldtype  
11.   
12. <!-- IK Analyzer types-->  
13.      <fieldType name="text_ik" class="solr.TextField">  
14.         <analyzer class="org.wltea.analyzer.lucene.IKAnalyzer"/>  
15.         <analyzer type="index">  
16.              <tokenizer class="org.wltea.analyzer.solr.IKTokenizerFactory" isMaxWordLength="false"/>  
17.              <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt" />  
18.              <filtr class="solr.WordDelimiterFilterFactory"   
19.               generateWordParts="1"  
20.               generateNumberPats="1"  
21.               catenateWords="1"  
22.               catenateNumbers="1"  
23.               catenateAll="0"  
24.               splitOnCaseChange="1"/>  
25.              <filter class="solr.LowerCaseFilterFactory"/>  
26.              <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>  
27.              <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>  
28.         </analyzer>  
29.   
30.         <analyzer type="query">  
31.            <tokenizer class="org.wltea.analyzer.solr.IKTokenizerFactory"  
32.            isMaxWordLength="false"/>  
33.             <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>  
34.              <filtr class="solr.WordDelimiterFilterFactory"   
35.               generateWordParts="1"  
36.               generateNumberPats="1"  
37.               catenateWords="1"  
38.               catenateNumbers="1"  
39.               catenateAll="0"  
40.               splitOnCaseChange="1"/>  
41.              <filter class="solr.LowerCaseFilterFactory"/>  
42.              <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>  
43.              <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>  
44.         </analyzer>  
45.      </fieldType>  
46.   
47.   
48. 加入 field  
49.     <!--IK Analyzer filed-->  
50.    <field name="text" type="text_ik" indexed="true" stored="false" multiValued="true" required="true"/>  
51.   
52.   
53. 然后在c:\tomcat6.0\webapps\solr\WEB-INF\classes 中加入 IKAnalyzer.cfg.xml 和 扩展字典 和 停止 字典 文件   
54.   
55. 然后访问   
56. http://localhost:8080/solr/admin/analysis.jsp  
57. 操作类是于 mmseg4j   

和上面的步骤类似
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 的从不同的文件中对数据进行 索引的添加

Java代码  

1. 1.不用说首先加入 jar 到  web-inf\lib中啦   
2.   
3. 2.然后在  E:\solr\apache-solr-3.6.2\example\solr\conf\db\data-config.xml 中加入 与数据的连接配置和 field映射   
4. <dataConfig>  
5.     <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"/>  
6.     <!--  
7.     <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"/>  
8.       
9.       
10.     -->  
11.     <document>  
12.         <entity dataSource="ds-1" name="bi_baoliao"   
13.         query="select id,userid,username,prodname,tags,createtime from bi_baoliao"  
14.         deltaQuery="select id from bi_baoliao where createtime > '${dataimporter.last_index_time}'">  
15.   
16.             <field column="Id" name="id" />  
17.             <field column="USERID"  name="userid" />  
18.             <field column="USERNAME"  name="username"/>  
19.             <field column="PRODNAME"  name="prodname"/>  
20.             <field column="TAGS"  name="tags"/>  
21.             <field column="CREATETIME"  name="createtime" dateTimeFormat="yyyy-MM-dd HH:mm:ss"/>  
22.               
23.         </entity>  
24.     </document>  
25. </dataConfig>  
26.   
27.   
28. 然后 在 solrconfig.xml中添加   
29.   
30.   <!--DataImportHandler -->  
31.     <requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler">  
32.     <lst name="defaults">  
33.       <str name="config">./db/data-config.xml</str>  
34.     </lst>  
35.   </requestHandler>  
36.   
37.   
38. 然后启动 服务    
39. 然后使用 http请求 创建 全量索引   增量索引  
40. http://localhost:8080/solr/dataimport?command=full-import 全量索引   
41.   
42. 对应 data-config.xml中的 entity 中  query sql语句    
43.   
44. http://localhost:8080/solr/dataimport?command=delta-import  增量索引  
45. 对应 data-config.xml中的 entity 中  deltaQuery   sql语句    
46.   
47. 还有一些 command 的参数  
48. full-import : "完全导入"  
49. clean : (default 'true'). 决定在建立索引之前，删除以前的索引。  
50. commit: (default 'true'). 决定这个操作之后是否要commit  
51. optimize: (default 'true'). 决定这个操作之后是否要优化。  
52. debug : (default false). 工作在debug模式下。  
53. delta-import : 当遇到一些增量的输入，  
54. status : 想要知道命令执行的状态 ,  
55. reload-config : 如果data-config.xml已经改变，你不希望重启solr，而要重新加载配置时，运行一下的命令http://:/solr/dataimport?command=reload-config  
56. abort : 你可以通过访问 url http://:/solr/dataimport?command=abort 来终止一个在运行的操作  
57.   
58. 还可以在 这个配置文件中 配置  json   xml  rss 不同类型数据源的导入    

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

Java代码  

1. 常用  
2. q - 查询字符串，必须的。  
3. fl - 指定返回那些字段内容，用逗号或空格分隔多个。  
4. start - 返回第一条记录在完整找到结果中的偏移位置，0开始，一般分页用。  
5. rows - 指定返回结果最多有多少条记录，配合start来实现分页。  
6. sort - 排序，格式：sort=<field name>+<desc|asc>[,<field name>+<desc|asc>]… 。示例：（inStock desc, price asc）表示先 “inStock” 降序, 再 “price” 升序，默认是相关性降序。  
7. wt - (writer type)指定输出格式，可以有 xml, json, php, phps, 后面 solr 1.3增加的，要用通知我们，因为默认没有打开。  
8. fq - （filter query）过虑查询，作用：在q查询符合结果中同时是fq查询符合的，例如：q=mm&fq=date_time:[20081001 TO 20091031]，找关键字mm，并且date_time是20081001到20091031之间的。官方文档：http://wiki.apache.org/solr/CommonQueryParameters  
9. 不常用  
10. q.op - 覆盖schema.xml的defaultOperator（有空格时用"AND"还是用"OR"操作逻辑），一般默认指定  
11. df - 默认的查询字段，一般默认指定  
12. qt - （query type）指定那个类型来处理查询请求，一般不用指定，默认是standard。  
13. 其它  
14. indent - 返回的结果是否缩进，默认关闭，用 indent=true|on 开启，一般调试json,php,phps,ruby输出才有必要用这个参数。  
15. version - 查询语法的版本，建议不使用它，由服务器指定默认值。  
16. [Solr的检索运算符]  
17.  “:” 指定字段查指定值，如返回所有值*:*²  
18.  “?”²表示单个任意字符的通配  
19.  “*” 表示多个任意字符的通配（不能在检索的项开始使用*或者?符号）²  
20.  “~”²表示模糊检索，如检索拼写类似于”roam”的项这样写：roam~将找到形如foam和roams的单词；roam~0.8，检索返回相似度在0.8以上的记录。  
21. ²邻近检索，如检索相隔10个单词的”apache”和”jakarta”，”jakarta apache”~10  
22.  “^”²控制相关度检索，如检索jakarta apache，同时希望去让”jakarta”的相关度更加好，那么在其后加上”^”符号和增量值，即jakarta^4 apache  
23.  布尔操作符AND、||²  
24.  布尔操作符OR、²&&  
25.  布尔操作符NOT、!、-²（排除操作符不能单独与项使用构成查询）  
26.  “+” 存在操作符，要求符号”+”后的项必须在文档相应的域中存在²  
27.  ( ) 用于构成子查询²  
28. ² [] 包含范围检索，如检索某时间段记录，包含头尾，date:[200707 TO 200710]  
29.  {}²不包含范围检索，如检索某时间段记录，不包含头尾  
30. date:{200707 TO 200710}  
31.  " 转义操作符，特殊字符包括+ -² && || ! ( ) { } [ ] ^ ” ~ * ? : "  
32.   
33.   
34. Solr 删除全部索引：http://localhost:8080/solr/update/?stream.body=<delete><query>*:*</query></delete>&stream.contentType=text/xml;charset=utf-8&commit=true  
35.   
36.   
37. Solr 查询索引记录：http://localhost:8080/solr/select/?q=%E5%85%A8%E6%96%87&version=2.2&start=0&rows=10&indent=on  
38.   
39. 日期查询  
40. Approvetime:[NOW/DAY-1DAY TO NOW/DAY]  
41. Approvetime:[NOW-1DAY TO NOW]  
42. Approvetime:[NOW-7DAY TO NOW]  
43.   
44. Approvetime:[NOW-1MONTH TO NOW]  
45.   
46. createdate:[1995-12-31\T23:59:59.999\Z TO 2007-03-06\T00:00:00\Z]  

常用
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

Java代码  

1. //加入 solr中的jar  在 下载的 solr中 dist中有个  solrj    
2. apache-solr-core-3.6.2.jar  
3. apache-solr-dataimporthandler-3.6.2.jar  
4. apache-solr-solrj-3.6.2.jar  
5. bjdata-common.jar  
6. bjdata-util.jar  
7. commons-codec-1.6.jar  
8. commons-httpclient-3.1.jar  
9. commons-io-2.1.jar  
10. geronimo-stax-api_1.0_spec-1.0.1.jar  
11. IKAnalyzer2012_u6.jar  
12. IKAnalyzer3.2.8.jar  
13. jcl-over-slf4j-1.6.1.jar  
14. log4j-1.2.14.jar  
15. ojdbc6.jar  
16. pinyin4j-2.5.0.jar  
17. poi-3.7-20101029.jar  
18. slf4j-api-1.6.1.jar  
19. slf4j-log4j12-1.7.5.jar  
20. wstx-asl-3.2.7.jar  

//加入 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

//各种测试案例

Java代码  

1. package com.sh.test;  
2.   
3. import java.io.IOException;  
4. import java.util.ArrayList;  
5. import java.util.Collection;  
6. import java.util.List;  
7.   
8. import javax.xml.registry.infomodel.User;  
9.   
10. import org.apache.solr.client.solrj.SolrQuery;  
11. import org.apache.solr.client.solrj.SolrQuery.ORDER;  
12. import org.apache.solr.client.solrj.SolrRequest.METHOD;  
13. import org.apache.solr.client.solrj.SolrServer;  
14. import org.apache.solr.client.solrj.SolrServerException;  
15. import org.apache.solr.client.solrj.beans.DocumentObjectBinder;  
16. import org.apache.solr.client.solrj.embedded.EmbeddedSolrServer;  
17. import org.apache.solr.client.solrj.impl.HttpSolrServer;  
18. import org.apache.solr.client.solrj.response.FacetField;  
19. import org.apache.solr.client.solrj.response.FacetField.Count;  
20. import org.apache.solr.client.solrj.response.QueryResponse;  
21. import org.apache.solr.client.solrj.response.TermsResponse;  
22. import org.apache.solr.client.solrj.response.TermsResponse.Term;  
23. import org.apache.solr.client.solrj.response.UpdateResponse;  
24. import org.apache.solr.common.SolrDocument;  
25. import org.apache.solr.common.SolrDocumentList;  
26. import org.apache.solr.common.SolrInputDocument;  
27. import org.apache.solr.common.SolrInputField;  
28. import org.apache.solr.common.params.ModifiableSolrParams;  
29. import org.apache.solr.common.params.SolrParams;  
30. import org.junit.After;  
31. import org.junit.Before;  
32. import org.junit.Test;  
33.   
34. import com.sh.baoliao.model.BiSearchBaoLiao;  
35.   
36. public class ServerTest {  
37.   
38.     private SolrServer server;  //有 HttpSolrServer EmbeddedSolrServer 两个  
39.       
40.     private static final String DEFAULT_URL="http://localhost:8983/solr";  
41.     private HttpSolrServer solrServer;  //CommonsHttpSolrServer solrServer; 过时  
42.       
43.     private EmbeddedSolrServer esolrServer;  
44.     @Before  
45.     public void init(){  
46.         try {  
47.             server =new HttpSolrServer(DEFAULT_URL);  
48.               
49.             solrServer=new HttpSolrServer(DEFAULT_URL);  
50.               
51.             //Server的有关配置选项参数   
52.             solrServer.setSoTimeout(1000); //socket read timeout  
53.             solrServer.setConnectionTimeout(100);  
54.             solrServer.setDefaultMaxConnectionsPerHost(100);  
55.             solrServer.setMaxTotalConnections(100);  
56.             solrServer.setFollowRedirects(false); // defaults to false   
57.             solrServer.setAllowCompression(true);   
58.             //solr 1.2 需要显示设置返回的类型  
59.             //solrServer.setParser(new XMLResponseParser());  
60.             //solrServer.setRequestWriter(new BinaryRequestWriter());  
61.               
62.         } catch (Exception e) {  
63.             e.printStackTrace();  
64.         }  
65.     }  
66.       
67.     @After  
68.     public void destory(){  
69.         server=null;  
70.         solrServer=null;  
71.         System.runFinalization();  
72.         System.gc();  
73.     }  
74.       
75.     public final void fail(Object o){  
76.         System.out.println(o);  
77.     }  
78.       
79.     /** 
80.      * 测试连接创建serve对象成功 
81.      */  
82.     @Test    
83.     public void test() {  
84.         //测试前先删除所有索引  
85.         try {  
86.             server.deleteByQuery( "*:*" );  
87.         } catch (SolrServerException e) {  
88.             // TODO Auto-generated catch block  
89.             e.printStackTrace();  
90.         } catch (IOException e) {  
91.             // TODO Auto-generated catch block  
92.             e.printStackTrace();  
93.         }  
94.         fail(server);  
95.         fail(solrServer);  
96.     }  
97.       
98.     /** 
99.      * 根据query参数查询索引 
100.      * @param query 
101.      */  
102.     @Test  
103.     public void query(String query){  
104.         if(query==null)  
105.             query="id:373";  
106.           
107.         SolrParams params=new SolrQuery(query);  
108.         try {  
109.             QueryResponse response=server.query(params);  
110.               
111.             SolrDocumentList list=response.getResults();  
112.               
113.             for (int i = 0; i < list.size(); i++) {  
114.                 fail(list.get(i));  
115.             }  
116.         } catch (SolrServerException e) {  
117.             // TODO Auto-generated catch block  
118.             e.printStackTrace();  
119.         }  
120.     }  
121.       
122.     //4、 利用SolrJ完成Index Document的添加操作  
123.     @Test  
124.     public void addDoc() {  
125.         //创建doc文档  
126.         SolrInputDocument doc = new SolrInputDocument();  
127.         doc.addField("id", 1);  
128.         doc.addField("name", "Solr Input Document");  
129.         doc.addField("manu", "this is SolrInputDocument content");  
130.           
131.         try {  
132.             //添加一个doc文档  
133.             UpdateResponse response = server.add(doc);  
134.             fail(server.commit());//commit后才保存到索引库  
135.             fail(response);  
136.             fail("query time：" + response.getQTime());  
137.             fail("Elapsed Time：" + response.getElapsedTime());  
138.             fail("status：" + response.getStatus());  
139.         } catch (SolrServerException e) {  
140.             e.printStackTrace();  
141.         } catch (IOException e) {  
142.             e.printStackTrace();  
143.         }  
144.         query("name:solr");  
145.     }  
146.       
147.     //5、 利用SolrJ添加多个Document，即添加文档集合  
148.     /** 
149.      * <b>function:</b> 添加docs文档集合 
150.      * @author hoojo 
151.      * @createDate 2011-10-21 上午09:55:01 
152.      */  
153.     @Test  
154.     public void addDocs() {  
155.         Collection<SolrInputDocument> docs = new ArrayList<SolrInputDocument>();  
156.         SolrInputDocument doc = new SolrInputDocument();  
157.         doc.addField("id", 2);  
158.         doc.addField("name", "Solr Input Documents 1");  
159.         doc.addField("manu", "this is SolrInputDocuments 1 content");  
160.           
161.         docs.add(doc);  
162.           
163.         doc = new SolrInputDocument();  
164.         doc.addField("id", 3);  
165.         doc.addField("name", "Solr Input Documents 2");  
166.         doc.addField("manu", "this is SolrInputDocuments 3 content");  
167.           
168.         docs.add(doc);  
169.           
170.         try {  
171.             //add docs  
172.             UpdateResponse response = server.add(docs);  
173.             //commit后才保存到索引库  
174.             fail(server.commit());  
175.             fail(response);  
176.         } catch (SolrServerException e) {  
177.             e.printStackTrace();  
178.         } catch (IOException e) {  
179.             e.printStackTrace();  
180.         }  
181.         query("solr");  
182.     }  
183.       
184.     //7、 添加Bean集合  
185.     @Test  
186.     public void addBean() {  
187.         //Index需要添加相关的Annotation注解，便于告诉solr哪些属性参与到index中  
188.         BiSearchBaoLiao index = new BiSearchBaoLiao();  
189.         index.setId(4l);  
190.         index.setUserid(21l);  
191.         index.setUsername("add bean index");  
192.         index.setProdname("添加Index Bean到索引库");  
193.           
194.         try {  
195.             //添加Index Bean到索引库  
196.             UpdateResponse response = server.addBean(index);  
197.             fail(server.commit());//commit后才保存到索引库  
198.             fail(response);  
199.         } catch (SolrServerException e) {  
200.             e.printStackTrace();  
201.         } catch (IOException e) {  
202.             e.printStackTrace();  
203.         }  
204.         queryAll();  
205.     }  
206.       
207.     //8、 删除索引Document  
208.   
209.     /** 
210.      * <b>function:</b> 删除索引操作 
211.      * @author hoojo 
212.      * @createDate 2011-10-21 上午10:04:28 
213.      */  
214.     @Test  
215.     public void remove() {  
216.         try {  
217.             //删除id为1的索引  
218.             server.deleteById("1");  
219.             server.commit();  
220.             query("id:1");  
221.               
222.             //根据id集合，删除多个索引  
223.             List<String> ids = new ArrayList<String>();  
224.             ids.add("2");  
225.             ids.add("3");  
226.             server.deleteById(ids);  
227.             server.commit(true, true);  
228.             query("id:3 id:2");  
229.               
230.             //删除查询到的索引信息  
231.             server.deleteByQuery("id:4 id:6");  
232.             server.commit(true, true);  
233.             queryAll();  
234.               
235.         } catch (SolrServerException e) {  
236.             e.printStackTrace();  
237.         } catch (IOException e) {  
238.             e.printStackTrace();  
239.         }  
240.     }  
241.       
242.     //9、 查询索引  
243.     @Test  
244.     public void queryAll() {  
245.         ModifiableSolrParams params = new ModifiableSolrParams();  
246.         // 查询关键词，*:*代表所有属性、所有值，即所有index  
247.         params.set("q", "*:*");  
248.         // 分页，start=0就是从0开始，，rows=5当前返回5条记录，第二页就是变化start这个值为5就可以了。  
249.         params.set("start", 0);  
250.         params.set("rows", Integer.MAX_VALUE);  
251.           
252.         // 排序，，如果按照id 排序，，那么将score desc 改成 id desc(or asc)  
253.         params.set("sort", "score desc");  
254.        
255.         // 返回信息 * 为全部 这里是全部加上score，如果不加下面就不能使用score  
256.         params.set("fl", "*,score");  
257.           
258.         try {  
259.             QueryResponse response = server.query(params);  
260.               
261.             SolrDocumentList list = response.getResults();  
262.             for (int i = 0; i < list.size(); i++) {  
263.                 fail(list.get(i));  
264.             }  
265.         } catch (SolrServerException e) {  
266.             e.printStackTrace();  
267.         }  
268.     }  
269.       
270.       
271.     //10、 其他和Server有关方法  
272.     /** 
273.      * <b>function:</b> 其他server相关方法测试 
274.      * @author hoojo 
275.      * @createDate 2011-10-21 上午10:02:03 
276.      */  
277.     @Test  
278.     public void otherMethod() {  
279.         fail(server.getBinder());  
280.         try {  
281.             fail(server.optimize());//合并索引文件，可以优化索引、提供性能，但需要一定的时间  
282.             fail(server.ping());//ping服务器是否连接成功  
283.               
284.             BiSearchBaoLiao index = new BiSearchBaoLiao();  
285.             index.setId(4l);  
286.             index.setUserid(21l);  
287.             index.setUsername("add bean index");  
288.             index.setProdname("添加Index Bean到索引库");  
289.               
290.             UpdateResponse response = server.addBean(index);  
291.             fail("response: " + response);  
292.               
293.             queryAll();  
294.             //回滚掉之前的操作，rollback addBean operation  
295.             fail("rollback: " + server.rollback());  
296.             //提交操作，提交后无法回滚之前操作；发现addBean没有成功添加索引  
297.             fail("commit: " + server.commit());  
298.             queryAll();  
299.         } catch (SolrServerException e) {  
300.             e.printStackTrace();  
301.         } catch (IOException e) {  
302.             e.printStackTrace();  
303.         }  
304.     }  
305.   
306.     //11、 文档查询  
307.   
308.     /** 
309.      * <b>function:</b> query 基本用法测试 
310.      * @author hoojo 
311.      * @createDate 2011-10-20 下午04:44:28 
312.      */  
313.     @Test  
314.     public void queryCase() {  
315.         //AND 并且  
316.         SolrQuery params = new SolrQuery("name:apple AND manu:inc");  
317.           
318.         //OR 或者  
319.         params.setQuery("name:apple OR manu:apache");  
320.         //空格 等同于 OR  
321.         params.setQuery("name:server manu:dell");  
322.           
323.         //params.setQuery("name:solr - manu:inc");  
324.         //params.setQuery("name:server + manu:dell");  
325.           
326.         //查询name包含solr apple  
327.         params.setQuery("name:solr,apple");  
328.         //manu不包含inc  
329.         params.setQuery("name:solr,apple NOT manu:inc");  
330.           
331.         //50 <= price <= 200  
332.         params.setQuery("price:[50 TO 200]");  
333.         params.setQuery("popularity:[5 TO 6]");  
334.         //params.setQuery("price:[50 TO 200] - popularity:[5 TO 6]");  
335.         //params.setQuery("price:[50 TO 200] + popularity:[5 TO 6]");  
336.           
337.         //50 <= price <= 200 AND 5 <= popularity <= 6  
338.         params.setQuery("price:[50 TO 200] AND popularity:[5 TO 6]");  
339.         params.setQuery("price:[50 TO 200] OR popularity:[5 TO 6]");  
340.           
341.         //过滤器查询，可以提高性能 filter 类似多个条件组合，如and  
342.         //params.addFilterQuery("id:VA902B");  
343.         //params.addFilterQuery("price:[50 TO 200]");  
344.         //params.addFilterQuery("popularity:[* TO 5]");  
345.         //params.addFilterQuery("weight:*");  
346.         //0 < popularity < 6  没有等于  
347.         //params.addFilterQuery("popularity:{0 TO 6}");  
348.           
349.         //排序  
350.         params.addSortField("id", ORDER.asc);  
351.           
352.         //分页：start开始页，rows每页显示记录条数  
353.         //params.add("start", "0");  
354.         //params.add("rows", "200");  
355.         //params.setStart(0);  
356.         //params.setRows(200);  
357.           
358.         //设置高亮  
359.         params.setHighlight(true); // 开启高亮组件  
360.         params.addHighlightField("name");// 高亮字段  
361.         params.setHighlightSimplePre("<font color='red'>");//标记，高亮关键字前缀  
362.         params.setHighlightSimplePost("</font>");//后缀  
363.         params.setHighlightSnippets(1);//结果分片数，默认为1  
364.         params.setHighlightFragsize(1000);//每个分片的最大长度，默认为100  
365.        
366.         //分片信息  
367.         params.setFacet(true)  
368.             .setFacetMinCount(1)  
369.             .setFacetLimit(5)//段  
370.             .addFacetField("name")//分片字段  
371.             .addFacetField("inStock");   
372.           
373.         //params.setQueryType("");  
374.           
375.         try {  
376.             QueryResponse response = server.query(params);  
377.               
378.             /*List<Index> indexs = response.getBeans(Index.class); 
379.             for (int i = 0; i < indexs.size(); i++) { 
380.                 fail(indexs.get(i)); 
381.             }*/  
382.               
383.             //输出查询结果集  
384.             SolrDocumentList list = response.getResults();  
385.             fail("query result nums: " + list.getNumFound());  
386.             for (int i = 0; i < list.size(); i++) {  
387.                 fail(list.get(i));  
388.             }  
389.               
390.             //输出分片信息  
391.             List<FacetField> facets = response.getFacetFields();  
392.             for (FacetField facet : facets) {  
393.                 fail(facet);  
394.                 List<Count> facetCounts = facet.getValues();  
395.                 for (FacetField.Count count : facetCounts) {  
396.                     System.out.println(count.getName() + ": " + count.getCount());  
397.                 }  
398.             }  
399.         } catch (SolrServerException e) {  
400.             e.printStackTrace();  
401.         }   
402.     }  
403.       
404.     //12、 分片查询、统计  
405.   
406.     /** 
407.      * <b>function:</b> 分片查询， 可以统计关键字及出现的次数、或是做自动补全提示 
408.      * @author hoojo 
409.      * @createDate 2011-10-20 下午04:54:25 
410.      */  
411.     @Test  
412.     public void facetQueryCase() {  
413.         SolrQuery params = new SolrQuery("*:*");  
414.           
415.         //排序  
416.         params.addSortField("id", ORDER.asc);  
417.           
418.         params.setStart(0);  
419.         params.setRows(200);  
420.        
421.         //Facet为solr中的层次分类查询  
422.         //分片信息  
423.         params.setFacet(true)  
424.             .setQuery("*:*")  
425.             .setFacetMinCount(1)  
426.             .setFacetLimit(5)//段  
427.             //.setFacetPrefix("electronics", "cat")  
428.             .setFacetPrefix("cor")//查询manu、name中关键字前缀是cor的  
429.             .addFacetField("manu")  
430.             .addFacetField("name");//分片字段  
431.        
432.         try {  
433.             QueryResponse response = server.query(params);  
434.               
435.             //输出查询结果集  
436.             SolrDocumentList list = response.getResults();  
437.             fail("Query result nums: " + list.getNumFound());  
438.               
439.             for (int i = 0; i < list.size(); i++) {  
440.                 fail(list.get(i));  
441.             }  
442.               
443.             fail("All facet filed result: ");  
444.             //输出分片信息  
445.             List<FacetField> facets = response.getFacetFields();  
446.             for (FacetField facet : facets) {  
447.                 fail(facet);  
448.                 List<Count> facetCounts = facet.getValues();  
449.                 for (FacetField.Count count : facetCounts) {  
450.                     //关键字 - 出现次数  
451.                     fail(count.getName() + ": " + count.getCount());  
452.                 }  
453.             }  
454.               
455.             fail("Search facet [name] filed result: ");  
456.             //输出分片信息  
457.             FacetField facetField = response.getFacetField("name");  
458.             List<Count> facetFields = facetField.getValues();  
459.             for (Count count : facetFields) {  
460.                 //关键字 - 出现次数  
461.                 fail(count.getName() + ": " + count.getCount());  
462.             }  
463.         } catch (SolrServerException e) {  
464.             e.printStackTrace();  
465.         }   
466.     }  
467.     //分片查询在某些统计关键字的时候还是很有用的，可以统计关键字出现的次数，可以通过统计的关键字来搜索相关文档的信息。  
468.       
469.       
470.   
471.     /** 
472.      * <b>function:</b> 创建SolrInputDocument 
473.      * @author hoojo 
474.      * @createDate 2011-10-21 下午03:38:20 
475.      */  
476.     @Test  
477.     public void createDoc() {  
478.         SolrInputDocument doc = new SolrInputDocument();  
479.         doc.addField("id", System.currentTimeMillis());  
480.         doc.addField("name", "SolrInputDocument");  
481.         doc.addField("age", 22, 2.0f);  
482.           
483.         doc.addField("like", new String[] { "music", "book", "sport" });  
484.           
485.         doc.put("address", new SolrInputField("guangzhou"));  
486.           
487.         doc.setField("sex", "man");  
488.         doc.setField("remark", "china people", 2.0f);  
489.           
490.         fail(doc);  
491.     }  
492.       
493.     /** 
494.      * <b>function:</b> 利用DocumentObjectBinder对象将SolrInputDocument 和 User对象相互转换 
495.      * @author hoojo 
496.      * @createDate 2011-10-21 下午03:38:40 
497.      */  
498.     @Test  
499.     public void docAndBean4Binder() {  
500.         SolrDocument doc = new SolrDocument();  
501.         doc.addField("id", 456);  
502.         doc.addField("name", "SolrInputDocument");  
503.           
504.         doc.addField("likes", new String[] { "music", "book", "sport" });  
505.           
506.         doc.put("address", "guangzhou");  
507.           
508.         doc.setField("sex", "man");  
509.         doc.setField("remark", "china people");  
510.           
511.         DocumentObjectBinder binder = new DocumentObjectBinder();  
512.           
513.         BiSearchBaoLiao user = new BiSearchBaoLiao();  
514.         user.setId(222l);  
515.         user.setUsername("JavaBean");  
516.         //user.setLike(new String[] { "music", "book", "sport" });  
517.         user.setProdname("guangdong");  
518.           
519.         fail(doc);  
520.         // User ->> SolrInputDocument  
521.         fail(binder.toSolrInputDocument(user));  
522.         // SolrDocument ->> User  
523.         fail(binder.getBean(User.class, doc));  
524.           
525.         SolrDocumentList list = new SolrDocumentList();  
526.         list.add(doc);  
527.         list.add(doc);  
528.         //SolrDocumentList ->> List  
529.         fail(binder.getBeans(User.class, list));  
530.     }  
531.       
532.     /** 
533.      * <b>function:</b> SolrInputDocument的相关方法 
534.      * @author hoojo 
535.      * @createDate 2011-10-21 下午03:44:30 
536.      */  
537.     @Test  
538.     public void docMethod() {  
539.         SolrInputDocument doc = new SolrInputDocument();  
540.         doc.addField("id", System.currentTimeMillis());  
541.         doc.addField("name", "SolrInputDocument");  
542.         doc.addField("age", 23, 1.0f);  
543.         doc.addField("age", 22, 2.0f);  
544.         doc.addField("age", 24, 0f);  
545.           
546.         fail(doc.entrySet());  
547.         fail(doc.get("age"));  
548.         //排名有用，类似百度竞价排名  
549.         doc.setDocumentBoost(2.0f);  
550.         fail(doc.getDocumentBoost());  
551.         fail(doc.getField("name"));  
552.         fail(doc.getFieldNames());//keys  
553.         fail(doc.getFieldValues("age"));  
554.         fail(doc.getFieldValues("id"));  
555.         fail(doc.values());  
556.     }  
557.       
558.     /** 
559.      * 自动补全功能 
560.      * @param q 
561.      * @param limit 
562.      * @return 
563.      */  
564.     private List<Term> query(String q, int limit) {    
565.          List<Term> items = null;    
566.          SolrQuery query = new SolrQuery();    
567.          query.addTermsField("spell");    
568.          query.setTerms(true);    
569.          query.setTermsLimit(limit);    
570.          query.setTermsLower(q);    
571.          query.setTermsPrefix(q);    
572.          query.setQueryType("/terms");    
573.          try {    
574.              QueryResponse qr = server.query(query);    
575.              TermsResponse resp = qr.getTermsResponse();    
576.              items = resp.getTerms("spell");    
577.          } catch (SolrServerException e) {    
578.             items = null;    
579.          }    
580.          return items;    
581.     }   
582.       
583.     public void  spell(){  
584.         List<Term> list = new ArrayList<Term>();    
585.         QueryResponse queryResponse = new QueryResponse();    
586.         SolrQuery query = new SolrQuery();    
587.         // fl=id,name&rows=0&q=*:*&facet=true&facet.field=searchText&facet.    
588.         // mincount=1&facet.prefix=sony    
589.         //facet=true&rows=0&fl=id%2Cname&facet.prefix=sony&facet.field=searchText    
590.         try {    
591.             query.setFacet(true);    
592.             query.setRows(0);    
593.             query.setQuery("*:*");    
594.             query.setFacetPrefix("sony");    
595.             query.addFacetField("searchText");    
596.             System.out.println(query.toString());    
597.             queryResponse =solrServer.query(query, METHOD.POST);    
598.         } catch (Exception e) {    
599.             // TODO: handle exception    
600.             e.printStackTrace();    
601.         }    
602.     }  
603. }  

转自：http://takeme.iteye.com/blog/1849781。谢谢分享

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