solr企业级搜索

一 。solr简介

    solr是以lucene为内核开发的企业级搜索应用  应用程序可以通过http请求方式来提交索引，查询索引，提供了比lucene更丰富的查询语言，是

一个高性能，高可用环境全文搜索引擎

二 。solr安装配置

     1》下载solr安装包  solr所有版本 （http://archive.apache.org/dist/lucene/solr/） 

           这里下载 solr-5.5.4

     2》安装 解压将solr-5.5.4\server\solr-webapp下的webapp 拷贝到tomcat\webapps目录下 改名为solr 启动tomcat

       直接访问 出现404  找到tomcat/logs/localhost.2017-08-17.log 日志  出现以下异常

[html]  view plain  copy

1. java.lang.NoClassDefFoundError: Failed to initialize Apache Solr: Could not find necessary SLF4j logging jars.   
2. If using Jetty, the SLF4j logging jars need to go in the jetty lib/ext directory. For other containers,   
3. the corresponding directory should be used. For more information, see: http://wiki.apache.org/solr/SolrLogging  
4.     at org.apache.solr.servlet.CheckLoggingConfiguration.check(CheckLoggingConfiguration.java:27)  
5.     at org.apache.solr.servlet.BaseSolrFilter.<clinit>(BaseSolrFilter.java:30)  

      可用看到缺少SLF4j包 应该去 应该去 解压包 /server/lib/ext下找到并拷贝到 tomcat/solr/lib目录下  然后重启

    继续访问 出现以下错误 

[html]  view plain  copy

1. java.lang.NoSuchMethodError: javax.servlet.ServletInputStream.isFinished()Z  
2.     org.apache.solr.servlet.SolrDispatchFilter.consumeInputFully(SolrDispatchFilter.java:284)  
3.     org.apache.solr.servlet.SolrDispatchFilter.doFilter(SolrDispatchFilter.java:274)  
4.     org.apache.solr.servlet.SolrDispatchFilter.doFilter(SolrDispatchFilter.java:208)  

    明显是Servlet版本不一致  tomcat6不支持solr5.54 加大tomcat版本 tomcat7也不支持 换成tomcat8  启动后访问 依然错误：

[html]  view plain  copy

1. org.apache.solr.common.SolrException: Error processing the request. CoreContainer is either not initialized or shutting down.  
2.     org.apache.solr.servlet.SolrDispatchFilter.doFilter(SolrDispatchFilter.java:217)  
3.     org.apache.solr.servlet.SolrDispatchFilter.doFilter(SolrDispatchFilter.java:208)  

   是因为需要配置solrhome和solrhome的配置环境

   3》配置solrhome

     找到 tomcat\solr\WEB-INF\web.xml 编辑  找到以下这段（配置solrhome）  去掉注释 将第二个参数配置为本地任意一个目录即可 

[html]  view plain  copy

1. <env-entry>  
2.    <env-entry-name>solr/home</env-entry-name>  
3.    <env-entry-value>D:\learn\solr-5.5.4\home</env-entry-value>  
4.    <env-entry-type>java.lang.String</env-entry-type>  
5. </env-entry>  

   找到solr解压包/server/solr目录拷贝所有文件到 以上web.xml指定的路径D:\learn\solr-5.5.4\home下 重启tomcat 访问

   http://localhost:8080/solor/index.html  或者 http://localhost:8080/solr/admin.html  

  

   4》配置core（core类似于数据库可以插入多个document（数据库表行）每个document拥有多个 field 数据库的列）

   solrhome下新建一个core目录  比如mycore

   拷贝 solr解压包下\server\solr\configsets\basic_configs到新建目录 mycore中

  进入solr管理网页 点击 core admin 添加该core

 

  点击Add core后 成功后 检查 mycore目录 发现多了 core.properties和data两个资源

 登陆solr管理网站发现 列表中多了mycore

 4》配置文件理解

    core/conf目录下的两个配置文件非常重要 

    managed-schema 主要用于配置 可以提交到该core的所有field定义，field的类型定义，唯一标识符等

    常用配置如下：

[html]  view plain  copy

1. 定义字段 _version_ 类型为long  indexed="true" 会进行分词索引  stored="true"表示存储到磁盘  
2. <field name="_version_" type="long" indexed="true" stored="true"/>  
3. 定义字段 id required="true" 表示所有的document必须添加id字段 multiValued="false" 表示是否是多值字段  
4. <field name="id" type="string" indexed="true" stored="true" required="true" multiValued="false" />   
5. 定义动态字段 所以_i结尾的字段都可以写入到当前的core  
6. <dynamicField name="*_i"  type="int"    indexed="true"  stored="true"/>  
7. 定义唯一标识符的字段  
8. <uniqueKey>id</uniqueKey>  
9. 定义字段类型的别名  
10. <fieldType name="string" class="solr.StrField" sortMissingLast="true" />  

   solrconfig.xml  主要用于配置solor的主要配置信息 比如lucene版本 缓存 数据目录 请求路径映射 等 

[html]  view plain  copy

1. 表示lucene版本  
2. <luceneMatchVersion>5.5.4</luceneMatchVersion>  
3. 表示数据目录 默认是data目录  
4. <dataDir>${solr.data.dir:}</dataDir>   
5. 自动提交配置  
6. <autoCommit>   
7.        当超过15000ms后自动提交所有数据  
8.        <maxTime>${solr.autoCommit.maxTime:15000}</maxTime>   
9.        是否马上就可以查询到  
10.        <openSearcher>false</openSearcher>   
11. </autoCommit>  
12. 表示当路径为 /select时查询所有的数据  
13. <requestHandler name="/select" class="solr.SearchHandler">  
14.     <!-- default values for query parameters can be specified, these  
15.          will be overridden by parameters in the request  
16.       -->  
17.      <lst name="defaults">  
18.        <str name="echoParams">explicit</str>  
19.        <int name="rows">10</int>  
20.      </lst>  
21. </requestHandler>  

 尝试在界面上添加数据和查询数据

 添加数据

 

 查询结果

 

查询的参数列表

  q表示查询的条件  字段名：值的格式

  fq表示filter query 过滤条件 和q是and的关系支持各种逻辑运算符 （参考https://cwiki.apache.org/confluence/display/solr/The+Standard+Query+Parser）

  sort表示排序 的字段  字段名 asc|desc 

  start 表示从第几行开始  rows表示查询的总行数

  fl表示查询显示的列 比如只需要查询 name_s,sex_i 这两列 使用,隔开

  df表示默认的查询字段 一般不设置

  Raw Query Parameters表示原始查询字段 可以使用 start=0&rows=10这种url的方式传入参数

  wt（write type）表示写入的格式 可以使用json和xml

  shards 多核同时搜索 solrhome拷贝mycore为mycore1  管理平台添加core   设置参数为 路径,路径来设置需要搜索的核

[html]  view plain  copy

1. String shards = "localhost:8080/solr/mycore,localhost:8080/solr/mycore1";   
2. query.set("shards", shards);  

  其他参考（https://cwiki.apache.org/confluence/display/solr/Common+Query+Parameters）

 5》配置中文分词器

   默认solr 没有使用中文分词器  所有搜索的词 都是整个句子就是一个词 搜索时 将单词全部写入才能搜索或者使用* 需要配置中文分词器

目前比较好用的分词器 是IK  2012年停更 只支持到 Lucene4.7 所有 solr5.5 需要lucene5支持  需要修改部分源码来支持solr5.5

 找到 IKAnalyzer类   需要重写  protected TokenStreamComponents createComponents(String fieldName) 方法

 找到 IKTokenizer类 需要重写构造方法  public IKTokenizer(Reader in, boolean useSmart) 为  public IKTokenizer(boolean useSmart) {

 在任意项目中 使用maven 引用lucene5 和ik  

保留 ikanalyzer包  然后删除其余的包 再次导入版本相同的包

[html]  view plain  copy

1. <dependency>  
2.           <groupId>org.apache.lucene</groupId>  
3.           <artifactId>lucene-core</artifactId>  
4.           <version>5.3.1</version>  
5.         </dependency>  
6.         <dependency>  
7.             <groupId>com.janeluo</groupId>  
8.             <artifactId>ikanalyzer</artifactId>  
9.             <version>2012_u6</version>  
10.             <exclusions>   
11.                 <exclusion>  
12.                     <groupId>org.apache.lucene</groupId>  
13.                      <artifactId>lucene-core</artifactId>  
14.                 </exclusion>  
15.             </exclusions>  
16.         </dependency>  

在项目中 添加完整的包名和类名 和 ik中一致 拷贝源代码

代码修改对应的方法即可

IKAnalyzer

[html]  view plain  copy

1. /**  
2.   
3.  *  
4.  */  
5. package org.wltea.analyzer.lucene;  
6.   
7. import java.io.Reader;  
8.   
9. import org.apache.lucene.analysis.Analyzer;  
10. import org.apache.lucene.analysis.Tokenizer;  
11.   
12. /**  
13.  */  
14. public final class IKAnalyzer extends Analyzer {  
15.   
16.   private boolean useSmart;  
17.   
18.   public boolean useSmart() {  
19.     return useSmart;  
20.   }  
21.   
22.   public void setUseSmart(boolean useSmart) {  
23.     this.useSmart = useSmart;  
24.   }  
25.   
26.   /**  
27.   
28.    */  
29.   public IKAnalyzer() {  
30.     this(false);  
31.   }  
32.   
33.   /**  
34.    */  
35.   public IKAnalyzer(boolean useSmart) {  
36.     super();  
37.     this.useSmart = useSmart;  
38.   }  
39.   
40.   /**这里就去掉了 Reader的一个参数  
41.    */  
42.   @Override  
43.   protected TokenStreamComponents createComponents(String fieldName) {  
44.     Tokenizer _IKTokenizer = new IKTokenizer(this.useSmart());  
45.     return new TokenStreamComponents(_IKTokenizer);  
46.   }  
47.   
48. }  

IKTokenizer

[html]  view plain  copy

1. /**  
2.  *   
3.  */  
4. package org.wltea.analyzer.lucene;  
5.   
6. import java.io.IOException;  
7. import java.io.Reader;  
8.   
9. import org.apache.lucene.analysis.Tokenizer;  
10. import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;  
11. import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;  
12. import org.apache.lucene.analysis.tokenattributes.TypeAttribute;  
13.   
14. import org.wltea.analyzer.core.IKSegmenter;  
15. import org.wltea.analyzer.core.Lexeme;  
16.   
17.   
18. public final class IKTokenizer extends Tokenizer {  
19.   
20.   
21.   private IKSegmenter _IKImplement;  
22.   
23.   
24.   private final CharTermAttribute termAtt;  
25.   
26.   private final OffsetAttribute offsetAtt;  
27.   
28.   private final TypeAttribute typeAtt;  
29.   
30.   private int endPosition;  
31.   
32.   //去掉了其中Reader的第一个构造参数  
33.   public IKTokenizer(boolean useSmart) {  
34.     super();//去掉super中的构造参数  
35.     offsetAtt = addAttribute(OffsetAttribute.class);  
36.     termAtt = addAttribute(CharTermAttribute.class);  
37.     typeAtt = addAttribute(TypeAttribute.class);  
38.     _IKImplement = new IKSegmenter(input, useSmart);  
39.   }  
40.   
41.    
42.   @Override  
43.   public boolean incrementToken() throws IOException {  
44.   
45.     clearAttributes();  
46.     Lexeme nextLexeme = _IKImplement.next();  
47.     if (nextLexeme != null) {  
48.   
49.       termAtt.append(nextLexeme.getLexemeText());  
50.      
51.       termAtt.setLength(nextLexeme.getLength());  
52.         
53.       offsetAtt.setOffset(nextLexeme.getBeginPosition(), nextLexeme.getEndPosition());  
54.      
55.       endPosition = nextLexeme.getEndPosition();  
56.     
57.       typeAtt.setType(nextLexeme.getLexemeTypeString());  
58.   
59.       return true;  
60.     }  
61.   
62.     return false;  
63.   }  
64.   
65.   /*  
66.    * (non-Javadoc)  
67.    * @see org.apache.lucene.analysis.Tokenizer#reset(java.io.Reader)  
68.    */  
69.   @Override  
70.   public void reset() throws IOException {  
71.     super.reset();  
72.     _IKImplement.reset(input);  
73.   }  
74.   
75.   @Override  
76.   public final void end() {  
77.     // set final offset  
78.     int finalOffset = correctOffset(this.endPosition);  
79.     offsetAtt.setOffset(finalOffset, finalOffset);  
80.   }  
81. }  

将编译好的class文件替换原始jar包即可

将solrhome下 配置文件managed-schema 添加一个字段类型 使用ik分词器

[html]  view plain  copy

1. <fieldType name="text_ik" class="solr.TextField" >  
2.       <analyzer type="index" isMaxWordLength="false" class="org.wltea.analyzer.lucene.IKAnalyzer"/>     
3.       <analyzer type="query" isMaxWordLength="true" class="org.wltea.analyzer.lucene.IKAnalyzer"/>   
4.     </fieldType>  

不能修改 StrField 不支持自定义分词器

<fieldType name="string" class="solr.StrField" sortMissingLast="true" >
</fieldType>

然后将对应需要进行中文分词的字段使用 text_ik该字段类型 比如

[html]  view plain  copy

1. <dynamicField name="*_s"  type="text_ik"  indexed="true"  stored="true" />  

重启 或者 cloud环境下重新生成collection 插入数据即可实现中文分词  通过某些中文关键字搜索

三。solr客户端

  solr提供的solrj java客户端可以使用java来添加和查询索引 

使用maven引入solrj的依赖库

[html]  view plain  copy

1. <!-- https://mvnrepository.com/artifact/org.apache.solr/solr-solrj -->  
2. <dependency>  
3.     <groupId>org.apache.solr</groupId>  
4.     <artifactId>solr-solrj</artifactId>  
5.     <version>5.5.3</version>  
6. </dependency>  

使用客户端操作添加和查询索引的代码

[html]  view plain  copy

1. public class TestCrud {  
2.     //请求的url  
3.     public static final String url="http://localhost:8080/solr/mycore";  
4.     /**  
5.      * 测试写入数据到solr  
6.      * @throws IOException   
7.      * @throws SolrServerException   
8.      */  
9.     @Test  
10.     public void testWriteDoc() throws SolrServerException, IOException{  
11.         HttpSolrClient hsc=new HttpSolrClient(url);  
12.         SolrInputDocument sid=new SolrInputDocument();  
13.         sid.addField("id", 1);  
14.         sid.addField("name_s","张三");  
15.         hsc.add(sid);  
16.         hsc.commit();  
17.         hsc.close();  
18.     }  
19.     /**  
20.      * 测试从solr读取数据  
21.      * @throws IOException   
22.      * @throws SolrServerException   
23.      */  
24.     @Test  
25.     public void testReadDoc() throws SolrServerException, IOException{  
26.         HttpSolrClient hsc=new HttpSolrClient(url);  
27.         SolrQuery sq=new SolrQuery();  
28.         sq.setQuery("name_s:*");  
29.         sq.set("sort", "id asc");  
30.         sq.setStart(0);  
31.         sq.setRows(1);  
32.         SolrDocumentList sdl=hsc.query(sq).getResults();  
33.         for(SolrDocument sd:sdl){  
34.             System.out.println(sd.getFieldValue("name_s"));  
35.         }  
36.         hsc.close();  
37.     }  
38.     /**  
39.      * 测试通过id删除  
40.      * @throws IOException   
41.      * @throws SolrServerException   
42.      */  
43.     @Test  
44.     public void testDelDoc() throws SolrServerException, IOException{  
45.         HttpSolrClient hsc=new HttpSolrClient(url);  
46.         hsc.deleteById("1");  
47.         hsc.commit();  
48.         hsc.close();  
49.     }  
50. }  

使用javabean的方式操作

javabean定义

[html]  view plain  copy

1. import org.apache.solr.client.solrj.beans.Field;  
2. public class UserInfo {  
3.     public UserInfo() {  
4.     }  
5.     @Field  
6.     private String id;  
7.     @Field  
8.     private String name_s;  
9.     @Field  
10.     private int age_i;  
11. }  

执行代码如下：

[html]  view plain  copy

1. /**  
2.      * 测试写入数据到solr  
3.      * @throws IOException   
4.      * @throws SolrServerException   
5.      */  
6.     @Test  
7.     public void testWriteDoc() throws SolrServerException, IOException{  
8.         HttpSolrClient hsc=new HttpSolrClient(url);  
9.         UserInfo ui=new UserInfo();  
10.         ui.setId("2");  
11.         ui.setName_s("李四");  
12.         ui.setAge_i(100);  
13.         hsc.addBean(ui);  
14.         hsc.commit();  
15.         hsc.close();  
16.     }  
17.     /**  
18.      * 测试从solr读取数据  
19.      * @throws IOException   
20.      * @throws SolrServerException   
21.      */  
22.     @Test  
23.     public void testReadDoc() throws SolrServerException, IOException{  
24.         HttpSolrClient hsc=new HttpSolrClient(url);  
25.         SolrQuery sq=new SolrQuery();  
26.         sq.setQuery("name_s:*");  
27.         sq.set("sort", "id asc");  
28.         sq.setStart(0);  
29.         sq.setRows(1);  
30.         List<UserInfo> sdl=hsc.query(sq).getBeans(UserInfo.class);  
31.         for(UserInfo sd:sdl){  
32.             System.out.println(sd.getName_s());  
33.         }  
34.         hsc.close();  
35.     }  

四。solr集群安装

  1》集群方式：

   solr集群目前有两种方式 主从模式和solrcloud模式（推荐方式）

solrcloud通过zookeeper管理集群 通过将索引切片的方式分发到不同的后端服务器中 后端服务器 可以通过一主多从的方式来实现高可用  一主多从

通过leader的管理方式 leader负责写入  从机负责分摊并发读取  leader挂掉后 从机选举出新的leader继续进行管理

 2》solrcloud集群概念

   solrcloud分为逻辑层和物理层 

   逻辑层：

      》Cluster（表示zookeeper集群） 用于管理solrcloud的实例collection

      》Collection 表示一个solrcloud的实例 能够被切分为多个片

      》Shards （片） 一个Collection 可以被切分为多个片 片的个数决定了并发量的大小 每个片拥有多个备份 其中包括leader 负责写入  replica负责容灾和读请求

                   

  物理层：

      》 Cluster由多个solr 节点（物理机器）组成  每个节点对应linux的后台进程

      》 Node（节点） 每个节点由多个Core组成   

      》 Core 每个片在该节点的拷贝都属于一个core  可能每个片都有一份拷贝在当前机器上 当前机器 可能有多个core

      》Replica 是每个切片的一份拷贝  必须使用使用相同的配置 该配置需要写入到zookeeper中 

      

 3》solrcloud集群实现（伪集群）

   》》拷贝三份tomcat  分别修改server.xml tomcat端口  （8080,8081,8082）

   》》同单机安装拷贝solr应用到webapps目录下 修改web.xml 分别指向不同的solrhome

           比如我的配置  

tomcat1	8080	D:\learn\solr-5.5.4\home
tomcat2	8081	D:\learn\solr-5.5.4\home1
tomcat3	8082	D:\learn\solr-5.5.4\home2

   》》拷贝 solr解压包下\server\solr到新建目录D:\learn\solr-5.5.4\home中 同时拷贝到hom1和home2     

            solr解压包下\server\solr\configsets\basic_configs到新建目录D:\learn\solr-5.5.4\home（只拷贝home 不拷贝home1和home2） 改名为

           collections1 

   》》tomcat/bin下的 catalina.cmd添加  

tomcat1下设置为：

[html]  view plain  copy

1. set JAVA_OPTS=-Dsolr.solr.home=D:/learn/solr-5.5.4/home -Dbootstrap_confdir=D:/learn/solr-5.5.4/home/collection1/conf   
2. -Dcollection.configName=myconf -DnumShards=3 -DzkHost=localhost:2181  

其他tomcat 设置为 

[html]  view plain  copy

1. set JAVA_OPTS=-Dsolr.solr.home=D:/learn/solr-5.5.4/home  -DzkHost=localhost:2181  

  》》 这里假设本机开启了zookeeper 端口是2181 当然可以开启多个zookeeper地址使用,隔开（参考http://blog.csdn.net/liaomin416100569/article/details/71642091）

  依次启动 zookeeper  和所有的tomcat  访问 http://localhost:8080/solr/admin.html

  》》使用命令创建collection （其他操作参考 https://cwiki.apache.org/confluence/display/solr/Collections+API）

[html]  view plain  copy

1. http://localhost:8081/solr/admin/collections?action=CREATE&name=collection1&numShards=3&replicationFactor=3&maxShardsPerNode=3&collection.configName=myconf  

  》》查看zookeeper信息和集群分片信息

 查看zookeeper中写入的数据

   

查看分片到哪些节点

五。solr一些其他高级查询（参考代码）

[html]  view plain  copy

1. package cn.et.solor;  
2.   
3. import java.io.IOException;  
4. import java.util.List;  
5. import java.util.Map;  
6.   
7. import org.apache.solr.client.solrj.SolrQuery;  
8. import org.apache.solr.client.solrj.SolrRequest;  
9. import org.apache.solr.client.solrj.SolrServerException;  
10. import org.apache.solr.client.solrj.impl.CloudSolrClient;  
11. import org.apache.solr.client.solrj.response.FacetField;  
12. import org.apache.solr.client.solrj.response.Group;  
13. import org.apache.solr.client.solrj.response.GroupCommand;  
14. import org.apache.solr.client.solrj.response.GroupResponse;  
15. import org.apache.solr.client.solrj.response.PivotField;  
16. import org.apache.solr.client.solrj.response.QueryResponse;  
17. import org.apache.solr.client.solrj.response.FacetField.Count;  
18. import org.apache.solr.common.params.GroupParams;  
19. import org.apache.solr.common.util.NamedList;  
20. import org.junit.Test;  
21. /**  
22.  * 支持一些高级特性 比如高亮 分类 分组 mtl（相似）  
23. {"id":"1","country_s":"美国","provice_s":"加利福尼亚州","city_s":"旧金山","age_i":"30","name_s":"John","desc_s":"John is come from austrina  John,s Dad is Johh Super"}  
24. {"id":"2","country_s":"美国","provice_s":"加利福尼亚州","city_s":"好莱坞","age_i":"40","name_s":"Mike","desc_s":"Mike is come from austrina  Mike,s Dad  is Mike Super"}  
25. {"id":"3","country_s":"美国","provice_s":"加利福尼亚州","city_s":"圣地牙哥","age_i":"50","name_s":"Cherry","desc_s":"Cherry is come from austrina  Cherry,s Dad  is Cherry Super"}  
26. {"id":"4","country_s":"美国","provice_s":"德克萨斯州","city_s":"休斯顿","age_i":"60","name_s":"Miya","desc_s":"Miya is come from austrina  Miya,s Dad  is Miya Super"}  
27. {"id":"5","country_s":"美国","provice_s":"德克萨斯州","city_s":"大学城","age_i":"70","name_s":"fubos","desc_s":"fubos is come from austrina  fubos,s Dad  is fubos Super"}  
28. {"id":"6","country_s":"美国","provice_s":"德克萨斯州","city_s":"麦亚伦","age_i":"20","name_s":"marry","desc_s":"marry is come from austrina  marry,s Dad  is marry Super"}  
29. {"id":"7","country_s":"中国","provice_s":"湖南省","city_s":"长沙市","age_i":"18","name_s":"张三","desc_s":"张三来自长沙市 是公务员一名"}  
30. {"id":"8","country_s":"中国","provice_s":"湖南省","city_s":"岳阳市","age_i":"15","name_s":"李四","desc_s":"李四来自岳阳市 是一名清洁工"}  
31. {"id":"9","country_s":"中国","provice_s":"湖南省","city_s":"株洲市","age_i":"33","name_s":"李光四","desc_s":"李光四 老家岳阳市 来自株洲 是李四的侄子"}  
32. {"id":"10","country_s":"中国","provice_s":"广东省","city_s":"深圳市","age_i":"67","name_s":"王五","desc_s":"王五来自深圳市  是来自深圳的一名海关缉私精英"}  
33. {"id":"11","country_s":"中国","provice_s":"广东省","city_s":"广州市","age_i":"89","name_s":"王冠宇","desc_s":"王冠宇是王五的儿子"}  
34.  */  
35. public class TestCloud {  
36.     /**  
37.      * 连接solrcloud  
38.      * @return  
39.      */  
40.     public CloudSolrClient getCloudSolrClient(){  
41.         String zkHost="localhost:2181";  
42.         CloudSolrClient csc=new CloudSolrClient(zkHost);  
43.         csc.setDefaultCollection("collection1");//集合名称  
44.         return csc;  
45.     }  
46.     /**  
47.      * solrcloud保存 修改 删除和单机相同  
48.      */  
49.     @Test  
50.     public void save() throws IOException, SolrServerException{  
51.         CloudSolrClient csc=getCloudSolrClient();  
52.         UserInfo ui=new UserInfo();  
53.         ui.setId("4");  
54.         ui.setName_s("王五");  
55.         ui.setAge_i(100);  
56.         csc.addBean(ui);  
57.         csc.commit();  
58.         csc.close();  
59.     }  
60.     /**  
61.      * solrcloud 删除  
62.      */  
63.     //@Test  
64.     public void delete() throws IOException, SolrServerException{  
65.         CloudSolrClient csc=getCloudSolrClient();  
66.         csc.deleteByQuery("*:*");  
67.         csc.commit();  
68.         csc.close();  
69.     }  
70.   
71.     /**  
72.      * solrcloud高亮显示  
73.      * 必须设置中文分词器  
74.      */  
75.     @Test  
76.     public void queryHign() throws IOException, SolrServerException{  
77.         CloudSolrClient csc=getCloudSolrClient();  
78.         SolrQuery sq=new SolrQuery();  
79.         sq.setQuery("desc_s:王五");  
80.         sq.addHighlightField("desc_s");  
81.         sq.setHighlight(true);  
82.         sq.setHighlightSimplePre("<font color=red>");  
83.         sq.setHighlightSimplePost("</font>");  
84.         QueryResponse qr=csc.query(sq);  
85.         List<UserInfo> userInfo=qr.getBeans(UserInfo.class);  
86.         Map<String, Map<String, List<String>>> highlighting = qr.getHighlighting();  
87.         System.out.println(highlighting);  
88.         for(UserInfo ui:userInfo){  
89.             System.out.println(ui.getName_s());  
90.         }  
91.         System.out.println(userInfo.size());  
92.         csc.commit();  
93.         csc.close();  
94.     }  
95.       
96.     /**  
97.      * Facet 面 用于对搜索的结果进行分类   
98.      *  比如按国家分类   addFacetField 表示按某些字段进行分类是普通分类  结果为：  
99.      *   country_s  
100.             美国:6  
101.             中国:5  
102.         sq.addFacetQuery("age_i:[1 TO 20]");  
103.         sq.addFacetQuery("age_i:[21 TO 50]");  
104.         sq.addFacetQuery("age_i:[51 TO *]");  
105.         可以将多个范围值 添加到FacetQuery可以获取到这些Query的统计数量 比如  
106.          {age_i:[1 TO 20]=3, age_i:[20 TO 50]=5, age_i:[50 TO *]=5}   
107.         其他 参考 https://wiki.apache.org/solr/SimpleFacetParameters#facet.query_:_Arbitrary_Query_Faceting   
108.      */  
109.     @Test  
110.     public void queryFacet() throws IOException, SolrServerException{  
111.         CloudSolrClient csc=getCloudSolrClient();  
112.         SolrQuery sq=new SolrQuery();  
113.           
114.         sq.setFacet(true);  
115.         //按字段分类 相同的归于一类  
116.         sq.addFacetField("country_s");  
117.         //特殊分类 添加范围  
118.         sq.addFacetQuery("age_i:[1 TO 20]");  
119.         sq.addFacetQuery("age_i:[21 TO 50]");  
120.         sq.addFacetQuery("age_i:[51 TO *]");  
121.         //这只facet字段分类的前缀  
122.         sq.setFacetPrefix("");  
123.         //根据 count 数量 升序和降序 也可以根据索引   
124.         sq.setFacetSort("count asc");  
125.         sq.setQuery("*:*");  
126.         QueryResponse qr=csc.query(sq);  
127.         List<FacetField> ff=qr.getFacetFields();  
128.         //获取到范围分类的对应统计数量  
129.         System.out.println(qr.getFacetQuery());  
130.         //获取到根据字段分类的对应统计数量  
131.         for(FacetField ftmp:ff){  
132.             System.out.println(ftmp.getName());  
133.             List<Count> cou=ftmp.getValues();  
134.             for (Count count : cou){  
135.                 System.out.println(count.getName()+":"+ count.getCount());  
136.             }  
137.         }  
138.         csc.commit();  
139.         csc.close();  
140.     }  
141.       
142.     /**  
143.      * Facet  参考https://wiki.apache.org/solr/SimpleFacetParameters#Pivot_.28ie_Decision_Tree.29_Faceting  
144.      *  可以按照多维度来进行分类    
145.      *    比如按照国家分类后  再按照省份分类(国家和省份字段不要使用中文分词器 否则分类被拆成很多类别)  
146.      *      
147.      *  结果一般为：  
148.      *    美国6：  
149.      *      加利福尼亚州3    
150.      *      德克萨斯州3  
151.      *    中国5：  
152.      *      湖南省3  
153.      *      广东省2  
154.   
155.      */  
156.     @Test  
157.     public void queryFacetPivot() throws IOException, SolrServerException{  
158.         CloudSolrClient csc=getCloudSolrClient();  
159.         SolrQuery sq=new SolrQuery();  
160.         sq.setFacet(true);  
161.         //按国家和省份进行二维分类  同一个字符串使用,隔开  
162.         sq.addFacetPivotField("country_s,provice_s");  
163.         sq.setQuery("*:*");  
164.         QueryResponse qr=csc.query(sq,SolrRequest.METHOD.POST);  
165.         NamedList<List<PivotField>> ff=qr.getFacetPivot();  
166.         //获取到根据字段分类的对应统计数量  
167.         for(Map.Entry<String,List<PivotField>> me:ff){  
168.             List<PivotField> lpf=me.getValue();  
169.             for(PivotField pf:lpf){  
170.                 System.out.println("一级分类:"+pf.getValue()+pf.getCount()+"---->");  
171.                 List<PivotField> clpf=pf.getPivot();  
172.                 for(PivotField cpf:clpf){  
173.                     System.out.println("二级分类:"+cpf.getValue()+cpf.getCount());  
174.                 }  
175.             }  
176.         }  
177.         csc.commit();  
178.         csc.close();  
179.     }  
180.     /**  
181.      * 分组是分类的升级 同时可以获取到分组下的一部分元素（https://cwiki.apache.org/confluence/display/solr/Result+Grouping）  
182.        分组的字段的数据如果是集群环境 要求数据被写入到一个分片中 否则无法分组查询  
183.      */  
184.     @Test  
185.     public void queryGroup() throws IOException, SolrServerException{  
186.         CloudSolrClient csc=getCloudSolrClient();  
187.         SolrQuery sq=new SolrQuery();  
188.         //sq.setParam("shards.tolerant", true);  
189.         sq.setParam(GroupParams.GROUP,true);  
190.         sq.setParam(GroupParams.GROUP_FIELD, "country_s");  
191.         sq.setParam("group.ngroups", true);  
192.         //sq.setParam(GroupParams.GROUP_LIMIT, "5");  
193.         sq.setQuery("*:*");  
194.         sq.setRows(10);  
195.         QueryResponse qr=csc.query(sq);  
196.         GroupResponse ff=qr.getGroupResponse();  
197.           
198.         for(GroupCommand me:ff.getValues()){  
199.             System.out.println(me.getName());  
200.              List<Group> groups=me.getValues();  
201.              System.out.println(groups);  
202.               
203.         }  
204.         csc.commit();  
205.         csc.close();  
206.     }  
207. }