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

 4,700浏览     wenqyAdmin   

根据上一节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();
  10.         //根据id集合，删除多个索引
  11.         List<String> ids = new ArrayList<String>();
  12.         ids.add(“201610080”);
  13.         ids.add(“201610081”);
  14.         solrClient.deleteById(ids);
  15.         solrClient.commit(true, true);
  17.         //删除查询到的索引信息
  18.         solrClient.deleteByQuery(“id:201610082 id:201610083”);
  19.         solrClient.commit(true, true);
  21.     } catch (SolrServerException e) {
  22.         e.printStackTrace();
  23.     } catch (IOException e) {
  24.         e.printStackTrace();
  25.     }
  26. }
查询索引
  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”, “*”);
  16.         QueryResponse query;
  17.         try {
  18.             query = solrClient.query(params);
  19.             for (SolrDocument result :query.getResults()) {
  20.                 System.out.println(result);
  21.             }
  22.         } catch (SolrServerException e) {
  23.             e.printStackTrace();
  24.         } catch (IOException e) {
  25.             e.printStackTrace();
  26.         }
  28.     }

 

查询基本用法

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

分片查询

  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);
  14.         BookIndex index = new BookIndex();
  15.         index.setId(“201610090”);
  16.         index.setName(“小温之家-solr学习之路”);
  17.         index.setCat(“book”);
  18.         index.setPrice(6.66f);
  19.         index.setAuthor(“wenqy3”);
  20.         index.setInStock(true);
  22.         DocumentObjectBinder binder = new DocumentObjectBinder();
  23.         // BookIndex ->> SolrInputDocument
  24.         System.out.println(binder.toSolrInputDocument(index));
  25.         // SolrDocument ->> BookIndex
  26.         System.out.println(binder.getBean(BookIndex.class, doc));
  27.         SolrDocumentList list = new SolrDocumentList();
  28.         list.add(doc);
  29.         //SolrDocumentList ->> List
  30.         System.out.println(binder.getBeans(BookIndex.class, list));
  31.     }

实体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.     }
  57.     public String toString() {
  58.         return “{id:”+id+“,name:”+name+“,cat:”+cat+“,price:”+price+“,author:”+author+“,inStock:”+inStock+“}”;
  59.     }
  61. }

代码调用测试

  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的查询语法和复杂的查询功能有待挖掘。。。

小二，再来一碟

赏

发表评论

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

24 + 20 = ?