配置solr的maven坐标

1 springboot整合solr的maven配置如下

  1. <dependency>
  2.      <groupId>org.springframework.boot</groupId>
  3.      <artifactId>spring-boot-starter-data-solr</artifactId>
  4. </dependency>

2 在application.yml配置文件中配置solr的Host地址

  1. spring:
  2.   data:
  3.     solr:
  4.       host: http://localhost:8081/solr/demo_core

3 准备实体类

这个实体类就是solr服务器的配置文件配置的字段。@Field注解是映射作用，Java实体类与solr索引的映射。

  1. package com.datago.microservice.kb.server.entity;
  3. import com.fasterxml.jackson.databind.annotation.JsonSerialize;
  4. import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
  5. import io.swagger.annotations.ApiModelProperty;
  6. import lombok.Data;
  7. import org.apache.solr.client.solrj.beans.Field;
  9. import java.io.Serializable;
  11. /**
  12. * @author xq
  13. * @date 2022/03/22 16:33
  14. * @describe 全文检索知识库
  15. */
  16. @Data
  17. public class Knowledge implements Serializable {
  18.     private static final long serialVersionUID = 1L;
  20.     @Field("id")
  21.     private String id;
  23.     /**
  24.     * 标题
  25.     */
  26.     @ApiModelProperty(value = "标题")
  27.     @Field("title")
  28.     private String title;
  29.     /**
  30.     * 分类ID
  31.     */
  32.     @ApiModelProperty(value = "分类ID")
  33.     @JsonSerialize(
  34.         using = ToStringSerializer.class
  35.     )
  36.     @Field("category_id")
  37.     private String categoryId;
  39.     /**
  40.     * 内容
  41.     */
  42.     @ApiModelProperty(value = "内容")
  43.     @Field("content")
  44.     private String content;
  47.     /**
  48.     * 是否置顶，0-不置顶，1-置顶
  49.     */
  50.     @ApiModelProperty(value = "是否置顶，0-不置顶，1-置顶")
  51.     @Field("is_top")
  52.     private Integer isTop;
  54.     /**
  55.     * 附件ID集合
  56.     */
  57.     @ApiModelProperty(value = "附件ID集合")
  58.     @Field("attach_ids")
  59.     private String attachIds;
  61.     /**
  62.     * 标签IDS
  63.     */
  64.     @ApiModelProperty(value = "标签IDS")
  65.     @Field("label_ids")
  66.     private String labelIds;
  68.     /**
  69.     * 可见范围
  70.     */
  71.     @ApiModelProperty(value = "可见范围")
  72.     @Field("visible_range")
  73.     private String visibleRange;
  76.     /**
  77.     * 发布时间
  78.     */
  79.     @ApiModelProperty(value = "发布时间")
  80.     @Field("release_time")
  81.     private String releaseTime;
  84.     /**
  85.     * 关联模块:(1.元数据、2.数据标准、3.数据质量、4.需求管理)
  86.     */
  87.     @ApiModelProperty("关联模块:(1.元数据、2.数据标准、3.数据质量、4.需求管理)")
  88.     @Field("association_module")
  89.     private String associationModule;
  91.     @ApiModelProperty("创建人")
  92.     @Field("create_user")
  93.     private String createUser;
  96.     @ApiModelProperty("业务状态")
  97.     @Field("status")
  98.     private Integer status;
  100.     /**
  101.     * 类别祖籍列表
  102.     */
  103.     @ApiModelProperty(value = "是否删除")
  104.     @Field("is_deleted")
  105.     private Integer isDeleted;
  107.     /**
  108.     * 创建人名称
  109.     */
  110.     @ApiModelProperty(value = "创建人名称")
  111.     @Field("create_user_name")
  112.     private String createUserName;
  115.     /**
  116.     * 标签集合
  117.     */
  118.     @ApiModelProperty(value = "标签集合")
  119.     @Field("label")
  120.     private String label;
  122.     /**
  123.     * 标签名集合
  124.     */
  125.     @ApiModelProperty(value = "标签名集合")
  126.     @Field("label_name")
  127.     private String labelName;
  129.     /**
  130.     * 类别名称
  131.     */
  132.     @ApiModelProperty(value = "类别名称")
  133.     @Field("category_name")
  134.     private String categoryName;
  136.     /**
  137.     * 类别祖籍列表
  138.     */
  139.     @ApiModelProperty(value = "类别祖籍列表")
  140.     @Field("category_ancestors")
  141.     private String categoryAncestors;
  143.     /**
  144.     * 置顶时间
  145.     */
  146.     @ApiModelProperty(value = "置顶时间")
  147.     @Field("top_time")
  148.     private String topTime;
  150.     /**
  151.     * 创建部门
  152.     */
  153.     @ApiModelProperty(value = "创建部门")
  154.     @Field("create_dept")
  155.     private String createDept;
  157.     /**
  158.     * 创建部门名称
  159.     */
  160.     @ApiModelProperty(value = "创建部门名称")
  161.     @Field("create_dept_name")
  162.     private String createDeptName;
  164.     /**
  165.     * 创建时间
  166.     */
  167.     @ApiModelProperty(value = "创建时间")
  168.     @Field("create_time")
  169.     private String createTime;
  171.     /**
  172.     * 修改时间
  173.     */
  174.     @ApiModelProperty(value = "修改时间")
  175.     @Field("update_time")
  176.     private String updateTime;
  179.     /**
  180.     * 修改人名称
  181.     */
  182.     @ApiModelProperty(value = "修改人名称")
  183.     @Field("update_user")
  184.     private String updateUser;
  186.     /**
  187.     * 修改人名称
  188.     */
  189.     @ApiModelProperty(value = "修改人名称")
  190.     @Field("update_user_name")
  191.     private String updateUserName;
  194.     /**
  195.     * 关联模块:(1.元数据、2.数据标准、3.数据质量、4.需求管理)
  196.     */
  197.     @ApiModelProperty("关联模块:(1.元数据、2.数据标准、3.数据质量、4.需求管理)")
  198.     @Field("association_module_name")
  199.     private String associationModuleName;
  202.     /**
  203.     * 是否收藏,0-未收藏，1-已收藏
  204.     */
  205.     @ApiModelProperty(value = "是否收藏,0-未收藏，1-已收藏")
  206.     @Field("is_collect")
  207.     private Integer isCollect;
  209.     /**
  210.     * 平均分
  211.     */
  212.     @ApiModelProperty(value = "平均分")
  213.     @Field("avg_score")
  214.     private Double avgScore;
  216.     @ApiModelProperty(value = "内容")
  217.     @Field("content_text")
  218.     private String contentText;
  223. }

4 注入SolrClient对象

用法示例如下

  1. /**
  2. * solr服务
  3. */
  4. protected SolrClient solrClient;
  6. @Autowired
  7. public void setSolrClient(SolrClient solrClient) {
  8.     this.solrClient = solrClient;
  9.     }

4.1 springboot添加solr索引库（给solr数据库添加数据）

  1. public void addData() throws Exception{
  2.     Products products=new Products();
  3.     products.setPid("557");
  4.     products.setPname("可爱的胖");
  5.     products.setCatalogName("京东");
  6.     products.setPrice(80.90);
  7.     products.setDescription("很乖的宠物");
  8.     products.setPicture("test.jpg");
  9.     UpdateResponse updateResponse = solrClient.addBean(products);
  10.     solrClient.commit();
  11.     System.out.println("添加成功");
  12. }

4.2 springboot修改和上述的添加一样，有就修改，没有就添加

4.3 springboot删除solr索引库

  1. public void delData() throws Exception{
  2.        solrClient.deleteById("890");
  3.        solrClient.commit();
  4. //       solrClient.deleteByQuery("*:*");//先查询然后删除，*:* 这里查询条件是全部，因此执行之后会清空索引库
  5.         System.out.println("删除成功");
  6.     }

4.4 springboot查询solr索引库的数据

  1. public void select() throws Exception{
  2.         SolrQuery solrQuery=new SolrQuery("*:*");//查询所有
  3.         QueryResponse query = solrClient.query(solrQuery);
  5.         long numFound = query.getResults().getNumFound();
  6.         System.out.println("总记录数："+numFound);
  8.         List<Products> beans = query.getBeans(Products.class);
  9.         for(Products product:beans){
  10.             System.out.println(product.getPid()+"  "+product.getPname()+"  "+product.getDescription());
  11.         }
  12.     }

4.5 模仿京东条件筛选搜索

  1.  public void moreSelect() throws Exception{
  2.        SolrQuery solrQuery=new SolrQuery();
  3.        //q
  4.        solrQuery.set("q","prod_pname:衣服");
  5.        //fq：过滤查询
  6.        solrQuery.setFilterQueries("prod_catalog_name:京东");
  7. //       多条件过滤
  8. //        solrQuery.setFilterQueries("prod_catalog_name:京东 or prod_catalog_name:淘宝");
  9.         //价格过滤
  10. //        solrQuery.addFilterQuery("prod_price:[10 TO *]");
  11.         //排序sort
  12. //        solrQuery.addSort("prod_price",SolrQuery.ORDER.asc);
  13.         //分页(规则和limit一样)
  14.         solrQuery.setStart(0);
  15.         solrQuery.setRows(5);
  16.         //回显（想查出来哪几个字段）
  17. //        solrQuery.setFields("prod_name","pid");
  18.         //高亮配置
  19.         solrQuery.setHighlight(true);//启动高亮
  20.         solrQuery.addHighlightField("prod_pname");//设置域名称
  21.         solrQuery.setHighlightSimplePre("<font color='red'>");
  22.         solrQuery.setHighlightSimplePost("</font>");
  24.         QueryResponse query = solrClient.query(solrQuery);
  25.         //得到高亮数据
  26.         Map<String, Map<String, List<String>>> highlighting = query.getHighlighting();
  28.         long numFound = query.getResults().getNumFound();
  29.         System.out.println("总记录数："+numFound);
  31.         List<Products> beans = query.getBeans(Products.class);
  32.         for(Products product:beans){
  34.             Map<String, List<String>> stringListMap = highlighting.get(product.getPid());
  35.             List<String> prod_pname = stringListMap.get("prod_pname");
  36.             String pname = prod_pname.get(0);
  37.             product.setPname(pname);//把名称重新赋值为高亮样式的名称
  38.             System.out.println(product.getPid()+"  "+product.getPname()+" "+product.getCatalogName());
  39.         }
  40.     }

5 Solr工具

5.1 solr service

  1. package com.datago.microservice.kb.server.service;
  3. import com.datago.microservice.kb.server.enums.SolrQueryEnum;
  4. import org.apache.solr.client.solrj.SolrQuery;
  5. import org.apache.solr.client.solrj.SolrServerException;
  6. import org.apache.solr.client.solrj.response.QueryResponse;
  7. import org.apache.solr.common.SolrInputDocument;
  9. import java.io.IOException;
  10. import java.util.List;
  11. import java.util.Map;
  13. /**
  14.  * @author xq
  15.  * @date 2022/02/16 11:24
  16.  * @describe
  17.  */
  18. public interface BaseSolrService<T> {
  19.     String OR = " OR ";
  20.     String AND = " AND ";
  21.     String REGEX = "%s";
  22.     String KEY = "id";
  23.     String KEY_FIELD = "id:";
  25.     String DOCS = "docs";
  26.     String RESPONSE = "response";
  27.     String START = "start";
  28.     String NUMBER_FOUND = "numberFound";
  29.     String ROWS = "rows";
  31.     String OPEN = "(";
  32.     String CLOSE = ")";
  34.     String IS_HIGH = "isHigh";
  36.     /**
  37.      * 插入
  38.      *
  39.      * @param document 数据导入
  40.      * @throws IOException         IO异常
  41.      * @throws SolrServerException solr服务异常
  42.      */
  43.     void insert(SolrInputDocument document) throws IOException, SolrServerException;
  45.     /**
  46.      * 插入
  47.      *
  48.      * @param core     核心
  49.      * @param document 数据导入
  50.      * @throws IOException         IO异常
  51.      * @throws SolrServerException solr服务异常
  52.      */
  53.     void insert(String core, SolrInputDocument document) throws IOException, SolrServerException;
  55.     /**
  56.      * 插入
  57.      *
  58.      * @param core     核心
  59.      * @param document 数据导入
  60.      * @throws IOException         IO异常
  61.      * @throws SolrServerException solr服务异常
  62.      */
  63.     void insertBatch(String core, List<SolrInputDocument> document) throws IOException, SolrServerException;
  65.     /**
  66.      * 插入
  67.      *
  68.      * @param core 核心
  69.      * @param t    数据实体
  70.      * @throws IOException         IO异常
  71.      * @throws SolrServerException solr服务异常
  72.      */
  73.     void insertBean(String core, T t) throws IOException, SolrServerException;
  75.     /**
  76.      * 修改
  77.      *
  78.      * @param t 数据实体
  79.      * @throws IOException         IO异常
  80.      * @throws SolrServerException solr服务异常
  81.      */
  82.     void update(T t) throws IOException, SolrServerException;
  84.     /**
  85.      * 删除
  86.      *
  87.      * @param query 条件
  88.      * @throws IOException         IO异常
  89.      * @throws SolrServerException solr服务异常
  90.      */
  91.     void delete(String query) throws IOException, SolrServerException;
  93.     /**
  94.      * 根据条件删除
  95.      *
  96.      * @param core  核心
  97.      * @param query 条件
  98.      * @throws IOException         IO异常
  99.      * @throws SolrServerException solr服务异常
  100.      */
  101.     void delete(String core, String query) throws IOException, SolrServerException;
  103.     /**
  104.      * 删除
  105.      *
  106.      * @param core  核心
  107.      * @param query 条件
  108.      * @throws IOException         IO异常
  109.      * @throws SolrServerException solr服务异常
  110.      */
  111.     void delete(String core, List<String> query) throws IOException, SolrServerException;
  113.     /**
  114.      * 查询（返回指定类型）
  115.      *
  116.      * @param collection 核心
  117.      * @param solrQuery  条件
  118.      * @param clazz      对象
  119.      * @return List
  120.      * @throws IOException         IO异常
  121.      * @throws SolrServerException solr服务异常
  122.      */
  123.     List<T> select(String collection, SolrQuery solrQuery, Class<T> clazz) throws IOException, SolrServerException;
  125.     /**
  126.      * 查询
  127.      *
  128.      * @param collection 核心
  129.      * @param solrQuery  条件
  130.      * @return QueryResponse
  131.      * @throws IOException         IO异常
  132.      * @throws SolrServerException solr服务异常
  133.      */
  134.     QueryResponse select(String collection, SolrQuery solrQuery) throws IOException, SolrServerException;
  137.     /**
  138.      * 查询（支持高亮设置）
  139.      *
  140.      * @param collection 核心
  141.      * @param query      条件
  142.      * @param field      查询列
  143.      * @param key        主键字段名
  144.      * @param clazz      对象
  145.      * @param isHigh     是否高亮显示
  146.      * @return List
  147.      * @throws IOException         IO异常
  148.      * @throws SolrServerException solr服务异常
  149.      */
  150.     List<T> select(String collection, SolrQuery query, String[] field, String key, Class<T> clazz, Boolean isHigh) throws SolrServerException, IOException;
  153.     /**
  154.      * 查询(支持高亮显示)
  155.      *
  156.      * @param collection 核心
  157.      * @param query      条件
  158.      * @param field      查询列
  159.      * @param key        主键字段名
  160.      * @param clazz      对象
  161.      * @param isHigh     是否高亮显示
  162.      * @return Map
  163.      * @throws IOException         IO异常
  164.      * @throws SolrServerException solr服务异常
  165.      */
  166.     Map<String, Object> selectMap(String collection, SolrQuery query, String[] field, String key, Class<T> clazz, Boolean isHigh) throws SolrServerException, IOException;
  169.     /**
  170.      * 查询
  171.      *
  172.      * @param collection       核心
  173.      * @param keyword          条件
  174.      * @param ids              准备加入的条件
  175.      * @param conditionKey     准备加入的条件字段名
  176.      * @param current          开始下标
  177.      * @param size             索引行数
  178.      * @param field            高亮字段
  179.      * @param key              主键
  180.      * @param clazz            对象
  181.      * @param isHigh           是否高亮
  182.      * @param isAutoPermission 是否权限过滤
  183.      * @return List
  184.      * @throws IOException         IO异常
  185.      * @throws SolrServerException solr服务异常
  186.      */
  187.     List<T> select(String collection, String keyword, List<String> ids, String conditionKey, Integer current, Integer size, String[] field, String key, Class<T> clazz, Boolean isHigh, Boolean isAutoPermission) throws SolrServerException, IOException;
  190.     /**
  191.      * 查询
  192.      *
  193.      * @param collection       核心
  194.      * @param keyword          条件
  195.      * @param fq               过滤条件
  196.      * @param ids              准备加入的条件
  197.      * @param conditionKey     准备加入的条件字段名
  198.      * @param current          开始下标
  199.      * @param size             索引行数
  200.      * @param field            高亮字段
  201.      * @param key              主键
  202.      * @param clazz            对象
  203.      * @param isHigh           是否高亮
  204.      * @param isAutoPermission 是否权限过滤
  205.      * @return List
  206.      * @throws IOException         IO异常
  207.      * @throws SolrServerException solr服务异常
  208.      */
  209.     List<T> select(String collection, String keyword, String fq, List<String> ids, String conditionKey, Integer current, Integer size, String[] field, String key, Class<T> clazz, Boolean isHigh, Boolean isAutoPermission) throws SolrServerException, IOException;
  212.     /**
  213.      * 查询
  214.      *
  215.      * @param collection       核心
  216.      * @param keyword          条件
  217.      * @param ids              准备加入的条件
  218.      * @param conditionKey     准备加入的条件字段名
  219.      * @param current          开始下标
  220.      * @param size             索引行数
  221.      * @param field            高亮字段
  222.      * @param key              主键
  223.      * @param clazz            对象
  224.      * @param isHigh           是否高亮显示
  225.      * @param isAutoPermission 是否权限过滤
  226.      * @param sort             排序
  227.      * @param queryEnum        权限配置方式
  228.      * @return Map
  229.      * @throws IOException         IO异常
  230.      * @throws SolrServerException solr服务异常
  231.      */
  232.     Map<String, Object> selectMap(String collection, String keyword, List<String> ids, String conditionKey,
  233.                                   Integer current, Integer size, String[] field, String key, Class<T> clazz,
  234.                                   Boolean isHigh, Boolean isAutoPermission, String sort, SolrQueryEnum queryEnum) throws SolrServerException, IOException;
  236.     /**
  237.      * 查询
  238.      *
  239.      * @param collection       核心
  240.      * @param keyword          条件
  241.      * @param fq               过滤条件
  242.      * @param ids              准备加入的条件
  243.      * @param conditionKey     准备加入的条件字段名
  244.      * @param current          开始下标
  245.      * @param size             索引行数
  246.      * @param field            高亮字段
  247.      * @param key              主键
  248.      * @param clazz            对象
  249.      * @param isHigh           是否高亮显示
  250.      * @param isAutoPermission 是否权限过滤
  251.      * @param sort             排序
  252.      * @param queryEnum        权限配置方式
  253.      * @return Map
  254.      * @throws IOException         IO异常
  255.      * @throws SolrServerException solr服务异常
  256.      */
  257.     Map<String, Object> selectMap(String collection, String keyword, String fq, List<String> ids, String conditionKey,
  258.                                   Integer current, Integer size, String[] field, String key, Class<T> clazz,
  259.                                   Boolean isHigh, Boolean isAutoPermission, String sort, SolrQueryEnum queryEnum) throws SolrServerException, IOException;
  262.     /**
  263.      * 生成条件
  264.      *
  265.      * @param keyword          条件
  266.      * @param ids              多值条件
  267.      * @param conditionKey     拼接的条件key
  268.      * @param current          分页参数
  269.      * @param size             分页参数
  270.      * @param field            高亮字段
  271.      * @param isAutoPermission 是否附带权限
  272.      * @param sort             排序
  273.      * @param queryEnum        权限配置方式
  274.      * @param isHigh           是否高亮
  275.      * @return SolrQuery
  276.      */
  277.     SolrQuery getQuery(String keyword, List<String> ids, String conditionKey, Integer current, Integer size,
  278.                        String[] field, Boolean isAutoPermission, String sort, SolrQueryEnum queryEnum, Boolean isHigh);
  280.     /**
  281.      * 生成条件
  282.      *
  283.      * @param keyword          条件
  284.      * @param fq               过滤条件
  285.      * @param ids              多值条件
  286.      * @param conditionKey     拼接的条件key
  287.      * @param current          分页参数
  288.      * @param size             分页参数
  289.      * @param field            高亮字段
  290.      * @param isAutoPermission 是否附带权限
  291.      * @param sort             排序
  292.      * @param queryEnum        权限配置方式
  293.      * @param isHigh           是否高亮
  294.      * @return SolrQuery
  295.      */
  296.     SolrQuery getQuery(String keyword, String fq, List<String> ids, String conditionKey, Integer current, Integer size,
  297.                        String[] field, Boolean isAutoPermission, String sort, SolrQueryEnum queryEnum, Boolean isHigh);
  300.     /**
  301.      * 日志输出
  302.      *
  303.      * @param solrQuery 条件
  304.      */
  305.     void printQuery(SolrQuery solrQuery);
  307.     /**
  308.      * 增加权限
  309.      *
  310.      * @param keyword   条件
  311.      * @param queryEnum 权限配置方式
  312.      * @return String
  313.      */
  314.     String addPermission(String keyword, SolrQueryEnum queryEnum);
  315. }

5.2 solr service实现类

  1. package com.datago.microservice.kb.server.service.impl;
  3. import cn.hutool.core.util.ObjectUtil;
  4. import cn.hutool.json.JSONUtil;
  5. import com.datago.microservice.kb.common.utils.Func;
  6. import com.datago.microservice.kb.server.enums.ParamEnum;
  7. import com.datago.microservice.kb.server.enums.SolrQueryEnum;
  8. import com.datago.microservice.kb.server.service.BaseSolrService;
  9. import com.datago.microservice.kb.server.utils.cache.ParamCache;
  10. import com.datago.microservice.kb.server.utils.common.SolrUtil;
  11. import com.datago.microservice.kb.server.utils.common.TokenUtil;
  12. import com.datago.microservice.kb.server.vo.SysUserVO;
  13. import org.apache.solr.client.solrj.SolrClient;
  14. import org.apache.solr.client.solrj.SolrQuery;
  15. import org.apache.solr.client.solrj.SolrRequest;
  16. import org.apache.solr.client.solrj.SolrServerException;
  17. import org.apache.solr.client.solrj.response.QueryResponse;
  18. import org.apache.solr.common.SolrDocumentList;
  19. import org.apache.solr.common.SolrInputDocument;
  20. import org.slf4j.Logger;
  21. import org.slf4j.LoggerFactory;
  22. import org.springframework.beans.factory.annotation.Autowired;
  23. import org.springframework.stereotype.Service;
  25. import java.io.IOException;
  26. import java.util.HashMap;
  27. import java.util.List;
  28. import java.util.Map;
  30. /**
  31.  * @author xq
  32.  * @date 2022/02/16 14:57
  33.  * @describe
  34.  */
  35. @Service
  36. public class BaseSolrServiceImpl<T> implements BaseSolrService<T> {
  37.     private static final Logger log = LoggerFactory.getLogger(BaseSolrService.class);
  39.     /**
  40.      * solr服务
  41.      */
  42.     protected SolrClient solrClient;
  44.     @Autowired
  45.     public void setSolrClient(SolrClient solrClient) {
  46.         this.solrClient = solrClient;
  47.     }
  50.     @Override
  51.     public void insert(SolrInputDocument document) throws IOException, SolrServerException {
  52.         solrClient.add(document);
  53.         // 提交
  54.         solrClient.commit(true, true);
  55.     }
  57.     @Override
  58.     public void insert(String core, SolrInputDocument document) throws IOException, SolrServerException {
  59.         solrClient.add(core, document);
  60.         // 提交
  61.         solrClient.commit(core, true, true);
  62.     }
  64.     @Override
  65.     public void insertBatch(String core, List<SolrInputDocument> document) throws IOException, SolrServerException {
  66.         solrClient.add(core, document);
  67.         // 提交
  68.         solrClient.commit(core, true, true);
  69.     }
  71.     @Override
  72.     public void insertBean(String core, T t) throws IOException, SolrServerException {
  73.         solrClient.addBean(core, t);
  74.         // 提交
  75.         solrClient.commit(core, true, true);
  76.     }
  78.     @Override
  79.     public void update(T t) throws IOException, SolrServerException {
  80.         solrClient.addBean(t);
  81.         // 提交
  82.         solrClient.commit(true, true);
  83.     }
  85.     @Override
  86.     public void delete(String query) throws IOException, SolrServerException {
  87.         solrClient.deleteByQuery(query);
  88.         // 提交
  89.         solrClient.commit(true, true);
  90.     }
  92.     @Override
  93.     public void delete(String core, String query) throws IOException, SolrServerException {
  94.         solrClient.deleteByQuery(core, query);
  95.         // 提交
  96.         solrClient.commit(core, true, true);
  97.     }
  99.     @Override
  100.     public void delete(String core, List<String> query) throws IOException, SolrServerException {
  101.         solrClient.deleteById(core, query);
  102.         solrClient.commit(core, true, true);
  103.     }
  105.     @Override
  106.     public List<T> select(String collection, SolrQuery solrQuery, Class<T> clazz) throws IOException, SolrServerException {
  107.         // 查询
  108.         QueryResponse queryResponse = solrClient.query(collection, solrQuery, SolrRequest.METHOD.POST);
  109.         // 将查询结果转换指定元素类型的集合
  110.         return queryResponse.getBeans(clazz);
  111.     }
  113.     @Override
  114.     public QueryResponse select(String collection, SolrQuery solrQuery) throws IOException, SolrServerException {
  115.         return solrClient.query(collection, solrQuery,SolrRequest.METHOD.POST);
  116.     }
  118.     @Override
  119.     public List<T> select(String collection, SolrQuery query, String[] field, String key, Class<T> clazz, Boolean isHigh) throws SolrServerException, IOException {
  120.         QueryResponse response = select(collection, query);
  122.         // 获得高亮的结果
  123.         Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
  125.         List<T> list = response.getBeans(clazz);
  126.         // 设置高亮内容
  127.         SolrUtil.setHlContent(list, field, key, highlighting, isHigh);
  128.         return list;
  129.     }
  131.     @Override
  132.     public Map<String, Object> selectMap(String collection, SolrQuery query, String[] field, String key, Class<T> clazz, Boolean isHigh) throws SolrServerException, IOException {
  133.         QueryResponse response = select(collection, query);
  135.         // 获得高亮的结果
  136.         Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();
  138.         Map<String, Object> map = new HashMap<>(8);
  139.         // 设置高亮内容
  140.         List<T> list = response.getBeans(clazz);
  141.         SolrDocumentList results = response.getResults();
  142.         SolrUtil.setHlContent(list, field, key, highlighting, isHigh);
  143.         // 设置分页属性
  144.         map.put(ROWS, query.getRows());
  145.         map.put(START, results.getStart());
  146.         map.put(NUMBER_FOUND, results.getNumFound());
  147.         map.put(DOCS, list);
  148.         return map;
  149.     }
  152.     @Override
  153.     public List<T> select(String collection, String keyword, List<String> ids, String conditionKey, Integer current, Integer size,
  154.                           String[] field, String key, Class<T> clazz, Boolean isHigh, Boolean isAutoPermission) throws SolrServerException, IOException {
  155.         return select(collection, keyword, null, ids, conditionKey, current, size, field, key, clazz, isHigh, isAutoPermission);
  156.     }
  158.     @Override
  159.     public List<T> select(String collection, String keyword, String fq, List<String> ids, String conditionKey, Integer current, Integer size, String[] field, String key, Class<T> clazz, Boolean isHigh, Boolean isAutoPermission) throws SolrServerException, IOException {
  160.         // 组织条件
  161.         SolrQuery query = getQuery(keyword, fq, ids, conditionKey, current, size, field, isAutoPermission, null, SolrQueryEnum.QUERY, isHigh);
  163.         return select(collection, query, field, key, clazz, isHigh);
  164.     }
  167.     @Override
  168.     public Map<String, Object> selectMap(String collection, String keyword, List<String> ids, String conditionKey,
  169.                                          Integer current, Integer size, String[] field, String key, Class<T> clazz,
  170.                                          Boolean isHigh, Boolean isAutoPermission, String sort, SolrQueryEnum queryEnum) throws SolrServerException, IOException {
  171.         return selectMap(collection, keyword, null, ids, conditionKey, current, size, field, key, clazz, isHigh, isAutoPermission, sort, queryEnum);
  172.     }
  174.     @Override
  175.     public Map<String, Object> selectMap(String collection, String keyword, String fq, List<String> ids, String conditionKey, Integer current, Integer size, String[] field, String key, Class<T> clazz, Boolean isHigh, Boolean isAutoPermission, String sort, SolrQueryEnum queryEnum) throws SolrServerException, IOException {
  176.         // 组织条件
  177.         SolrQuery query = getQuery(keyword, fq, ids, conditionKey, current, size, field, isAutoPermission, sort, queryEnum, isHigh);
  179.         return selectMap(collection, query, field, key, clazz, isHigh);
  180.     }
  182.     /**
  183.      * 生成条件
  184.      *
  185.      * @param keyword          条件
  186.      * @param ids              多值条件
  187.      * @param conditionKey     拼接的条件key
  188.      * @param current          分页参数
  189.      * @param size             分页参数
  190.      * @param field            高亮字段
  191.      * @param isAutoPermission 是否附带权限
  192.      * @return SolrQuery
  193.      */
  194.     @Override
  195.     public SolrQuery getQuery(String keyword, List<String> ids, String conditionKey, Integer current, Integer size,
  196.                               String[] field, Boolean isAutoPermission, String sort, SolrQueryEnum queryEnum, Boolean isHigh) {
  197.         return getQuery(keyword, null, ids, conditionKey, current, size, field, isAutoPermission, sort, queryEnum, isHigh);
  198.     }
  200.     @Override
  201.     public SolrQuery getQuery(String keyword, String fq, List<String> ids, String conditionKey, Integer current, Integer size, String[] field, Boolean isAutoPermission, String sort, SolrQueryEnum queryEnum, Boolean isHigh) {
  202.         SolrQuery query = new SolrQuery();
  203.         if (ObjectUtil.isEmpty(size)) {
  204.             size = 10;
  205.         }
  206.         if (ObjectUtil.isEmpty(current)) {
  207.             current = 0;
  208.         }
  209.         // 如果高亮则代表输入了关键字
  210.         if (isHigh) {
  211.             keyword = SolrUtil.conditions(keyword, ids, conditionKey, OR);
  212.         }
  214.         // 过滤条件
  215.         if (ObjectUtil.isNotEmpty(fq)) {
  216.             query.setFilterQueries(fq);
  217.         }
  219.         // 是否增加权限控制
  220.         if (isAutoPermission) {
  221.             keyword = addPermission(keyword, queryEnum);
  222.         }
  224.         query.add("q", keyword);
  226.         // 增加排序
  227.         if (ObjectUtil.isNotEmpty(sort)) {
  228.             List<SolrQuery.SortClause> clauses = SolrUtil.sort(sort);
  229.             if (ObjectUtil.isNotEmpty(clauses)) {
  230.                 query.setSorts(clauses);
  231.             }
  232.         }
  234.         // 设置高亮
  235.         SolrUtil.setHl(query, field);
  237.         // 设置分页
  238.         query.setStart(current);
  239.         query.setRows(size);
  241.         printQuery(query);
  242.         return query;
  243.     }
  246.     /**
  247.      * 日志输出
  248.      *
  249.      * @param solrQuery 条件
  250.      */
  251.     @Override
  252.     public void printQuery(SolrQuery solrQuery) {
  253.         Map map = solrQuery.toMap(new HashMap<>(1));
  254.         String jsonStr = JSONUtil.toJsonStr(map);
  255.         log.info("solr查询条件：" + jsonStr);
  256.     }
  258.     /**
  259.      * 增加权限
  260.      *
  261.      * @param keyword 条件
  262.      * @return String
  263.      */
  264.     @Override
  265.     public String addPermission(String keyword, SolrQueryEnum queryEnum) {
  266.         SysUserVO user = TokenUtil.getUser();
  267.         String value = ParamCache.getValue(ParamEnum.KNOWLEDGE_BASE_ROLE_NAME.getKey());
  268.         value = ObjectUtil.isEmpty(value) ? ParamEnum.KNOWLEDGE_BASE_ROLE_NAME.getValue() : value;
  269.         List<String> list = Func.toStrList(value);
  271.         // 权限控制
  272.         String permission = OPEN.concat(keyword).concat(CLOSE).concat(AND).concat(OPEN);
  273.         // 普通人员权限
  274.         String purview = "";
  275.         // 管理人员权限
  276.         String adminPurview = "";
  277.         switch (queryEnum) {
  278.             // 管理页面、回收站页面只可查看自己的数据
  279.             case MANAGER:
  280.                 purview = permission
  281.                         // 创建用户可看
  282.                         .concat("create_user:").concat(user.getUserId())
  283.                         .concat(AND).concat("is_deleted:0")
  284.                         .concat(CLOSE);
  285.                 adminPurview = permission.concat("is_deleted:0").concat(CLOSE);
  286.                 break;
  287.             case IS_DELETED:
  288.                 purview = permission
  289.                         // 创建用户可看
  290.                         .concat("create_user:").concat(user.getUserId())
  291.                         .concat(AND).concat("is_deleted:1")
  292.                         .concat(CLOSE);
  293.                 adminPurview = permission.concat("is_deleted:1").concat(CLOSE);
  294.                 break;
  295.             // 查询页面可看 visible_range:ALL 或者 visible_range:自己部门 或者 自己创建的
  296.             case QUERY:
  297.                 purview = permission.concat("visible_range:ALL")
  298.                         // 用户当前部门可看
  299.                         .concat(OR).concat("visible_range:*").concat(user.getOrgNo()).concat("*")
  300.                         // 创建用户可看
  301.                         .concat(OR).concat("create_user:").concat(user.getUserId())
  302.                         .concat(CLOSE);
  303.                 adminPurview = permission.concat("is_deleted:0").concat(CLOSE);
  304.                 break;
  305.             // 收藏页面因用户收藏的数据已作为条件，故不做权限控制
  306.             case COLLECT:
  307.             default:
  308.                 purview = keyword;
  309.                 adminPurview = keyword;
  310.                 break;
  311.         }
  313.         // 知识库管理员权限校验
  314.         if (ObjectUtil.isNotEmpty(list)) {
  315.             for (String var2 : list) {
  316.                 if (user.getRole().contains(var2)) {
  317.                     return adminPurview;
  318.                 }
  319.             }
  320.         }
  322.         return purview;
  324.     }
  327. }