工程搭建

1. 创建SpringBoot工程

以IntelliJ IDEA为例，创建“Spring Initializr”或“Maven”工程。
image.png
组件选择如下：

  • Developer Tools
    • Spring Boot DevTools
    • Lombok
  • Web
    • Spring Web
  • NoSQL
    • Spring Data for Apache Solr

image.png

2. 添加pom.xml依赖

如果创建的Maven工程，则可手动添加Solr集成相关依赖。

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-solr</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.boot</groupId>
  7.     <artifactId>spring-boot-starter-web</artifactId>
  8. </dependency>

Solr连接

1. 通过Solr URL连接

  • application.yml

    1. spring:  
    2. application:
    3.   name: solr-demo
    4. data:
    5.   solr:
    6.      host: http://bigdata-node1:8983/solr/db_sync
    7. server:
    8. port: 8081

  • application.properties

    1. spring.application.name=solr-springboot-example
    2. server.port=8081
    3. # solr Configuration
    4. spring.data.solr.host=http://bigdata-node1:8983/solr/db_sync

    2. 通过ZooKeeper连接

  • application.yml

    1. spring:
    2. application:
    3.   name: solr-springboot-example
    4. data:
    5.   solr:
    6.     zk-host: 192.168.0.101:2181,192.168.0.102:2181,192.168.0.103:2181
    7. server:
    8. port: 8081

  • application.properties

    1. spring.application.name=solr-springboot-example
    2. server.port=8081
    3. # solr Configuration
    4. spring.data.solr.zk-host=192.168.0.101:2181,192.168.0.102:2181,192.168.0.103:2181

    案例

    01. 简单示例

    1. 分页查询

    ```java import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.SolrQuery; import org.apache.solr.client.solrj.SolrServerException; import org.apache.solr.client.solrj.impl.CloudSolrClient; import org.apache.solr.client.solrj.response.QueryResponse; import org.apache.solr.common.SolrDocument; import org.apache.solr.common.SolrDocumentList; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import java.io.IOException;

@SpringBootTest public class SolrSampleTests {

  1. @Autowired
  2. private SolrClient solrClient;
  4. /**
  5.  * 测试：分页查找
  6.  */
  7. @Test
  8. public void findPage() throws IOException, SolrServerException {
  9.     /**
  10.      * 集群版CloudSolrClient继承自SolrClient，需要进行强转
  11.      * 单机版不需要，直接可以使用solrClient
  12.      */
  13.     CloudSolrClient cloudSolrClient = (CloudSolrClient) solrClient;
  14.     // 设置默认的操作实例
  15.     cloudSolrClient.setDefaultCollection("db_sync");
  16.     // 设置查找的参数
  17.     SolrQuery query = new SolrQuery();
  19.     query.setQuery("title:中国");
  20.     // 第?页
  21.     query.setStart(0);
  22.     // 每页记录数
  23.     query.setRows(5);
  24.     // 执行查找
  25.     QueryResponse response = cloudSolrClient.query(query);
  26.     SolrDocumentList documentList = response.getResults();
  28.     for (SolrDocument entries : documentList) {
  29.         String title = (String) entries.getFieldValue("title");
  30.         String id = (String) entries.getFieldValue("id");
  31.         System.out.println(id + "-->" + title);
  32.     }
  33. }

}

  1. <a name="KHlW8"></a>
  2. ### 2. 高亮显示
  3. ```java
  4. import org.apache.solr.client.solrj.SolrClient;
  5. import org.apache.solr.client.solrj.SolrQuery;
  6. import org.apache.solr.client.solrj.SolrServerException;
  7. import org.apache.solr.client.solrj.impl.CloudSolrClient;
  8. import org.apache.solr.client.solrj.response.QueryResponse;
  9. import org.apache.solr.common.SolrDocument;
  10. import org.apache.solr.common.SolrDocumentList;
  11. import org.junit.jupiter.api.Test;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.boot.test.context.SpringBootTest;
  14. import java.io.IOException;
  16. @SpringBootTest
  17. public class SolrSampleTests {
  19.     @Autowired
  20.     private SolrClient solrClient;
  22.     /**
  23.      * 设置结果高亮显示
  24.      *
  25.      * @throws IOException
  26.      * @throws SolrServerException
  27.      */
  28.     @Test
  29.     public void highlight() throws IOException, SolrServerException {
  30.         /**
  31.          * 集群版CloudSolrClient继承自SolrClient，需要进行强转
  32.          * 单机版不需要，直接可以使用solrClient
  33.          */
  34.         CloudSolrClient cloudSolrClient = (CloudSolrClient) solrClient;
  35.         // 设置默认的操作实例
  36.         cloudSolrClient.setDefaultCollection("db_sync");
  37.         // 设置查找的参数
  38.         SolrQuery query = new SolrQuery();
  39.         query.setQuery("title:中国");
  40.         // 开启高亮
  41.         query.setHighlight(true);
  42.         // 设置高亮字段
  43.         query.addHighlightField("title");
  44.         // 前缀
  45.         query.setHighlightSimplePre("<font color='red'>");
  46.         // 后缀
  47.         query.setHighlightSimplePost("</font>");
  48.         // 执行查找
  49.         QueryResponse response = cloudSolrClient.query(query);
  50.         // 打印高亮信息
  51.         System.out.println(response.getHighlighting());
  52.     }
  54. }

02. 综合示例

1. 添加pom.xml依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.3.3.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.lonton.bigdata</groupId>
  12.     <artifactId>solr-springboot-example</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>solr-springboot-example</name>
  15.     <description>Solr SpringBoot集成</description>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.     </properties>
  21.     <dependencies>
  22.         <dependency>
  23.             <groupId>org.springframework.boot</groupId>
  24.             <artifactId>spring-boot-starter-data-solr</artifactId>
  25.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework.boot</groupId>
  29.             <artifactId>spring-boot-starter-web</artifactId>
  30.         </dependency>
  32.         <dependency>
  33.             <groupId>org.springframework.boot</groupId>
  34.             <artifactId>spring-boot-devtools</artifactId>
  35.             <scope>runtime</scope>
  36.             <optional>true</optional>
  37.         </dependency>
  39.         <dependency>
  40.             <groupId>org.projectlombok</groupId>
  41.             <artifactId>lombok</artifactId>
  42.             <optional>true</optional>
  43.         </dependency>
  45.         <dependency>
  46.             <groupId>org.springframework.boot</groupId>
  47.             <artifactId>spring-boot-starter-test</artifactId>
  48.             <scope>test</scope>
  49.             <!-- 这个是JUnit5中为了支持使用JUint4所做的一个过度
  50.                 也就是说，你只需要在你的JUnit4旧项目中添加这个依赖，
  51.                 就能完美过渡，而不用修改之前代码
  52.                 这里用不到，自然也就排除了。
  53.             -->
  54.             <exclusions>
  55.                 <exclusion>
  56.                     <groupId>org.junit.vintage</groupId>
  57.                     <artifactId>junit-vintage-engine</artifactId>
  58.                 </exclusion>
  59.             </exclusions>
  60.         </dependency>
  62.         <!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
  63.         <dependency>
  64.             <groupId>commons-beanutils</groupId>
  65.             <artifactId>commons-beanutils</artifactId>
  66.             <version>1.9.3</version>
  67.         </dependency>
  69.         <dependency>
  70.             <groupId>com.alibaba</groupId>
  71.             <artifactId>fastjson</artifactId>
  72.             <version>1.2.61</version>
  73.         </dependency>
  75.         <dependency>
  76.             <groupId>org.assertj</groupId>
  77.             <artifactId>assertj-core</artifactId>
  78.             <version>3.11.1</version>
  79.             <scope>compile</scope>
  80.         </dependency>
  82.         <dependency>
  83.             <groupId>com.google.guava</groupId>
  84.             <artifactId>guava</artifactId>
  85.             <version>25.0-jre</version>
  86.             <scope>compile</scope>
  87.         </dependency>
  89.     </dependencies>
  91.     <build>
  92.         <plugins>
  93.             <plugin>
  94.                 <groupId>org.springframework.boot</groupId>
  95.                 <artifactId>spring-boot-maven-plugin</artifactId>
  96.             </plugin>
  98.             <!-- 将生成的jar复制到指定路径 -->
  99.             <plugin>
  100.                 <artifactId>maven-antrun-plugin</artifactId>
  101.                 <executions>
  102.                     <execution>
  103.                         <!-- 在maven进行package的时候执行-->
  104.                         <phase>package</phase>
  105.                         <configuration>
  106.                             <tasks>
  107.                                 <!-- jar包保存位置 -->
  108.                                 <copy todir="E:\vagrant\mybox\bigdata_example\share">
  109.                                     <!-- antrun自动生成的配置文件的保存位置，这里默认是父项目的target文件夹 -->
  110.                                     <fileset dir="${project.build.directory}">
  111.                                         <include name="*.jar"/>
  112.                                     </fileset>
  113.                                 </copy>
  114.                             </tasks>
  115.                         </configuration>
  116.                         <goals>
  117.                             <goal>run</goal>
  118.                         </goals>
  119.                     </execution>
  120.                 </executions>
  121.             </plugin>
  123.         </plugins>
  126.         <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
  127.             <plugins>
  128.                 <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
  129.                 <plugin>
  130.                     <artifactId>maven-clean-plugin</artifactId>
  131.                     <version>3.1.0</version>
  132.                 </plugin>
  133.                 <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
  134.                 <plugin>
  135.                     <artifactId>maven-resources-plugin</artifactId>
  136.                     <version>3.0.2</version>
  137.                 </plugin>
  138.                 <plugin>
  139.                     <groupId>org.apache.maven.plugins</groupId>
  140.                     <artifactId>maven-compiler-plugin</artifactId>
  141.                     <version>3.8.0</version>
  142.                     <configuration>
  143.                         <source>1.8</source>
  144.                         <target>1.8</target>
  145.                         <encoding>UTF-8</encoding>
  146.                     </configuration>
  147.                 </plugin>
  148.                 <plugin>
  149.                     <artifactId>maven-surefire-plugin</artifactId>
  150.                     <version>2.22.1</version>
  151.                 </plugin>
  152.                 <plugin>
  153.                     <artifactId>maven-jar-plugin</artifactId>
  154.                     <version>3.0.2</version>
  155.                 </plugin>
  156.                 <plugin>
  157.                     <artifactId>maven-install-plugin</artifactId>
  158.                     <version>2.5.2</version>
  159.                 </plugin>
  160.                 <plugin>
  161.                     <artifactId>maven-deploy-plugin</artifactId>
  162.                     <version>2.8.2</version>
  163.                 </plugin>
  164.                 <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
  165.                 <plugin>
  166.                     <artifactId>maven-site-plugin</artifactId>
  167.                     <version>3.7.1</version>
  168.                 </plugin>
  169.                 <plugin>
  170.                     <artifactId>maven-project-info-reports-plugin</artifactId>
  171.                     <version>3.0.0</version>
  172.                 </plugin>
  174.             </plugins>
  175.         </pluginManagement>
  176.     </build>
  178. </project>

2. 工程配置

■ 配置（application.properties）

  1. spring.application.name=solr-springboot-example
  2. server.port=8081
  3. # solr Configuration
  4. spring.data.solr.zk-host=192.168.0.101:2181,192.168.0.102:2181,192.168.0.103:2181

3. 编写关键类

■ SolrClient配置（以下方法二选其一）

  1. 启动加载类（SolrClientRunner.java） ```java import org.apache.solr.client.solrj.SolrClient; import org.apache.solr.client.solrj.impl.CloudSolrClient; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.ApplicationArguments; import org.springframework.boot.ApplicationRunner; import org.springframework.stereotype.Component;

/**

  • Description 启动加载类（配置CloudSolrClient） */ @Component public class SolrClientRunner implements ApplicationRunner {

    @Autowired private SolrClient client;

    @Override public void run(ApplicationArguments args) throws Exception {

    1.  /**
    2.   * 集群版CloudSolrClient继承自SolrClient，需要进行强转
    3.   * 单机版不需要，直接可以使用solrClient
    4.   */
    5.  // SolrClient client=SpringUtil.getBean(SolrClient.class);
    6.  CloudSolrClient cloudSolrClient = (CloudSolrClient) client;
    7.  // 设置默认的操作实例
    8.  cloudSolrClient.setDefaultCollection("db_sync");

    }

}

  2. 2. **配置类（SolrClientConfig.java）**
  3. ```java
  4. import org.apache.solr.client.solrj.SolrClient;
  5. import org.apache.solr.client.solrj.impl.CloudSolrClient;
  6. import org.apache.solr.common.StringUtils;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import java.util.Arrays;
  11. import java.util.Optional;
  13. /**
  14.  * Description 自定义配置类（SolrClinet）
  15.  */
  16. @Configuration
  17. public class SolrClientConfig {
  19.     @Value("${spring.data.solr.zk-host}")
  20.     private String zk_host;
  22.     /**
  23.      * 集群版CloudSolrClient继承自SolrClient，需要进行强转
  24.      * 单机版不需要，直接可以使用solrClient
  25.      */
  26.     @Bean(name = "solrClient")
  27.     public SolrClient client() {
  28.         if (StringUtils.isEmpty(zk_host)) {
  29.             return null;
  30.         }
  31.         CloudSolrClient client = new CloudSolrClient.Builder(
  32.                 Arrays.asList(zk_host.split(",")),
  33.                 Optional.empty()
  34.         ).build();
  35.         // 设置默认的操作实例
  36.         client.setDefaultCollection("db_sync");
  37.         client.setZkClientTimeout(5000);
  38.         client.setZkConnectTimeout(5000);
  39.         return client;
  40.     }
  42. }


■ 服务接口（SolrService.java）

  1. import org.apache.solr.client.solrj.SolrServerException;
  2. import org.apache.solr.common.SolrDocument;
  3. import org.apache.solr.common.SolrDocumentList;
  4. import java.io.IOException;
  5. import java.util.List;
  6. import java.util.Map;
  8. public interface SolrService {
  10.     /**
  11.      * 将Map对象添加（新增或修改）到Solr中
  12.      *
  13.      * @param map
  14.      * @return
  15.      */
  16.     boolean saveOrUpdate(Map map);
  18.     /**
  19.      * 通过文档ID删除Solr中的文档
  20.      *
  21.      * @param id 索引ID
  22.      * @return
  23.      */
  24.     boolean deleteById(String id);
  26.     /**
  27.      * 通过查询删除Solr中对应的数据集合
  28.      *
  29.      * @param query 查询条件
  30.      */
  31.     boolean deleteByQuery(String query);
  33.     /**
  34.      * 更新Solr中的文档，Map对象中必须存在id用于定位doc文档
  35.      *
  36.      * @param map Key<String>代表数据域名称,Value<Object>代表修改值
  37.      * @return
  38.      */
  39.     boolean update(Map<String, Object> map);
  41.     /**
  42.      * 批量新增或更新记录
  43.      *
  44.      * @param entities 新增或更新对象列表
  45.      * @param <T>      泛型
  46.      * @return
  47.      * @throws SolrServerException
  48.      * @throws IOException
  49.      */
  50.     <T> boolean batchSaveOrUpdate(List<T> entities) throws SolrServerException, IOException;
  52.     /**
  53.      * 通过泛型获取Solr中的对象集合
  54.      *
  55.      * @param clz          泛型类对应java.lang.Class
  56.      * @param query        数据域名称:数据域的值；查询全部*:*；多条件查询 name:Java AND age:20
  57.      * @param filterQueries 过滤条件
  58.      * @param hlFieldsList 高亮显示数据域名称，是List<String>集合
  59.      * @param page         第几页
  60.      * @param rows         每页显示记录数
  61.      * @return
  62.      */
  63.     <T> SolrResultInfo<T> query(Class<T> clz, String query,String filterQueries, List<String> hlFieldsList, Integer page, Integer rows);
  65.     /**
  66.      * 将SolrDocument转换成Bean
  67.      *
  68.      * @param record 索引对象
  69.      * @param clz    Class对象
  70.      * @return
  71.      */
  72.     <T> T toBean(SolrDocument record, Class<T> clz);
  74.     /**
  75.      * 将SolrDocumentList转换成BeanList
  76.      *
  77.      * @param records 索引对象列表
  78.      * @param clz     Class对象
  79.      * @return
  80.      */
  81.     <T> List<T> toBeanList(SolrDocumentList records, Class<T> clz);
  83.     /**
  84.      * 根据ID获取记录
  85.      *
  86.      * @param id  索引ID
  87.      * @param clz Class对象
  88.      * @param <T> 泛型
  89.      * @return
  90.      */
  91.     <T> T getById(String id, Class<T> clz) throws IOException, SolrServerException;
  93. }

■ 服务实现类（SolrServiceImpl.java）

  1. import com.lonton.bigdata.service.SolrResultInfo;
  2. import com.lonton.bigdata.service.SolrService;
  3. import org.apache.commons.beanutils.BeanUtils;
  4. import org.apache.solr.client.solrj.SolrClient;
  5. import org.apache.solr.client.solrj.SolrQuery;
  6. import org.apache.solr.client.solrj.SolrServerException;
  7. import org.apache.solr.client.solrj.beans.DocumentObjectBinder;
  8. import org.apache.solr.client.solrj.impl.CloudSolrClient;
  9. import org.apache.solr.client.solrj.response.QueryResponse;
  10. import org.apache.solr.client.solrj.response.UpdateResponse;
  11. import org.apache.solr.common.SolrDocument;
  12. import org.apache.solr.common.SolrDocumentList;
  13. import org.apache.solr.common.SolrInputDocument;
  14. import org.apache.solr.common.StringUtils;
  15. import org.slf4j.Logger;
  16. import org.slf4j.LoggerFactory;
  17. import org.springframework.beans.factory.annotation.Autowired;
  18. import org.springframework.stereotype.Service;
  19. import org.springframework.transaction.annotation.Transactional;
  20. import java.io.IOException;
  21. import java.lang.reflect.Field;
  22. import java.lang.reflect.InvocationTargetException;
  23. import java.sql.Time;
  24. import java.sql.Timestamp;
  25. import java.util.*;
  27. @Service
  28. public class SolrServiceImpl implements SolrService {
  30.     private static final Logger log = LoggerFactory.getLogger(SolrServiceImpl.class);
  32.     @Autowired
  33.     private SolrClient client;
  35.     /**
  36.      * 将Map对象添加（新增或修改）到Solr中
  37.      *
  38.      * @param map Map对象
  39.      * @return
  40.      */
  41.     @Override
  42.     @Transactional(rollbackFor = Exception.class)
  43.     public boolean saveOrUpdate(Map map) {
  44.         Set kSet = map.keySet();
  45.         SolrInputDocument doc = new SolrInputDocument();
  46.         for (Object k : kSet) {
  47.             Object val = map.get(k);
  48.             if (val != null) {
  49.                 doc.addField(k.toString(), val);
  50.             }
  51.         }
  52.         try {
  53.             client.add(doc);
  54.             UpdateResponse resp = client.commit();
  55.             if (resp.getStatus() == 0) {
  56.                 log.debug("saveOrUpdate successfully!");
  57.                 return true;
  58.             }
  59.         } catch (Exception e) {
  60.             log.error(e.getMessage());
  61.             e.printStackTrace();
  62.         }
  63.         log.debug("saveOrUpdate failure!");
  64.         return false;
  65.     }
  67.     /**
  68.      * 通过文档ID删除Solr中的文档
  69.      *
  70.      * @param id 索引ID
  71.      * @return
  72.      */
  73.     @Override
  74.     @Transactional(rollbackFor = Exception.class)
  75.     public boolean deleteById(String id) {
  76.         try {
  77.             client.deleteById(id);
  78.             UpdateResponse resp = client.commit();
  79.             if (resp.getStatus() == 0) {
  80.                 log.debug("delete successfully!");
  81.                 return true;
  82.             }
  83.         } catch (Exception e) {
  84.             log.error(e.getMessage());
  85.             e.printStackTrace();
  86.         }
  87.         log.debug("delete failure!");
  88.         return false;
  89.     }
  91.     /**
  92.      * 通过查询删除Solr中对应的数据集合
  93.      *
  94.      * @param query 查询条件
  95.      */
  96.     @Override
  97.     @Transactional(rollbackFor = Exception.class)
  98.     public boolean deleteByQuery(String query) {
  99.         try {
  100.             client.deleteByQuery(query);
  101.             UpdateResponse resp = client.commit();
  102.             if (resp.getStatus() == 0) {
  103.                 log.debug("delete successfully!");
  104.                 return true;
  105.             }
  106.         } catch (Exception e) {
  107.             log.error(e.getMessage());
  108.             e.printStackTrace();
  109.         }
  110.         log.debug("delete failure!");
  111.         return false;
  112.     }
  114.     /**
  115.      * 更新Solr中的文档，Map对象中必须存在id用于定位doc文档
  116.      *
  117.      * @param map Key<String>代表数据域名称,Value<Object>代表修改值
  118.      * @return
  119.      */
  120.     @Override
  121.     @Transactional(rollbackFor = Exception.class)
  122.     public boolean update(Map<String, Object> map) {
  123.         try {
  124.             String id = (String) map.get("id");
  125.             SolrInputDocument doc = new SolrInputDocument();
  126.             doc.addField("id", id);
  127.             for (String key : map.keySet()) {
  128.                 // 数据域Id忽略更新
  129.                 if (!"id".equals(key)) {
  130.                     Map fieldMap = new HashMap();
  131.                     fieldMap.put("set", map.get(key));
  132.                     doc.addField(key, fieldMap);
  133.                 }
  134.             }
  135.             client.add(doc);
  136.             UpdateResponse resp = client.commit();
  137.             if (resp.getStatus() == 0) {
  138.                 log.debug("update successfully!");
  139.                 return true;
  140.             }
  141.         } catch (Exception e) {
  142.             log.error(e.getMessage());
  143.             e.printStackTrace();
  144.         }
  145.         log.debug("update failure!");
  146.         return false;
  147.     }
  149.     /**
  150.      * 批量新增或更新记录
  151.      *
  152.      * @param entities 新增或更新对象列表
  153.      * @param <T>      泛型
  154.      * @return
  155.      * @throws SolrServerException
  156.      * @throws IOException
  157.      */
  158.     @Override
  159.     @Transactional(rollbackFor = Exception.class)
  160.     public <T> boolean batchSaveOrUpdate(List<T> entities) throws SolrServerException, IOException {
  161.         DocumentObjectBinder binder = new DocumentObjectBinder();
  162.         int total = entities.size();
  163.         int count = 0;
  164.         for (T t : entities) {
  165.             SolrInputDocument doc = binder.toSolrInputDocument(t);
  166.             client.add(doc);
  167.             log.debug("添加数据到索引中，总共要添加 %d 条记录，当前添加第%d条 %n", total, ++count);
  168.         }
  169.         client.commit();
  170.         log.debug("batch Save Or Update successfully!");
  171.         return true;
  172.     }
  174.     /**
  175.      * 通过泛型获取Solr中的对象集合
  176.      *
  177.      * @param clz          泛型类对应java.lang.Class
  178.      * @param query        数据域名称:数据域的值；查询全部*:*；多条件查询 name:Java AND age:20
  179.      * @param hlFieldsList 高亮显示数据域名称，是List<String>集合
  180.      * @param page         第几页
  181.      * @param rows         每页显示记录数
  182.      * @return
  183.      */
  184.     @Override
  185.     public <T> SolrResultInfo<T> query(Class<T> clz, String query,String filterQueries, List<String> hlFieldsList, Integer page, Integer rows) {
  186.         try {
  187.             // 定义返回自定义数据结构对象
  188.             SolrResultInfo<T> resultInfo = new SolrResultInfo<T>();
  189.             SolrQuery q = new SolrQuery();
  191.             // 查询条件
  192.             q.set("q", query);
  194.             // 过滤条件
  195.             if(StringUtils.isEmpty(filterQueries)){
  196.                 q.set("fl", "*");
  197.             }else{
  198.                 q.setFilterQueries(filterQueries);
  199.             }
  201.             // 高亮设置（开启）
  202.             q.setHighlight(true);
  204.             // 高亮显示字段
  205.             String hlField = "";
  206.             for (String s : hlFieldsList) {
  207.                 hlField = hlField + s + ",";
  208.             }
  209.             if (hlField.endsWith(",")) {
  210.                 hlField = hlField.substring(0, hlField.length() - 1);
  211.             }
  212.             q.set("hl.fl", hlField);
  214.             // 高亮样式
  215.             q.setHighlightSimplePre("<font color=\"red\">");
  216.             q.setHighlightSimplePost("</font>");
  218.             // 分页设置
  219.             q.setStart((page - 1) * rows);
  220.             q.setRows(rows);
  222.             // 查询响应对象
  223.             QueryResponse qr = client.query(q);
  224.             Map<String, Map<String, List<String>>> hlMap = qr.getHighlighting();
  225.             log.debug(hlMap.toString());
  227.             // 高亮结果处理
  228.             SolrDocumentList lst = qr.getResults();
  229.             List<T> rtn = new ArrayList<T>();
  230.             Long total = qr.getResults().getNumFound();
  231.             for (SolrDocument doc : lst) {
  232.                 String id = (String) doc.getFieldValue("id");
  233.                 T t = clz.newInstance();
  234.                 // 获取自定义类所有属性名称
  235.                 Field[] fields = getField(clz);
  236.                 for (Field field : fields) {
  237.                     String fieldName = field.getName();
  238.                     String solrFldName = getSolrFieldName(clz, field);
  239.                     String fObj = getSingleValue(doc.getFieldValue(solrFldName));
  240.                     if (fObj == null) {
  241.                         continue;
  242.                     }
  243.                     if (field.getType() == java.sql.Date.class) {
  244.                         Date dt = new Date(fObj);
  245.                         fObj = new java.sql.Date(dt.getTime()).toString();
  246.                     }
  247.                     if (field.getType() == Timestamp.class) {
  248.                         Date dt = new Date(fObj);
  249.                         fObj = new Timestamp(dt.getTime()).toString();
  250.                     }
  251.                     if (field.getType() == Time.class) {
  252.                         Date dt = new Date(fObj);
  253.                         fObj = new Time(dt.getTime()).toString();
  254.                     }
  255.                     // 高亮显示数据形式：Map<ID, Map<FieldName,[MultiValue]>>
  256.                     if (hlFieldsList.contains(fieldName)) {
  257.                         //Map<FieldName,List<MultiValue>>
  258.                         Map<String, List<String>> fldMap = hlMap.get(id);
  259.                         Object hlObj = fldMap.get(fieldName);
  260.                         String hlVal = getSingleValue(hlObj);
  261.                         if (hlVal != null)
  262.                             fObj = hlVal;
  264.                     }
  265.                     if (fObj != null) {
  266.                         BeanUtils.setProperty(t, fieldName, fObj);
  267.                     }
  268.                 }
  269.                 rtn.add(t);
  270.             }
  271.             resultInfo.setList(rtn);
  272.             resultInfo.setTotal(total);
  273.             return resultInfo;
  274.         } catch (Exception e) {
  275.             log.error(e.getMessage());
  276.             e.printStackTrace();
  277.         }
  278.         return null;
  279.     }
  281.     @Override
  282.     public <T> T toBean(SolrDocument record, Class<T> clz) {
  283.         T obj = null;
  284.         try {
  285.             obj = clz.newInstance();
  286.         } catch (InstantiationException e1) {
  287.             e1.printStackTrace();
  288.         } catch (IllegalAccessException e1) {
  289.             e1.printStackTrace();
  290.         }
  291.         Field[] fields = clz.getDeclaredFields();
  292.         for(Field field:fields){
  293.             Object value = record.get(field.getName());
  294.             try {
  295.                 BeanUtils.setProperty(obj, field.getName(), value);
  296.             } catch (IllegalAccessException e) {
  297.                 e.printStackTrace();
  298.             } catch (InvocationTargetException e) {
  299.                 e.printStackTrace();
  300.             }
  301.         }
  302.         return obj;
  303.     }
  305.     @Override
  306.     public <T> List<T> toBeanList(SolrDocumentList records, Class<T> clz) {
  307.         List<T> list = new ArrayList();
  308.         for(SolrDocument record : records){
  309.             list.add(toBean(record,clz));
  310.         }
  311.         return list;
  312.     }
  314.     @Override
  315.     public <T> T getById(String id, Class<T> clz) throws IOException, SolrServerException {
  316.         SolrDocument record = client.getById(id);
  317.         return toBean(record,clz);
  318.     }
  320.     /**
  321.      * 根据Class对象获取此类型的定义属性数据
  322.      *
  323.      * @param clz class对象
  324.      * @return
  325.      */
  326.     private static Field[] getField(Class clz) {
  327.         return clz.getDeclaredFields();
  328.     }
  330.     /**
  331.      * 通过Field对象取得其上定义的注解名称
  332.      *
  333.      * @param clz
  334.      * @param fld
  335.      * @return
  336.      */
  337.     private static String getSolrFieldName(Class clz, Field fld) {
  338.         org.apache.solr.client.solrj.beans.Field fld2 = fld.getAnnotation(org.apache.solr.client.solrj.beans.Field.class);
  339.         if (fld2 == null) {
  340.             return fld.getName();
  341.         }
  343.         if (fld2.value().equals("#default")) {
  344.             return fld.getName();
  345.         } else {
  346.             return fld2.value();
  347.         }
  348.     }
  350.     /**
  351.      * 转化多值域为单值
  352.      *
  353.      * @param obj
  354.      * @return
  355.      */
  356.     private static String getSingleValue(Object obj) {
  357.         if (obj == null) {
  358.             return null;
  359.         }
  360.         String val = obj.toString();
  361.         if (val.startsWith("[") && val.endsWith("]")) {
  362.             return val.substring(1, val.length() - 1);
  363.         }
  364.         return val;
  365.     }
  367. }

■ 返回对象封装类（SolrResultInfo.java）

  1. import java.util.List;
  3. /**
  4.  * Description 查询Solr返回的对象，对象类型为Ｔ的集合，还包含Solr中符合条件记录总数
  5.  */
  6. public class SolrResultInfo<T> {
  7.     private List<T> list = null;
  8.     private Long total = null;
  10.     public List<T> getList() {
  11.         return list;
  12.     }
  14.     public void setList(List<T> list) {
  15.         this.list = list;
  16.     }
  18.     public Long getTotal() {
  19.         return total;
  20.     }
  22.     public void setTotal(Long total) {
  23.         this.total = total;
  24.     }
  26. }

**■ 实体类（Article.java

  1. import lombok.AllArgsConstructor;
  2. import lombok.Data;
  3. import lombok.NoArgsConstructor;
  4. import org.apache.solr.client.solrj.beans.Field;
  5. import org.springframework.data.solr.core.mapping.SolrDocument;
  6. import java.io.Serializable;
  8. /**
  9.  * Description VO-文章类
  10.  */
  11. @Data
  12. @AllArgsConstructor
  13. @NoArgsConstructor
  14. @SolrDocument(solrCoreName = "db_sync")
  15. public class Article implements Serializable {
  17.     @Field("id")
  18.     private Integer id;
  19.     @Field("content_id")
  20.     private Long contentId;
  21.     @Field("title")
  22.     private String title;
  23.     @Field("content")
  24.     private String content;
  25.     @Field("type")
  26.     private Integer type;
  27.     @Field("create_at")
  28.     private Long createAt;
  29.     @Field("publish_at")
  30.     private Long publishAt;
  32.     @Override
  33.     public String toString() {
  34.         return "Article{" +
  35.                 "id=" + id +
  36.                 ", contentId=" + contentId +
  37.                 ", title='" + title + '\'' +
  38.                 ", content='" + content + '\'' +
  39.                 ", type=" + type +
  40.                 ", createAt=" + createAt +
  41.                 ", publishAt=" + publishAt +
  42.                 '}';
  43.     }
  45. }

■ 工具类（CommonUtils.java）

  1. import com.google.common.collect.Lists;
  2. import com.google.common.collect.Maps;
  3. import org.apache.commons.beanutils.BeanUtils;
  4. import org.springframework.cglib.beans.BeanMap;
  5. import java.util.List;
  6. import java.util.Map;
  8. /**
  9.  * Description 工具类（Map与JavaBean互转）
  10.  */
  11. public class CommonUtils {
  13.     /**
  14.      * 把一个Map转换成指定类型的JavaBean对象
  15.      *
  16.      * @param map   Map对象
  17.      * @param clazz Class对象
  18.      * @param <T>   泛型
  19.      * @return
  20.      */
  21.     public static <T> T mapToBean(Map<String, ?> map, Class<T> clazz) {
  22.         try {
  23.             T bean = clazz.newInstance();
  24.             BeanUtils.populate(bean, map);
  25.             return bean;
  26.         } catch (Exception e) {
  27.             throw new RuntimeException(e);
  28.         }
  29.     }
  31.     /**
  32.      * 将List<Map<String,Object>>转换为List<T>
  33.      *
  34.      * @param maps  Map对象列表
  35.      * @param clazz Class对象
  36.      * @return
  37.      * @throws InstantiationException
  38.      * @throws IllegalAccessException
  39.      */
  40.     public static <T> List<T> mapsToBeans(List<Map<String, Object>> maps, Class<T> clazz)
  41.             throws InstantiationException, IllegalAccessException {
  42.         List<T> list = Lists.newArrayList();
  43.         if (maps != null && maps.size() > 0) {
  44.             Map<String, Object> map;
  45.             T bean;
  46.             for (int i = 0, size = maps.size(); i < size; i++) {
  47.                 map = maps.get(i);
  48.                 bean = clazz.newInstance();
  49.                 list.add((T) mapToBean(map, bean.getClass()));
  50.             }
  51.         }
  52.         return list;
  53.     }
  55.     /**
  56.      * 将对象装换为map
  57.      *
  58.      * @param bean
  59.      * @return
  60.      */
  61.     public static <T> Map<String, Object> beanToMap(T bean) {
  62.         Map<String, Object> map = Maps.newHashMap();
  63.         if (bean != null) {
  64.             BeanMap beanMap = BeanMap.create(bean);
  65.             for (Object key : beanMap.keySet()) {
  66.                 map.put(key + "", beanMap.get(key));
  67.             }
  68.         }
  69.         return map;
  70.     }
  72.     /**
  73.      * 将List<T>转换为List<Map<String, Object>>
  74.      *
  75.      * @param beanList
  76.      * @return
  77.      */
  78.     public static <T> List<Map<String, Object>> beansToMap(List<T> beanList) {
  79.         List<Map<String, Object>> list = Lists.newArrayList();
  80.         if (beanList != null && beanList.size() > 0) {
  81.             Map<String, Object> map;
  82.             T bean;
  83.             for (int i = 0, size = beanList.size(); i < size; i++) {
  84.                 bean = beanList.get(i);
  85.                 map = beanToMap(bean);
  86.                 list.add(map);
  87.             }
  88.         }
  89.         return list;
  90.     }
  92. }

4. 测试

■ 测试类（SolrServiceTests.java）

  1. import com.lonton.bigdata.vo.Article;
  2. import org.apache.solr.client.solrj.SolrServerException;
  3. import org.junit.jupiter.api.Test;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.boot.test.context.SpringBootTest;
  6. import java.io.IOException;
  7. import java.util.ArrayList;
  8. import java.util.HashMap;
  9. import java.util.List;
  10. import java.util.Map;
  12. /**
  13.  * Description 单元测试（Solr服务）
  14.  */
  15. @SpringBootTest
  16. public class SolrServiceTests {
  18.     @Autowired
  19.     private SolrService service;
  21.     @Test
  22.     public void saveOrUpdate() {
  23.         Map<String, Object> map = new HashMap<>();
  24.         map.put("id", "1");
  25.         map.put("content_id", 101L);
  26.         map.put("title", "北京");
  27.         map.put("content", "test作为一个中国人，我感到很自豪。");
  28.         map.put("type", 1);
  29.         map.put("create_at", 1578912614123L);
  30.         map.put("publish_at", 1578912614125L);
  31.         assert service.saveOrUpdate(map);
  32.     }
  34.     @Test
  35.     public void deleteById() {
  36.         saveOrUpdate();
  37.         assert service.deleteById("1");
  38.     }
  40.     @Test
  41.     public void deleteByQuery() {
  42.         saveOrUpdate();
  43.         assert service.deleteByQuery("id:1");
  44.     }
  46.     @Test
  47.     public void deleteAll() {
  48.         assert service.deleteByQuery("*:*");
  49.     }
  51.     @Test
  52.     public void update() {
  53.         saveOrUpdate();
  54.         Map<String, Object> map = new HashMap<>();
  55.         map.put("id", "1");
  56.         map.put("content_id", 999L);
  57.         map.put("title", "update-test");
  58.         map.put("content", "update-test");
  59.         map.put("type", 1);
  60.         map.put("create_at", 1578912614199L);
  61.         map.put("publish_at", 1578912614199L);
  62.         assert service.update(map);
  63.     }
  65.     @Test
  66.     public void batchSaveOrUpdate() throws IOException, SolrServerException {
  67.         List<Article> entities = new ArrayList<>();
  68.         for (int i = 1; i <= 35; i++) {
  69.             entities.add(new Article(i, i * 10L, "我是中国人，打倒小日本" + i, "作为一个中国人，我感到很自豪。", 1, 1578912614123L, 1578912614123L));
  70.         }
  71.         assert service.batchSaveOrUpdate(entities);
  72.     }
  74.     @Test
  75.     public void query() throws IOException, SolrServerException {
  76.         batchSaveOrUpdate();
  77.         List<String> hlFieldsList = new ArrayList<>();
  78.         hlFieldsList.add("title");
  79.         hlFieldsList.add("content");
  80.         int page = 1;
  81.         int rows = 5;
  82.         String filterQueries = "content_id:[1 TO *]";
  83.         SolrResultInfo<Article> resultInfo = service.query(Article.class, "keywords:中国", filterQueries, hlFieldsList, page, rows);
  84.         Long total = resultInfo.getTotal();
  85.         System.out.println("total:" + total);
  86.         if (total > 0) {
  87.             for (Article article : resultInfo.getList()) {
  88.                 System.out.println(article);
  89.             }
  90.         }
  91.     }
  93. }

■ 控制类（ArticleController.java）

  1. import com.alibaba.fastjson.JSONArray;
  2. import com.alibaba.fastjson.JSONObject;
  3. import com.alibaba.fastjson.TypeReference;
  4. import com.lonton.bigdata.service.SolrResultInfo;
  5. import com.lonton.bigdata.service.SolrService;
  6. import com.lonton.bigdata.util.CommonUtils;
  7. import com.lonton.bigdata.vo.Article;
  8. import org.apache.solr.client.solrj.SolrServerException;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.web.bind.annotation.*;
  11. import java.io.IOException;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14. import java.util.Map;
  16. @RestController
  17. @RequestMapping("/solrService")
  18. public class ArticleController {
  20.     @Autowired
  21.     private SolrService service;
  23.     // http://localhost:8082/solrService/saveOrUpdate/record
  25.     /**
  26.      * 将Map对象添加（新增或修改）到Solr中<br/>
  27.      * {
  28.      * "id":"1",
  29.      * "content_id":10,
  30.      * "title":"我是中国人",
  31.      * "content":"作为一个中国人，我感到很自豪。ArticleController",
  32.      * "type":1,
  33.      * "create_at":1578912614123,
  34.      * "publish_at":1578912614123
  35.      * }
  36.      *
  37.      * @param jsonParam 接收前端JSON格式的数据
  38.      * @return
  39.      */
  40.     @ResponseBody
  41.     @RequestMapping(value = "/saveOrUpdate/record", method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
  42.     public boolean saveOrUpdate(@RequestBody JSONObject jsonParam) {
  43.         Map<String, String> map = JSONObject.parseObject(jsonParam.toJSONString(), new TypeReference<Map<String, String>>() {
  44.         });
  45.         System.out.println(map);
  46.         return service.saveOrUpdate(map);
  47.     }
  49.     // http://localhost:8082/solrService/deleteById/1
  51.     /**
  52.      * 根据id删除
  53.      *
  54.      * @param id 索引ID
  55.      */
  56.     @RequestMapping(value = "/deleteById/{id}", method = RequestMethod.POST)
  57.     public boolean deleteById(@PathVariable("id") String id) {
  58.         return service.deleteById(id);
  59.     }
  61.     // http://localhost:8082/solrService/deleteByQuery/id/1
  62.     // http://localhost:8082/solrService/deleteByQuery/*/*
  64.     /**
  65.      * 通过查询删除Solr中对应的数据集合
  66.      *
  67.      * @param key   字段
  68.      * @param value 值
  69.      * @return
  70.      */
  71.     @RequestMapping(value = "/deleteByQuery/{key}/{value}", method = RequestMethod.POST)
  72.     public boolean deleteByQuery(@PathVariable("key") String key, @PathVariable("value") String value) {
  73.         return service.deleteByQuery(String.format("%s:%s", key, value));
  74.     }
  76.     // http://localhost:8082/solrService/update/record
  78.     /**
  79.      * 更新Solr中的文档，Map对象中必须存在id用于定位doc文档<br/>
  80.      * {
  81.      * "id":"1",
  82.      * "content_id":10,
  83.      * "title":"我是中国人update",
  84.      * "content":"作为一个中国人，我感到很自豪。update",
  85.      * "type":1,
  86.      * "create_at":1578912614123,
  87.      * "publish_at":1578912614123
  88.      * }
  89.      *
  90.      * @param jsonParam 接收前端JSON格式的数据
  91.      * @return
  92.      */
  93.     @ResponseBody
  94.     @RequestMapping(value = "/update/record", method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
  95.     public boolean update(@RequestBody JSONObject jsonParam) {
  96.         Map<String, Object> map = JSONObject.parseObject(jsonParam.toJSONString(), new TypeReference<Map<String, Object>>() {
  97.         });
  98.         System.out.println(map);
  99.         return service.update(map);
  100.     }
  102.     // http://localhost:8082/solrService/batchSaveOrUpdate/record
  104.     /**
  105.      * 批量新增或更新记录
  106.      * [{
  107.      * "id": "1",
  108.      * "contentId": 101,
  109.      * "title": "我是中国人add",
  110.      * "content": "作为一个中国人，我感到很自豪。add",
  111.      * "type": 1,
  112.      * "createAt": 1578912614123,
  113.      * "publishAt": 1578912614123
  114.      * },
  115.      * {
  116.      * "id": "2",
  117.      * "contentId": 102,
  118.      * "title": "我是中国人add",
  119.      * "content": "作为一个中国人，我感到很自豪。add",
  120.      * "type": 1,
  121.      * "createAt": 1578912614123,
  122.      * "publishAt": 1578912614123
  123.      * }]
  124.      *
  125.      * @param jsonParam 接收前端JSON格式的数据
  126.      * @return
  127.      * @throws IllegalAccessException
  128.      * @throws InstantiationException
  129.      * @throws IOException
  130.      * @throws SolrServerException
  131.      */
  132.     @ResponseBody
  133.     @RequestMapping(value = "/batchSaveOrUpdate/record", method = RequestMethod.POST, produces = "application/json;charset=UTF-8")
  134.     public boolean batchSaveOrUpdate(@RequestBody JSONArray jsonParam) throws Exception {
  135.         List<Map<String, Object>> maps = (List<Map<String, Object>>) JSONArray.parse(jsonParam.toJSONString());
  136.         // 方法1
  137.         /*List<Article> list =new ArrayList<>();
  138.         for (Map<String, String> map : maps) {
  139.             // 1. 工具类将map转为JavaBean
  140.             list.add(CommonUtils.mapToBean(map, Article.class));
  141.             // 2. 从Map中取值对JavaBean进行setter
  142.             *//*Article bean=new Article();
  143.             bean.setId(Integer.valueOf(map.get("id")));
  144.             bean.setContentId(Long.parseLong(String.valueOf(map.get("content_id"))));
  145.             bean.setTitle(map.get("title"));
  146.             bean.setContent(map.get("content"));
  147.             bean.setType(Integer.valueOf(String.valueOf(map.get("type"))));
  148.             bean.setCreateAt(Long.valueOf(String.valueOf(map.get("create_at"))));
  149.             bean.setPublishAt(Long.valueOf(String.valueOf(map.get("publish_at"))));
  150.             list.add(bean);*//*
  151.         }*/
  152.         // 方法2
  153.         List<Article> list = CommonUtils.mapsToBeans(maps, Article.class);
  154.         System.out.println(CommonUtils.beansToMap(list));
  155.         return service.batchSaveOrUpdate(list);
  156.     }
  158.     // http://localhost:8082/solrService/getById/1
  160.     /**
  161.      * 根据id查询内容
  162.      *
  163.      * @param id 索引ID
  164.      * @return
  165.      * @throws IOException
  166.      * @throws SolrServerException
  167.      */
  168.     @RequestMapping(value = "/getById/{id}", method = RequestMethod.GET)
  169.     public Article getById(@PathVariable String id) throws IOException, SolrServerException {
  170.         Article article = service.getById(id, Article.class);
  171.         System.out.println(article);
  172.         return article;
  173.     }
  175.     // http://localhost:8082/solrService/query/中国/1/5
  177.     /**
  178.      * 综合查询（条件、高亮等）
  179.      *
  180.      * @param keywords 关键字
  181.      * @param page     第？页
  182.      * @param rows     每页显示所少条记录
  183.      * @return
  184.      */
  185.     @RequestMapping(value = "/query/{keywords}/{page}/{rows}", method = RequestMethod.GET)
  186.     public SolrResultInfo query(@PathVariable String keywords, @PathVariable int page, @PathVariable int rows) {
  187.         List<String> hlFieldsList = new ArrayList<>();
  188.         hlFieldsList.add("title");
  189.         hlFieldsList.add("content");
  190.         String filterQueries = "content_id:[102 TO *]";
  191.         SolrResultInfo<Article> resultInfo = service.query(
  192.                 Article.class,
  193.                 String.format("keywords:%s", keywords),
  194.                 filterQueries,
  195.                 hlFieldsList,
  196.                 page,
  197.                 rows
  198.         );
  199.         Long total = resultInfo.getTotal();
  200.         System.out.println("total:" + total);
  201.         if (total > 0) {
  202.             for (Article article : resultInfo.getList()) {
  203.                 System.out.println(article);
  204.             }
  205.         }
  206.         return resultInfo;
  207.     }
  209. }

5. 完整示例代码

源码：solr-springboot-example-src.zip

参考

简书：Spring Boot和Solr整合
https://www.jianshu.com/p/05a161add1a6
CSDN：Spring Boot整合Solr，手把手教你使用Solr
https://blog.csdn.net/weixin_42129558/article/details/82682265
博客园：Spring Boot整合Solr
https://www.cnblogs.com/wdfordream/p/11377161.html
CSDN：Spring Boot+Solr配置入门
https://blog.csdn.net/hello_word2/article/details/80757396