08、全文检索 -- Solr -- 使用 SolrClient 连接 Solr（演示手动配置自定义的SolrClient 并在测试类使用 solrClient 进行添加、查询、删除文档的操作）_solrclient查询

SolrClient

演示前的一些解释：

1、Solr 不是一个框架，它相当于一个应用程序，或者可以理解它是一个数据库，但实际上它不是数据库，它是对 Lucene 做一个包装，包装成一个反向索引库，也可以说包装成一个应用程序，然后这个应用程序就提供了 RestFul 的编程接口，因此我们的应用程序就可以直接向这个编程接口发送请求，获取响应。

而SolrClient 是 Solr 本身提供的一个API，它是一个操作 Solr 索引库的门面类，最大的作用是可以向 Solr 发送 RestFul 请求，并且获取 RestFul 的响应：

2、使用 SolrClient 连接 Solr，这里说的连接 Solr 就是指连接 Solr 图形界面，也可以理解是连接 Solr 的服务器，一个道理。

3、演示时，记得启动 Solr 服务器，打开小黑窗：输入 solr start 命令即可。
Solr图形管理界面：http://localhost:8983/solr/#/

SolrClient的功能

SolrClient 这个API包含如下常用方法：

- add(String collection, Collection<SolrInputDocument> docs, int commitWithinMs)：
  向collection添加或更新多个文档。每个SolrInputDocument代表一个文档。指定在commitWithinMs毫秒之内提交修改。
  提示：每个Core内都会定义一个Field来代表文档的唯一标识，如果新增文档的唯一标识在Core内已经存在，
  那就表现为更新文档，而不是新增文档。
  
- add(String collection, SolrInputDocument doc, int commitWithinMs)：添加或更新单个的文档。

- addBean(String collection, Object obj, int commitWithinMs)：以面向对象的方式添加或更新单个文档。其中obj代表映射文档的实体对象。因此该方法的本质就是添加单个文档的add()方法。

- addBeans(String collection, Collection<?> beans, int commitWithinMs)：以面向对象的方式添加或更新多个文档。

- deleteById(String collection, List<String> ids, int commitWithinMs)：根据id删除一个或多个文档。其第2个参数既可是List集合，也可是单个id值。

- deleteByQuery(String collection, String query, int commitWithinMs)：删除符合query条件的所有文档。

- getById(String collection, String id, SolrParams params)：根据id加载文档。第3个params参数用于指定额外的Solr参数。

- optimize(String collection, boolean waitFlush, boolean waitSearcher)：优化索引库。

- query(String collection, SolrParams params, SolrRequest.METHOD method)：以params参数从Solr索引库执行检索。

- request(SolrRequest request, String collection)：向Solr索引库发送请求。

- commit(String collection)：提交修改。上面这些添加文档的方法没有指定commitWithinMs参数，就需要显式调用该方法来提交修改。

- rollback(String collection)：回滚修改。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

SolrClient方法的说明：

SolrClient 的方法都可指定一个 commitWithinMs 参数，该参数指定在多少毫秒内会对所做的修改进行提交；

如果上面 add 和 deleteByxxx 方法没有指定 commitWithinMs 参数，就必须显式地使用commit()方法来提交修改。

SolrClient 的这些方法都可以省略 collection 参数，该参数指定了要操作的逻辑索引库。

如果省略了该参数，那就要求程序在创建SolrClient时指定Collection（单机模式下对应于Core）。
例如如下：
spring.data.solr.host=http://127.0.0.1:8983/solr/collection参数

Spring Boot Starter Data Solr的不足

Spring Boot提供了一个Starter：spring-boot-starter-data-solr，但实话实说，这个Starter的功能很简陋，也就是提供了两个类：SolrAutoConfiguration 和 SolrProperties，

其中 SolrProperties 用于加载以 spring.data.solr.* 开头的属性，

SolrAutoConfiguration 则负责在容器中自动配置 SolrClient。

Spring Boot 自动配置的 SolrClient 还不支持读取用户名、密码信息。

从Spring Boot 2.5之后，Spring Boot Data Solr Starter不复存在了。

【说明：】 如果打算使用 Spring Boot 2.5，其实就没必要强行使用Spring Boot Data Solr Starter。
直接添加Spring Data Solr依赖即可。

此外，Spring Data Solr 还需要依赖 commons-codes。

        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.9</version>
        </dependency>
1
2
3
4
5

手动配置自定义的SolrClient

增加如下代码：

// 设置使用基本认证的客户端
System.setProperty("solr.httpclient.builder.factory",
    "org.apache.solr.client.solrj.impl.PreemptiveBasicAuthClientBuilderFactory");
// 设置认证的用户名和密码
System.setProperty("basicauth", username + ":" + password);
1
2
3
4
5

SolrClient 代码演示

配置自定义的 SolrClient

1、创建一个 SpringBoot 项目，添加依赖

2、SolrAutoConfiguration 解析

查看这个SolrAutoConfiguration 自动配置类

如图：这个Solr的自动配置类里面只有这个一个 SolrClient 的 bean

SolrProperties 属性处理类

如图：SolrProperties 这个属性处理类并没有属性来指定用户名和密码信息。

Spring Boot 自动配置的 SolrClient 还不支持读取用户名、密码信息。
就是如果我的 Solr 服务器有用户名和密码这种权限认证的话，这个 SolrClient 就没办法连接到了。
所以需要自己手动配置自定义的SolrClient

3、手动配置自定义的SolrClient

如图：直接把 SolrAutoConfiguration 自动配置类的代码拷贝到自己的配置类里面进行修改。

添加了用户认证：

4、配置文件指定单机模式、用户名和密码

配置文件指定单机模式，然后添加 连接Solr索引库的用户名和密码

SolrClient 用法示例

1、为SolrClient定义数据类：

使用@Field修饰数据类的属性即可，表明将数据类的属性映射到索引库的指定 field。

如图：创建 Book 类所用到的字段，也存在这个 managed-schema 配置文件里面。这样类的字段才能映射到这个索引库里面的field。

2、定义添加文档的测试类

写一个测试类，然后使用这个 addBean 方法添加一个文档。

addBean(String collection, Object obj, int commitWithinMs)： 以面向对象的方式添加或更新单个文档。其中obj代表映射文档的实体对象。因此该方法的本质就是添加单个文档的add()方法

测试类如图：

注意： 添加的索引库是 books ，然后映射到这个 books 索引库的对象是 book。但是此时的 books 索引库还没创建，所以接下来就来创建这个索引库。

注意点： 添加和删除操作，需要添加这个commitWithingMs 这个参数，来指定多久提交执行这个操作。

创建 books 索引库

为了演示方便，这里使用之前创建的 ljhcore 索引库的配置文件，所以这个新建的索引库的 managed-schema 配置文件里面的 field 都是一样的。

然后在图形界面这里再添加 core ，这样就成功创建了一个 books 的索引库。

然后查询一下，可以看到此时的索引库没有任何的文档。

测试遇到的bug及解决方法

添加文档的测试结果

启动测试类成功

再查看下图形界面的数据
测试中的3个文档数据成功添加到books索引库里面了

这个 price_c 在book对象中并没有这个字段，之所以出现，是因为这是个 拷贝字段。

3、定义查询文档的测试方法

查询代码如图：
通过字段和关键词查询文档。

查询文档的测试结果

第一个查询：
查 title_cn 这个字段包含 “忍者” 这个关键词的文档

第二个查询：查询索引库中，description 字段中含有 “成长” 这个关键词的文档

第三个查询：查询索引库中，description 字段中含有 " 成* " 这个关键词的文档

4、定义删除文档的测试方法

根据文档的 id 来删除文档

删除文档的测试结果

删除文档 id = 1 的测试通过

再到图形界面来查查看，可以看到 id = 1 的文档已经被删除了

5、根据查询来删除文档

根据提供的字段和关键词，通过查询，如果该字段包含该关键词，则该文档会被删除掉。

如图：如果查询到 books 索引库里面，title_cn 这个字段有包含 “龙珠” 这个关键词的文档，则将该文档删除掉。

根据查询来删除文档的测试结果

如图，title_cn 字段含有“龙珠”这个关键词的文档被成功删除掉了。

完整代码：

SolrConfig

package cn.ljh.solrclient.config;

import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.impl.CloudSolrClient;
import org.apache.solr.client.solrj.impl.HttpSolrClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.solr.SolrProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import java.util.Arrays;
import java.util.Optional;

//手动配置自定义的SolrClient
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({HttpSolrClient.class, CloudSolrClient.class})
@EnableConfigurationProperties(SolrProperties.class)
public class SolrConfig
{

    //把配置文件中的属性值注入到这个成员变量里面
    @Value("${spring.data.solr.username}")
    private String username;
    @Value("${spring.data.solr.password}")
    private String password;


    //此处需要配置一个 SolrClient（直接抄SolrAutoConfiguration的源码就可以了）
    @Bean
    public SolrClient solrClient(SolrProperties properties)
    {
        //通过系统属性来设置连接Solr所使用的认证信息

        // 设置使用基本认证的客户端
        System.setProperty("solr.httpclient.builder.factory",
                "org.apache.solr.client.solrj.impl.PreemptiveBasicAuthClientBuilderFactory");
        // 设置认证的用户名和密码
        System.setProperty("basicauth", username + ":" + password);

        if (StringUtils.hasText(properties.getZkHost()))
        {
            return new CloudSolrClient.Builder(Arrays.asList(properties.getZkHost()), Optional.empty()).build();
        }
        return new HttpSolrClient.Builder(properties.getHost()).build();
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

Book

package cn.ljh.solrclient.domain;

import lombok.Data;
import org.apache.solr.client.solrj.beans.Field;
import org.springframework.data.annotation.Id;

/**
 * author JH
 */
@Data
public class Book
{
    //该id字段会被映射到索引库的 id field，而在索引库中 ，id field 被自定为标志属性
    //@Id
    //添加这个 @Field 注解，就能自动映射到索引库中同名的field
    @Field
    private Integer id;
    //这就表示这个 title ，映射到索引库中的 title_cn 这个字段
    @Field("title_cn")
    private String title;
    @Field
    private String description;
    @Field
    private Double price;

    //构造器
    public Book(Integer id, String title, String description, Double price)
    {
        this.id = id;
        this.title = title;
        this.description = description;
        this.price = price;
    }


}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

application.properties

# 现在演示的是单机模式，所以先指定这个host
spring.data.solr.host=http://127.0.0.1:8983/solr
# 连接 Solr 索引库的用户名和密码（就是Solr的图形界面）
spring.data.solr.username=root
spring.data.solr.password=123456

1
2
3
4
5
6
7

SolrClientTest

package cn.ljh.solrclient;

import cn.ljh.solrclient.domain.Book;
import lombok.SneakyThrows;
import org.apache.solr.client.solrj.SolrClient;
import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.params.SolrParams;
import org.assertj.core.util.Strings;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;


// SpringBootTest.WebEnvironment.NONE:  指定测试的web环境为非Web环境。
// 通常情况下，我们会将该参数设置为NONE，表示不需要启动内嵌的Web容器，从而更加快速地执行测试
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)
public class SolrClientTest
{

    @Autowired
    private SolrClient solrClient;


    //添加文档到books索引库的测试类
    @SneakyThrows
    @ParameterizedTest
    //这些参数相当于一个个文档
    @CsvSource({
            "1,火影忍者,讲述成为村长的故事,200",
            "2,七龙珠,讲述赛亚人的成长故事,300",
            "3,家庭教师,讲述废材纲成为第十代首领的热血故事,400"
    })
    public void testSave(Integer id, String title, String description, Double price)
    {

        Book book = new Book(id, title, description, price);

        //向 books 逻辑索引库添加文档 ； 参数1：索引库的名字 ， 参数2：映射文档的实体对象  ，参数3 ：500 毫秒的提交时间
        solrClient.addBean("books", book, 500);

    }


    //查询索引库中的文档的测试类
    @SneakyThrows
    @ParameterizedTest
    //这个注解用来进行多次测试，一个字符串代表一次测试方法。
    @CsvSource({
            "title_cn,忍者",
            "description,成为",
            "description,成*"
    })
    //参数1：要查询的字段   参数2：要查询的关键词
    public void testQuery(String field, String term)
    {

        //创建查询，表明在 field 字段中查询 term 关键字
        SolrParams params = new SolrQuery(field + ":" + term);
        //执行查询操作，去 books 这个索引库里面查询，得到响应
        QueryResponse queryResponse = solrClient.query("books", params);
        //返回所得到的文档
        SolrDocumentList docList = queryResponse.getResults();
        //遍历所有的文档
        for (SolrDocument doc : docList)
        {
            System.err.println("获取所有 field 的名字：" + doc.getFieldNames());
            //遍历文档中的每个字段名
            for (String fn : doc.getFieldNames())
            {
                //通过字段名获取字段值
                System.err.println("filed名称：【 " + fn + " 】，field 的值：【" + doc.getFieldValue(fn) + " 】");
            }
        }

    }

    //根据文档的id来删除文档
    @SneakyThrows
    @ParameterizedTest
    @ValueSource(strings = {"1"})
    public void testDeleteById(String id)
    {
        //根据文档的id来删除
        //参数1：指定删除哪个索引库的文档     参数2：删除这个id的文档    参数3：指定多久提交执行这个删除操作，这里是500毫秒
        solrClient.deleteById("books",id,500);
    }


    //根据提供的字段和关键词，通过查询，如果该字段包含该关键词，则该文档会被删除掉
    @SneakyThrows
    @ParameterizedTest
    @CsvSource({
            "title_cn,龙珠"
    })
    //这个字段包含这个关键词的则会被删除掉
    public void testDeleteByQuery(String field, String term)
    {
        //因为 参数2 需要的类型是String，所以这里不用创建SolrQuery查询对象
        //str 打印出来 ===> q=title_cn:龙珠
        String str = field + ":" + term;

        //参数1：指定删除哪个索引库的文档     参数2：字段名+关键词    参数3：指定多久提交执行这个删除操作，这里是500毫秒
        solrClient.deleteByQuery("books",str,500);
    }



}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
    </parent>
    <groupId>cn.ljh</groupId>
    <artifactId>solrclient</artifactId>
    <version>1.0.0</version>
    <name>solrclient</name>


    <properties>
        <java.version>11</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

        <!-- 最基础的Spring Boot Starter -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- SpringBoot 2.5.3 不再为 Spring Data Solr 提供 Starter，因此只能手动添加 Spring Data Solr 依赖 -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-solr</artifactId>
            <version>4.3.11</version>
        </dependency>

        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.9</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79