大多涉及到資料的處理，無非CURD四種操作，對於搜尋SOLR而言，基本操作也可以說就這麼幾種，在實際應用中，搜尋條件的多樣性才是重點，我們在進入複雜的搜尋之前，先來看一下如何新增和修改文件

<!-- more -->

I. 環境準備

solr的基礎環境需要準備好，如果對這一塊有疑問的童鞋，可以參考下上一篇博文: 《190510-SpringBoot高階篇搜尋之Solr環境搭建與簡單測試》

1. 環境配置

在pom檔案中，設定好對應的依賴

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from update -->
</parent>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <spring-cloud.version>Finchley.RELEASE</spring-cloud.version>
    <java.version>1.8</java.version>
</properties>


<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>


<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-solr</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>
 

因為我們採用預設的solr訪問姿勢，所以配置檔案中可以不加對應的引數，當然也可以加上

開啟 application.yml 配置檔案

spring:
  data:
    solr:
      host: http://127.0.0.1:8983/solr

如果我們的solr加上了使用者名稱密碼訪問條件，引數中並沒有地方設定username和password，那應該怎麼辦?

spring:
  data:
    solr:
      host: http://admin:[email protected]:8983/solr

如上寫法，將使用者名稱和密碼寫入http的連線中

2. 自動裝配

我們主要使用SolrTemplate來和Solr打交到，因此我們需要先註冊這個bean，可以怎麼辦？

package com.git.hui.boot.solr.config;

import org.apache.solr.client.solrj.SolrClient;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.solr.core.SolrTemplate;

/**
 * Created by @author yihui in 19:49 19/5/10.
 */
@Configuration
public class SearchAutoConfig {

    @Bean
    @ConditionalOnMissingBean(SolrTemplate.class)
    public SolrTemplate solrTemplate(SolrClient solrClient) {
        return new SolrTemplate(solrClient);
    }
}
 

上面的配置是條件注入，只有當SolrTemplate對應的bean沒有被自動載入時，才會載入，為什麼要怎麼幹？

（可以想一想原因...）

II. 使用姿勢示例

我們的操作主要依賴的是SolrTemplate，因此有必要在開始之前，看一下它的簽名

Spring的原始碼中，可以發現大多xxxTemplate都會實現一個xxxOperations 介面，而這個介面就是用來定義CURD的api，比如我們看下 SolrOperations中與修改相關的api

default UpdateResponse saveBean(String collection, Object obj) {
	return saveBean(collection, obj, Duration.ZERO);
}

/**
 * Execute add operation against solr, which will do either insert or update with support for commitWithin strategy.
 *
 * @param collection must not be {@literal null}.
 * @param obj must not be {@literal null}.
 * @param commitWithin max time within server performs commit.
 * @return {@link UpdateResponse} containing update result.
 */
UpdateResponse saveBean(String collection, Object obj, Duration commitWithin);

default UpdateResponse saveBeans(String collection, Collection<?> beans) {
	return saveBeans(collection, beans, Duration.ZERO);
}

UpdateResponse saveBeans(String collection, Collection<?> beans, Duration commitWithin);

default UpdateResponse saveDocument(String collection, SolrInputDocument document) {
	return saveDocument(collection, document, Duration.ZERO);
}

/**
 * Add a solrj input document to solr, which will do either insert or update with support for commitWithin strategy
 *
 * @param document must not be {@literal null}.
 * @param commitWithin must not be {@literal null}.
 * @return {@link UpdateResponse} containing update result.
 * @since 3.0
 */
UpdateResponse saveDocument(String collection, SolrInputDocument document, Duration commitWithin);


default UpdateResponse saveDocuments(String collection, Collection<SolrInputDocument> documents) {
	return saveDocuments(collection, documents, Duration.ZERO);
}

UpdateResponse saveDocuments(String collection, Collection<SolrInputDocument> documents, Duration commitWithin);

上面的api簽名中，比較明確的說明了這個 saveXXX 既可以用來新增文件，也可以用來修改文件，主要有提供了兩類

• 單個與批量
• saveDocument 與 saveBean

1. 新增文件

從上面的api簽名上看，saveDocument 應該是相對原始的操作方式了，因此我們先看下它的使用姿勢

a. saveDocument

首先就是建立文件 SolrInputDocument 物件，通過呼叫addField來設定成員值

public void testAddByDoc() {
    SolrInputDocument document = new SolrInputDocument();
    document.addField("id", 3);
    document.addField("title", "testAddByDoc!");
    document.addField("content", "通過solrTemplate新增文件");
    document.addField("type", 2);
    document.addField("create_at", System.currentTimeMillis() / 1000);
    document.addField("publish_at", System.currentTimeMillis() / 1000);

    UpdateResponse response = solrTemplate.saveDocument("yhh", document);
    solrTemplate.commit("yhh");
    System.out.println("over:" + response);
}

<font color="red">注意：儲存文件之後，一定得呼叫commit提交</font>

b. saveBean

前面需要建立SolrInputDocument物件，我們更希望的使用case是直接傳入一個POJO，然後自動與solr的filed進行關聯

因此一種使用方式可以如下

• 定義pojo，成員上通過 @Field 註解來關聯solr的field
• pojo物件直接當做引數傳入，儲存之後，執行 commit 提交

@Data
public static class DocDO {
    @Field("id")
    private Integer id;
    @Field("title")
    private String title;
    @Field("content")
    private String content;
    @Field("type")
    private Integer type;
    @Field("create_at")
    private Long createAt;
    @Field("publish_at")
    private Long publishAt;
}

/**
 * 新增
 */
private void testAddByBean() {
    DocDO docDO = new DocDO();
    docDO.setId(4);
    docDO.setTitle("addByBean");
    docDO.setContent("新增一個測試文件");
    docDO.setType(1);
    docDO.setCreateAt(System.currentTimeMillis() / 1000);
    docDO.setPublishAt(System.currentTimeMillis() / 1000);

    UpdateResponse response = solrTemplate.saveBean("yhh", docDO);
    solrTemplate.commit("yhh");
    System.out.println(response);
}

c. 批量

批量的方式就比較簡單了，傳入集合即可

private void testBatchAddByBean() {
    DocDO docDO = new DocDO();
    docDO.setId(5);
    docDO.setTitle("addBatchByBean - 1");
    docDO.setContent("新增一個測試文件");
    docDO.setType(1);
    docDO.setCreateAt(System.currentTimeMillis() / 1000);
    docDO.setPublishAt(System.currentTimeMillis() / 1000);

    DocDO docDO2 = new DocDO();
    docDO2.setId(6);
    docDO2.setTitle("addBatchByBean - 2");
    docDO2.setContent("新增一個測試文件");
    docDO2.setType(1);
    docDO2.setCreateAt(System.currentTimeMillis() / 1000);
    docDO2.setPublishAt(System.currentTimeMillis() / 1000);

    UpdateResponse response = solrTemplate.saveBeans("yhh", Arrays.asList(docDO, docDO2));
    solrTemplate.commit("yhh");
    System.out.println(response);
}

d. 測試

上面的幾個方法，我們執行之後，我們看下是否能查詢到新增加的資料

2. 文件修改

在看前面的介面簽名時，就知道修改和新增用的是相同的api，所以修改文件和上面的使用實際上也沒有什麼特別的，下面簡單的演示一下

public void testUpdateDoc() {
    DocDO docDO = new DocDO();
    docDO.setId(5);
    docDO.setTitle("修改之後!!!");
    docDO.setType(1);
    docDO.setCreateAt(System.currentTimeMillis() / 1000);
    docDO.setPublishAt(System.currentTimeMillis() / 1000);

    UpdateResponse response = solrTemplate.saveBean("yhh", docDO);
    solrTemplate.commit("yhh");
    System.out.println(response);
}

上面的例項中，修改了id為5的文件標題，並刪除了content內容，執行完畢之後，結果如何呢？

• title被替換
• content沒有了

到這裡就有個疑問了，對於呼叫而言，怎麼保證是修改還是新增呢？

• 這裡主要是根據id來判斷，這個id類似db中的唯一主鍵，當我們沒有指定id時，會隨機生成一個id
• 如果存在相同的id，則修改文件；如果不存在，則新增文件

III. 其他

0. 專案

• 專案原始碼：https://github.com/liuyueyi/spring-boot-demo
• 工程原始碼: https://github.com/liuyueyi/spring-boot-demo/blob/master/spring-boot/140-search-solr

1. 一灰灰Blog

盡信書則不如，以上內容，純屬一家之言，因個人能力有限，難免有疏漏和錯誤之處，如發現bug或者有更好的建議，歡迎批評指正，不吝感激

下面一灰灰的個人部落格，記錄所有學習和工作中的博文，歡迎大家前去逛逛

• 一灰灰Blog個人部落格 https://blog.hhui.top
• 一灰灰Blog-Spring專題部落格 http://spring.hhui.top

相關推薦