Solr学习之路–2索引基本操作

根据上一节Solr学习之路–1环境集成搭建后,创建并查询了索引,可以看下统计信息:

solr_overview

添加索引

我们可以利用管理用户界面添加索引文档:

solr_adddoc

其他方式,在搭建环境时体现过。

删除索引

我们可以通过命令的方式或者通过HTTP,提交请求和管理界面的方式进行测试

通过id删除

java -Ddata=args -Dc=wenqy -jar post.jar "<delete><id>20160928</id></delete>"

通过查询条件删除

java -Ddata=args -Dc=wenqy -jar post.jar "<delete><query>name:小温之家</query></delete>"

也可以手动提交,期间可以可以查询出数据

java -Ddata=args -Dcommit=false -Dc=wenqy -jar post.jar "<delete><id>20160928</id></delete>"

然后提交事务,彻底删除

java -Dc=wenqy -jar post.jar -

提交请求的方式

删除所有数据

http://localhost:8983/solr/wenqy/update?stream.body=*:*&commit=true

根据查询条件删除

http://localhost:8983/solr/wenqy/update?stream.body=<delete><query>name:小温 AND cat:book</query></delete>&commit=true

通过用户管理界面删除,删除id为“201610091”的数据solr_deldoc

SolrJ测试

添加索引

利用solr对java的支持,添加索引集合

  1. /**
  2.  * 添加索引集合
  3.  */
  4. public void addDocs() {
  5.     Collection<SolrInputDocument> docs = new ArrayList<SolrInputDocument>();
  6.     for (int i=10; i<20; i++) {
  7.         SolrInputDocument doc = new SolrInputDocument();
  8.         doc.addField(“id”“20161008”+i);
  9.         doc.addField(“cat”“book”);
  10.         doc.addField(“name”“小温之家-solr学习之路”+i);
  11.         doc.addField(“price”9.99f);
  12.         doc.addField(“author”“wenqy”);
  13.         doc.addField(“inStock”true);
  14.         docs.add(doc);
  15.     }
  16.     try {
  17.         System.out.println(solrClient.add(docs));
  18.         System.out.println(solrClient.commit());
  19.     } catch (SolrServerException e) {
  20.         e.printStackTrace();
  21.     } catch (IOException e) {
  22.         e.printStackTrace();
  23.     }
  24. }

以对象的方式添加索引集合

  1. /**
  2.      * 以对象方式添加索引集合
  3.      */
  4.     public void addBeans() {
  5.         List<BookIndex> indexs = new ArrayList<BookIndex>();
  6.         for (int i=20; i<30; i++) {
  7.             BookIndex index = new BookIndex();
  8.             index.setId(“20161008”+i);
  9.             index.setName(“小温之家-solr学习之路”+i);
  10.             index.setCat(“book”);
  11.             index.setPrice(6.66f);
  12.             index.setAuthor(“wenqy2”);
  13.             index.setInStock(true);
  14.             indexs.add(index);
  15.         }
  16.         try {
  17.             System.out.println(solrClient.addBeans(indexs));
  18.             System.out.println(solrClient.commit());
  19.         } catch (SolrServerException e) {
  20.             e.printStackTrace();
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         }
  24.     }
删除索引
  1. /**
  2.  * 删除索引
  3.  */
  4. public void remove() {
  5.     try {
  6.         //删除id为20160928的索引
  7.         solrClient.deleteById(“20160928”);
  8.         solrClient.commit();
  9.         //根据id集合,删除多个索引
  10.         List<String> ids = new ArrayList<String>();
  11.         ids.add(“201610080”);
  12.         ids.add(“201610081”);
  13.         solrClient.deleteById(ids);
  14.         solrClient.commit(truetrue);
  15.         //删除查询到的索引信息
  16.         solrClient.deleteByQuery(“id:201610082 id:201610083”);
  17.         solrClient.commit(truetrue);
  18.     } catch (SolrServerException e) {
  19.         e.printStackTrace();
  20.     } catch (IOException e) {
  21.         e.printStackTrace();
  22.     }
  23. }
查询索引
  1. /**
  2.      * 以查询参数的方式查询
  3.      * @param query
  4.      */
  5.     public void query(String query) {
  6.         SolrParams params = new SolrQuery(query);
  7.         try {
  8.             QueryResponse response = solrClient.query(params);
  9.             for (SolrDocument result :response.getResults()) {
  10.                 System.out.println(result);
  11.             }
  12.         } catch (SolrServerException | IOException e) {
  13.             e.printStackTrace();
  14.         }
  15.     }

 

查询所有索引

  1. /**
  2.      * 查询所有索引
  3.      */
  4.     public void queryAll() {
  5.         ModifiableSolrParams params = new ModifiableSolrParams();
  6.         // 查询关键词,*:*代表所有属性、所有值,即所有index
  7.         params.set(“q”“*:*”);
  8.         // 分页,start=0就是从0开始,rows=10当前返回10条记录,下一页变化start这个值为10。
  9.         params.set(“start”0);
  10.         params.set(“rows”, Integer.MAX_VALUE);
  11.         // 排序
  12.         params.set(“sort”“id desc”);
  13.         // 返回字段
  14.         params.set(“fl”“*”);
  15.         QueryResponse query;
  16.         try {
  17.             query = solrClient.query(params);
  18.             for (SolrDocument result :query.getResults()) {
  19.                 System.out.println(result);
  20.             }
  21.         } catch (SolrServerException e) {
  22.             e.printStackTrace();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }
  26.     }

 

查询基本用法

  1. /**
  2.      * 测试案例:查询基本用法
  3.      */
  4.     public void queryCase() {
  5.         //AND 并且
  6.         SolrQuery params = new SolrQuery(“name:小温之家  AND cat:book”);
  7.         //OR 或者
  8. //      params.setQuery(“name:小温之家  AND author:wenqy”);
  9.         //空格 等同于 OR
  10. //      params.setQuery(“name:小温之家  author:wenqy”);
  11.         //- 在要排除的词前加上-  号,即排除author为wenqy的数据
  12.         params.setQuery(“name:小温之家 – author:wenqy”);
  13.         //+ 必须包含”+” 号后面的数据
  14. //      params.setQuery(“name:A + author:wenqy”);
  15.         //查询name包含solr 小温之家
  16.         params.setQuery(“name:solr,小温之家”);
  17.         //author不包含wenqy
  18.         params.setQuery(“name:solr,小温之家  NOT author:wenqy”);
  19.         //50 <= price <= 200
  20.         params.setQuery(“price:[50 TO 200]”);
  21.         params.setQuery(“price:[5 TO 6]”);
  22.         //params.setQuery(“price:[50 TO 200] – price:[5 TO 6]”);
  23.         //params.setQuery(“price:[50 TO 200] + price:[5 TO 6]”);
  24.         //50 <= price <= 200 AND 5 <= price <= 6
  25.         params.setQuery(“price:[50 TO 200] AND price:[5 TO 6]”);
  26.         //过滤器查询,可以提高性能 filter 类似多个条件组合,如and
  27.         //params.addFilterQuery(“id:201609”);
  28.         //params.addFilterQuery(“price:[50 TO 200]”);
  29.         //params.addFilterQuery(“author:*”);
  30.         //0 < price < 6  没有等于
  31.         //params.addFilterQuery(“price:{0 TO 6}”);
  32.         //排序
  33.         params.addSort(“id”, ORDER.asc);
  34.         //分页:start开始页,rows每页显示记录条数
  35.         //params.add(“start”, “0”);
  36.         //params.add(“rows”, “200”);
  37.         //params.setStart(0);
  38.         //params.setRows(200);
  39.         //设置高亮
  40.         params.setHighlight(true); // 开启高亮组件
  41.         params.addHighlightField(“name”);// 高亮字段
  42.         params.setHighlightSimplePre(“<span class=’red’>”);//标记,高亮关键字前缀
  43.         params.setHighlightSimplePost(“</span>”);//后缀
  44.         params.setHighlightSnippets(1);//结果分片数,默认为1
  45.         params.setHighlightFragsize(1000);//每个分片的最大长度,默认为100
  46.         //分片信息
  47.         params.setFacet(true)
  48.             .setFacetMinCount(1)
  49.             .setFacetLimit(5)//段
  50.             .addFacetField(“name”)//分片字段
  51.             .addFacetField(“inStock”);
  52.         //params.setQueryType(“”);
  53.         try {
  54.             QueryResponse response = solrClient.query(params);
  55.             /*List<BookIndex> indexs = response.getBeans(BookIndex.class);
  56.             for (int i = 0; i < indexs.size(); i++) {
  57.                 fail(indexs.get(i));
  58.             }*/
  59.             //输出查询结果集
  60.             for (SolrDocument result :response.getResults()) {
  61.                 System.out.println(result);
  62.             }
  63.             //输出分片信息
  64.             List<FacetField> facets = response.getFacetFields();
  65.             for (FacetField facet : facets) {
  66.                 List<Count> facetCounts = facet.getValues();
  67.                 for (FacetField.Count count : facetCounts) {
  68.                     System.out.println(count.getName() + “: “ + count.getCount());
  69.                 }
  70.             }
  71.         } catch (SolrServerException e) {
  72.             e.printStackTrace();
  73.         } catch (IOException e) {
  74.             e.printStackTrace();
  75.         }
  76.     }

分片查询

  1. /**
  2.      * 分片查询, 统计关键字及出现次数、或自动补全提示
  3.      */
  4.     public void facetQuery() {
  5.         SolrQuery params = new SolrQuery(“*:*”);
  6.         //排序
  7.         params.addSort(“id”, ORDER.asc);
  8.         // 分页
  9.         params.setStart(0);
  10.         params.setRows(200);
  11.         //Facet为solr中的层次分类查询
  12.         //分片信息
  13.         params.setFacet(true)
  14.             .setQuery(“name:小温”)
  15.             .setFacetMinCount(1)
  16.             .setFacetLimit(10)//段
  17.             //.setFacetPrefix(“electronics”, “cat”)
  18.             .setFacetPrefix(“wenqy”)//查询name中关键字前缀是小温之家
  19.             .addFacetField(“author”);
  20.             //.addFacetField(“name”);//分片字段
  21.         try {
  22.             QueryResponse response = solrClient.query(params);
  23.             //输出查询结果集
  24.             for (SolrDocument result :response.getResults()) {
  25.                 System.out.println(result);
  26.             }
  27.             //输出分片信息
  28.             List<FacetField> facets = response.getFacetFields();
  29.             for (FacetField facet : facets) {
  30.                 List<Count> facetCounts = facet.getValues();
  31.                 StringBuffer stringBuffer = new StringBuffer();
  32.                 for (FacetField.Count count : facetCounts) {
  33.                     stringBuffer.append(count.getName()+” “);
  34.                 }
  35.                 // 获取自动代码提示数组
  36.                 String[] split = stringBuffer.toString().split(” “);
  37.                 for (String s : split) {
  38.                     System.out.println(s);
  39.                 }
  40.             }
  41.             //输出分片信息
  42.             FacetField facetField = response.getFacetField(“author”);
  43.             List<Count> facetFields = facetField.getValues();
  44.             for (Count count : facetFields) {
  45.                 //关键字 – 出现次数
  46.                 System.out.println(count.getName() + “: “ + count.getCount());
  47.             }
  48.         } catch (SolrServerException e) {
  49.             e.printStackTrace();
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
实体绑定

文档与实体Bean的相互绑定

  1. /**
  2.      * 文档与实体Bean的相互绑定
  3.      */
  4.     public void doc2Bean() {
  5.         SolrDocument doc = new SolrDocument();
  6.         doc.addField(“id”“20161009”);
  7.         doc.addField(“cat”“book”);
  8.         doc.addField(“name”“小温之家-solr学习之路”);
  9.         doc.addField(“price”9.99f);
  10.         doc.addField(“author”“wenqy3”);
  11.         doc.addField(“inStock”true);
  12.         BookIndex index = new BookIndex();
  13.         index.setId(“201610090”);
  14.         index.setName(“小温之家-solr学习之路”);
  15.         index.setCat(“book”);
  16.         index.setPrice(6.66f);
  17.         index.setAuthor(“wenqy3”);
  18.         index.setInStock(true);
  19.         DocumentObjectBinder binder = new DocumentObjectBinder();
  20.         // BookIndex ->> SolrInputDocument
  21.         System.out.println(binder.toSolrInputDocument(index));
  22.         // SolrDocument ->> BookIndex
  23.         System.out.println(binder.getBean(BookIndex.class, doc));
  24.         SolrDocumentList list = new SolrDocumentList();
  25.         list.add(doc);
  26.         //SolrDocumentList ->> List
  27.         System.out.println(binder.getBeans(BookIndex.class, list));
  28.     }

实体Bean

  1. /**
  2.  *  Entity:book书籍,参考exampledocs的book.csv
  3.  *  通过注解 将属性参与到index中
  4.  * @author wenqy
  5.  *
  6.  */
  7. public class BookIndex {
  8.     private String id;
  9.     @Field
  10.     private String name;
  11.     @Field
  12.     private String cat;
  13.     @Field
  14.     private float price;
  15.     @Field
  16.     private String author;
  17.     @Field
  18.     private boolean inStock;
  19.     public String getId() {
  20.         return id;
  21.     }
  22.     @Field
  23.     public void setId(String id) {
  24.         this.id = id;
  25.     }
  26.     public String getName() {
  27.         return name;
  28.     }
  29.     public void setName(String name) {
  30.         this.name = name;
  31.     }
  32.     public String getCat() {
  33.         return cat;
  34.     }
  35.     public void setCat(String cat) {
  36.         this.cat = cat;
  37.     }
  38.     public float getPrice() {
  39.         return price;
  40.     }
  41.     public void setPrice(float price) {
  42.         this.price = price;
  43.     }
  44.     public String getAuthor() {
  45.         return author;
  46.     }
  47.     public void setAuthor(String author) {
  48.         this.author = author;
  49.     }
  50.     public boolean isInStock() {
  51.         return inStock;
  52.     }
  53.     public void setInStock(boolean inStock) {
  54.         this.inStock = inStock;
  55.     }
  56.     public String toString() {
  57.         return “{id:”+id+“,name:”+name+“,cat:”+cat+“,price:”+price+“,author:”+author+“,inStock:”+inStock+“}”;
  58.     }
  59. }

代码调用测试

  1. public static void main(String[] args) {
  2.         AddCoreTest search = new AddCoreTest();
  3.         search.init();
  4.         //search.addData();
  5.         //search.addBeans();
  6.         //search.addDocs();
  7.         //search.remove();
  8.         //search.queryAll();
  9.         //search.query(“name:小温之家”);
  10.         //search.queryCase();
  11.         //search.facetQuery();
  12.         search.doc2Bean();
  13.     }

暂且这样吧,Solr的查询语法和复杂的查询功能有待挖掘。。。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

21 + 9 = ?