SolrJ的使用

SolrJ的使用

1、添加依赖

 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>

     <groupId>com.myx.solr</groupId>
     <artifactId>day11solr</artifactId>
     <version>1.0-SNAPSHOT</version>

     <dependencies>
         <!-- Junit单元测试 -->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.12</version>
         </dependency>
         <dependency>
             <groupId>org.apache.solr</groupId>
             <artifactId>solr-solrj</artifactId>
             <version>4.10.2</version>
         </dependency>
         <!-- Solr底层会使用到slf4j日志系统 -->
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-log4j12</artifactId>
             <version>1.7.22</version>
         </dependency>
         <dependency>
             <groupId>commons-logging</groupId>
             <artifactId>commons-logging</artifactId>
             <version>1.2</version>
         </dependency>
     </dependencies>
     <build>
         <plugins>
             <!-- java编译插件 -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.2</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
                 </configuration>
             </plugin>
         </plugins>
     </build>

 </project>

2、创建实体类

 package pojo;

 import org.apache.solr.client.solrj.beans.Field;

 public class Item {
     @Field   //表明当前字段要添加到索引库中
     private long id;
     @Field
     private String title;
     @Field
     private long price;

     public long getId() {
         return id;
     }

     public void setId(long id) {
         this.id = id;
     }

     public String getTitle() {
         return title;
     }

     public void setTitle(String title) {
         this.title = title;
     }

     public long getPrice() {
         return price;
     }

     public void setPrice(long price) {
         this.price = price;
     }
 }

3、SolrJ的增删改查

3.1使用Document向Solr添加或修改索引

 /*
   5     *
   6     * 使用Document向Solr添加或修改索引*/
   7     @Test
   8     public void testWrite1() throws IOException, SolrServerException {
   9         //连接Solr服务器
  10         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
  11         //创建Solr的输入Document
  12         SolrInputDocument document = new SolrInputDocument();
  13
  14         //添加字段
  15         document.addField("id",15L);
  16         document.addField("title","锤子手机，老罗会吹");
  17         document.addField("price",992210);
  18
  19         //添加Document到server
  20         server.add(document);
  21
  22         //提交请求，如果id不存在，则添加新数据，如果存在，则修改数据
  23         server.commit();
  24     }

3.2使用注解和JavaBean向Solr中添加或修改数据

 /*
  27     * 使用注解和JavaBean向Solr中添加或修改数据
  28     * */
  29     @Test
  30     public void testWrite2() throws IOException, SolrServerException {
  31         //连接Solr服务器
  32         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
  33         //创建一个实体对象
  34         Item item = new Item();
  35         item.setId(16);
  36         item.setTitle("oppo手机，照亮你的美");
  37         item.setPrice(23330);
  38
  39         //将对象添加到Server
  40         server.addBean(item);
  41         //提交请求，如果id不存在，则添加新数据，如果存在就修改数据
  42         server.commit();
  43     }

3.3 SolrJ删除索引数据

  45     /*
  46     * SolrJ删除索引数据
  47     *
  48     * */
  49
  50     @Test
  51     public void testDelete() throws IOException, SolrServerException {
  52         //连接Solr服务器
  53         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
  54
  55         //根据id删除数据，注意这里需要传字符串
  56          // server.deleteById("16");
  57
  58         //根据查询条件删除，参数是字符串格式，写出查询条件
  59         server.deleteByQuery("title:Apple");
  60         //提交
  61         server.commit();
  62     }
  63 

3.4 使用Solr查询索引，返回的是Document形式

 /*
  65     * 使用Solr查询索引，返回的是Document形式
  66     * */
  67     @Test
  68     public void testQueryDocument() throws SolrServerException {
  69         //连接Solr服务器
  70         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
  71
  72         //创建查询对象
  73         SolrQuery solrQuery = new SolrQuery("title:华为");
  74
  75         //执行查询，获取响应
  76         QueryResponse response = server.query(solrQuery);
  77
  78         //获取查询结果，本质是一个Document的集合
  79         SolrDocumentList results = response.getResults();
  80         //获取总条数
  81         System.out.println("本次共搜索到" + results.size() + "条数据");
  82
  83         //遍历集合
  84         for (SolrDocument document : results) {
  85             System.out.println("id" + document.getFieldValue("id"));
  86             System.out.println("title" + document.getFieldValue("title"));
  87             System.out.println("price" + document.getFieldValue("price"));
  88         }
  89     }

3.5使用SolrJ查询索引，返回的是JavaBean

 /*
  92     * 使用SolrJ查询索引，返回的是JavaBean
  93     * */
  94
  95     @Test
  96     public void testQueryBeans() throws SolrServerException {
  97         //连接Solr服务器
  98         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
  99
 100         //创建查询对象：SolrQuery
 101         SolrQuery query = new SolrQuery("title:华为");
 102         //执行查询，获取响应
 103         QueryResponse response = server.query(query);
 104
 105         //获取查询结果，指定实体类的类型，返回实体类的集合
 106         List<Item> list = response.getBeans(Item.class);
 107
 108         //打印总条数
 109         System.out.println("本次共搜索到" + list.size() + "条数据");
 110
 111         //遍历集合
 112         for (Item item : list) {
 113             System.out.println(item.getId());
 114             System.out.println(item.getTitle());
 115             System.out.println(item.getPrice());
 116         }
 117     }
 118 

4 高级查询

4.1布尔查询

 /*
 121     * 布尔查询
 122     * */
 123     @Test
 124     public void testQueryBoolean() throws SolrServerException {
 125         //连接Solr服务器
 126         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
 127
 128         //创建查询对象：SolrQuery,并且使用Boolean操作，可选OR AND ONT
 129         SolrQuery query = new SolrQuery("title:华为 OR 小米");
 130         //执行查询，获取响应
 131         QueryResponse response = server.query(query);
 132
 133         //获取查询结果，指定实体类的类型，返回实体类的集合
 134         List<Item> list = response.getBeans(Item.class);
 135
 136         //打印总条数
 137         System.out.println("本次共搜索到" + list.size() + "条数据");
 138
 139         //遍历集合
 140         for (Item item : list) {
 141             System.out.println(item.getId());
 142             System.out.println(item.getTitle());
 143             System.out.println(item.getPrice());
 144         }
 145     }
 146 

4.2 相似度查询

 148     /*
 149     * 相似度查询
 150     * */
 151     @Test
 152     public void testFuzzyQuery() throws SolrServerException {
 153         //连接Solr服务器
 154         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
 155
 156         //相似度查询，与lucene的相似度查询一致，允许的编辑举例是0-2，默认是2
 157         SolrQuery query = new SolrQuery("title:applk~");
 158         //执行查询，获取响应
 159         QueryResponse response = server.query(query);
 160
 161         //获取查询结果，指定实体类的类型，返回实体类的集合
 162         List<Item> list = response.getBeans(Item.class);
 163
 164         //打印总条数
 165         System.out.println("本次共搜索到" + list.size() + "条数据");
 166
 167         //遍历集合
 168         for (Item item : list) {
 169             System.out.println(item.getId());
 170             System.out.println(item.getTitle());
 171             System.out.println(item.getPrice());
 172         }
 173     }
 174 

4.3 范围查询，闭区间

 176     /*
 177     * 范围查询，闭区间
 178     * */
 179     @Test
 180     public void testScoreQuery() throws SolrServerException {
 181         //连接Solr服务器
 182         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
 183
 184         //创建查询对象
 185         SolrQuery query = new SolrQuery("price:[100000 TO 200000]");
 186         //执行查询，获取响应
 187         QueryResponse response = server.query(query);
 188
 189         //获取查询结果，指定实体类的类型，返回实体类的集合
 190         List<Item> list = response.getBeans(Item.class);
 191
 192         //打印总条数
 193         System.out.println("本次共搜索到" + list.size() + "条数据");
 194
 195         //遍历集合
 196         for (Item item : list) {
 197             System.out.println(item.getId());
 198             System.out.println(item.getTitle());
 199             System.out.println(item.getPrice());
 200         }
 201     }
 202 

4.4 使用SolrJ查询索引，并且设置排序

 /*
 205     * 使用SolrJ查询索引，并且设置排序
 206     * */
 207
 208     @Test
 209     public void testSortedQuery() throws SolrServerException {
 210         //连接Solr服务器
 211         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
 212
 213         //创建查询对象
 214         SolrQuery query = new SolrQuery("title:华为");
 215
 216         //设置查询的排序参数，参数：排序的字段名、排序方式
 217         query.setSort("price", SolrQuery.ORDER.desc);
 218
 219         //执行查询，获取响应
 220         QueryResponse response = server.query(query);
 221
 222         //获取查询结果，指定实体类的类型，返回实体类的集合
 223         List<Item> list = response.getBeans(Item.class);
 224
 225         //打印总条数
 226         System.out.println("本次共搜索到" + list.size() + "条数据");
 227
 228         //遍历集合
 229         for (Item item : list) {
 230             System.out.println(item.getId());
 231             System.out.println(item.getTitle());
 232             System.out.println(item.getPrice());
 233         }
 234     }

4.5 查询索引并且分页

 /*
 237     * 查询索引并且分页
 238     * */
 239     @Test
 240     public void testPageQuery() throws SolrServerException {
 241         //准备分页参数
 242         int pageNum = 2; //查询的页数
 243         int pageSize = 5; // 每页显示条数
 244         int start = (pageNum - 1) * pageSize;//当前页的起始条数
 245
 246         //连接Solr服务器
 247         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
 248
 249         //创建查询对象
 250         SolrQuery query = new SolrQuery("title:手机");
 251
 252         //设置查询的排序参数，参数：排序的字段名、排序方式
 253         query.setSort("price", SolrQuery.ORDER.desc);
 254
 255         //设置分页信息到查询对象中
 256         query.setStart(start);
 257         query.setRows(5);
 258
 259         //执行查询，获取响应
 260         QueryResponse response = server.query(query);
 261
 262         //获取查询结果，指定实体类的类型，返回实体类的集合
 263         List<Item> list = response.getBeans(Item.class);
 264
 265         //打印总条数
 266         System.out.println("本次共搜索到" + list.size() + "条数据");
 267
 268         //遍历集合
 269         for (Item item : list) {
 270             System.out.println(item.getId());
 271             System.out.println(item.getTitle());
 272             System.out.println(item.getPrice());
 273         }
 274     }

4.6 查询索引并且高亮

   /*
 278     * 查询索引并且高亮
 279     * */
 280     @Test
 281     public void testHighlightQuery() throws SolrServerException {
 282         //连接Solr服务器
 283         HttpSolrServer server = new HttpSolrServer("http://localhost:8080/solr/core2");
 284
 285         //创建查询对象
 286         SolrQuery query = new SolrQuery("title:华为");
 287
 288         //设置高亮标签
 289         query.setHighlightSimplePre("<em>");
 290         query.setHighlightSimplePost("</em>");
 291
 292         //高亮字段
 293         query.addHighlightField("title");
 294
 295         //执行查询，获取响应
 296         QueryResponse response = server.query(query);
 297
 298         // 解析高亮响应结果,是一个Map
 299         // 外层的Map：它的键是文档的id,值是这个文档的其它高亮字段，又是一个Map
 300         // 内存的Map：是其它高亮字段，键是其它字段的名称，值是这个字段的值，这个值是一个List
 301         Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
 302         //获取查询结果，指定实体类的类型，返回实体类的集合
 303         List<Item> list = response.getBeans(Item.class);
 304
 305         //打印总条数
 306         System.out.println("本次共搜索到" + list.size() + "条数据");
 307
 308         //遍历集合
 309         for (Item item : list) {
 310             long id = item.getId();
 311             System.out.println("id: " + id);
 312             // 这里ID是long类型，与集合的键不匹配，所以我们需要把id转为String类型，再get
 313             System.out.println("title: " + highlighting.get(id+"").get("title").get(0));
 314             System.out.println("price: " + item.getPrice());
 315
 316         }
 317     }