全文检索服务_【Solr】

主要内容

1. Solr 简介
2. Solr 搜索原理
3. Solr 单机版安装
4. 可视化管理界面
5. 新建核心
6. 分词
7. Dataimport
8. 使用 SolrJ 操作 Solr
9. Spring Data for Apache Solr
10. SolrCloud

一、 Solr 简介

1 为什么使用 Solr

在海量数据下，对 MySQL 或 Oracle 进行模糊查询或条件查询的效率是很低的。而搜 索功能在绝大多数项目中都是必须的，如何提升搜索效率是很多互联网项目必须要考虑的问题。

既然使用关系型数据库进行搜索效率比较低，最直接的解决方案就是使用专用搜索工具 进行搜索，从而提升搜索效率。

2 常见搜索解决方案

基于 Apache Lucene（全文检索工具库）实现搜索。但是 Lucene 的使用对于绝大多 数的程序员都是“噩梦级”的。

基于谷歌 API 实现搜索。
基于百度 API 实现搜索。

3 Solr 简介

Solr 是基于 Apache Lucene 构建的用于搜索和分析的开源解决方案。可提供可扩展索 引、搜索功能、高亮显示和文字解析功能。

Solr 本质就是一个 Java web 项目，且内嵌了Jetty 服务器，所以安装起来非常方便。 客户端操作 Solr 的过程和平时我们所写项目一样，就是请求 Solr 中控制器，处理完数据后 把结果响应给客户端。

4 正向索引和反向索引

只要讨论搜索就不得不提的两个概念：正向索引（forward index）和反向索引(inverted index)。

正向索引：从文档内容到词组的过程。每次搜索的时候需要搜索所有文档，每个文档比 较搜索条件和词组。


反向索引：是正向索引的逆向。建立词组和文档的映射关系。通过找到词组就能找到文 档内容。（和新华字典找字很像）

二、 Solr 搜索原理

1 搜索原理

Solr 能够提升检索效率的主要原因就是分词和索引（反向索引）。

分词：会对搜索条件/存储内容进行分词，分成日常所使用的词语。

索引：存储在 Solr 中内容会按照程序员的要求来是否建立索引。如果要求建立索引会 把存储内容中关键字（分词）建立索引。

2 Solr 中数据存储说明

Solr 为了给内容建立索引，所以 Solr 就必须具备数据存储能力。所有需要被搜索的内 容都需要存储在 Solr 中，在开发中需要把数据库中数据添加到 Solr 中进行初始化，每次修 改数据库中数据还需要同步 Solr 中的数据。

Solr 中数据存储是存储在 Document 对象中，对象中可以包含的属性和属性类型都定 义在 schema.xml中。如果需要自定义属性或自定义属性类型都需要修改 schema.xml 配 置文件。从 Solr 5 开始 schema.xml更改名称为 managed-schema(没有扩展名)

三、 Solr 单机版安装

Solr 是使用 Java 编写，所以必选先安装 JDK。

1 上传并解压

上传压缩包 solr-8.2.0.tgz 到/usr/local/tmp 中。

解压
# cd /usr/local/tmp
# tar zxf solr-8.2.0.tgz

2 复制到/usr/local 中

# cp -r solr-8.2.0 ../solr

3 修改启动参数

修改启动参数，否则启动时报警告。提示设置 SOLR_ULIMIT_CHECKS=false

# cd /usr/local/solr/bin

# vim solr.in.sh

4 启动 Solr

Solr 内嵌 Jetty，直接启动即可。默认监听 8983 端口。
Solr 默认不推荐 root 账户启动，如果是 root 账户启动需要添加-force参数。
# ./solr start -force

四、 可视化管理界面

在关闭防火墙的前提下，可以在 windows 的浏览器中访问 Solr。
输入:http://192.168.32.133:8983 就可以访问 Solr 的可视化管理界面。

左侧有 5 个菜单。分别是：
（1）Dashboard：面板显示 Solr 的总体信息。
（2）Logging：日志
（3）Core Admin：Solr 的核心。类似于数据的 Database
（4）Java Perperties：所有 Java 相关属性。
（5）Thread Dump：线程相关信息。
（6）如果有 Core，将显示在此处。

五、 新建核心

Solr 安装完成后默认是没有核心的。
需要手动配置。 需要在 solr/server/solr下新建文件夹，并给定配置文件，否则无法建立。

1 新建目录

在/usr/local/solr/server/solr中新建自定义名称目录。此处示例名称为 testcore。
# cd /usr/local/solr/server/solr
# mkdir testcore

2 复制配置文件

在 configsets 里面包含了_default 和 sample_techproducts_configs。里面都是配置 文件示例。_default 属于默认配置，较纯净。sample_techproducts_configs 是带有了一 些配置示例。
# cp -r configsets/_default/conf/ testcore/

3 填写 Core 信息

在可视化管理界面中 Core Admin 中编写信息后点击 Add Core 后，短暂延迟后 testcore 就会创建成功。schema 处不用更改。

4 出现 testcore

在客户端管理界面中，选择新建的 Core 后，就可以按照自己项目的需求进行操作了。

六、 分词 Analysis

在 Solr 可视化管理界面中，Core 的管理菜单项中都会有 Analysis。表示根据 Scheme.xml(managed-schema)中配置要求进行解析。 对英文解析就比较简单了，只要按照空格把英文语句拆分成英文单词即可。

但是如果条件是中文时，把一句话按照字进行拆分就不是很合理了。正确的方式是按照 合理的词组进行拆分。

1 中文分词器安装及配置步骤

上传ik-analyzer.jar到 webapps 中。
去 https://search.maven.org/search?q=com.github.magese下 载 对 应 版 本 的ik-analyzer。
可以在"软件/Analyzer"中直接获取。

1.1 上传 jar 到指定目录

上传 ik-analyzer-8.2.0.jar 到/usr/local/solr/server/solr-webapp/webapp/WEB-INF/lib目录中

1.2 修改配置文件

修改/usr/local/solr/server/solr/testcore/conf/managed-schema

# vim /usr/local/solr/server/solr/testcore/conf/managed-schema

排版：Esc 退出编辑状态下：gg=G
添加下面内容。

<field name="myfield" type="text_ik" indexed="true" stored="true" />
	<fieldType name="text_ik" class="solr.TextField"> 
		<analyzer type="index"> 
			<tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory" useSmart="false" conf="ik.conf"/> 
			<filter class="solr.LowerCaseFilterFactory"/> 
		</analyzer> 
		<analyzer type="query"> 
			<tokenizer class="org.wltea.analyzer.lucene.IKTokenizerFactory" useSmart="true" conf="ik.conf"/> 
			<filter class="solr.LowerCaseFilterFactory"/> 
		</analyzer> 
	</fieldType>

1.3 重启

# cd /usr/local/solr/bin
# ./solr stop -all
# ./solr start -force

1.4 验证

可以在可视化管理界面中找到 myfield 属性进行验证。

2 managed-schema 配置说明

2.1<fieldType/>

表 示 定 义 一 个 属 性 类 型 。 在 Solr 中 属 性 类 型 都 是 自 定 义 的 。 在 上 面 配 置 中 name="text_ik"为自定义类型。当某个属性取值为text_ik 时 IK Analyzer才能生效。

2.2 <field/>

表示向 Document 中添加一个属性。

常用属性：

• name: 属性名
• type:属性类型。所有类型都是 solr 使用<fieldType>配置的
• indexed: 是否建立索引
• stored: solr 是否把该属性值响应给搜索用户。
• required：该属性是否是必须的。默认 id 是必须的。
• multiValued：如果为 true，表示该属性为复合属性，此属性中包含了多个其他的 属性。常用在多个列作为搜索条件时，把这些列定义定义成一个新的复合属性，通过搜索一 个复合属性就可以实现搜索多个列。当设置为 true 时与<copyField source="" dest=""/>结合使用

2.3 <uniqueKey>

唯一主键，Solr 中默认定义 id 属性为唯一主键。ID 的值是不允许重复的。

2.4<dynamicField>

名称中允许*进行通配。代表满足特定名称要求的一组属性。

七、 Dataimport

可以使用 Solr 自带的 Dataimport 功能把数据库中数据快速导入到 solr 中.必须保证managed-schema 和数据库中表的列对应。

1 修改配置文件

修改 solrconfig.xml，添加下面内容

<!-- 配置数据导入的处理器 --> 
<requestHandler name="/dataimport" class="org.apache.solr.handler.dataimport.DataImportHandler"> 
	<lst name="defaults"> 
		<!-- 加载 data-config.xml --> 
		<str name="config">data-config.xml</str> 
	</lst> 
</requestHandler>

2 新建 data-config.xml

和 solrconfig.xml 同一目录下新建 data-config.xml

<?xml version="1.0" encoding="UTF-8"?> 
<dataConfig> 
	<dataSource type="JdbcDataSource" driver="com.mysql.jdbc.Driver" url="jdbc:mysql://192.168.51.241:3306/maven" user="root" password="root"/> 
	<document> 
		<entity name="product" query="SELECT id,name,price from product"> 
			<!-- 实现数据库的列和索引库的字段的映射 column 指定数据库的列表 name 指定索引库的字段名字，必须和 schema.xml 中定义的一样 -->
			<field column="id" name="id"/> 
			<field column="name" name="name"/> 
			<field column="price" name="price"/>
		</entity> 
	</document> 
</dataConfig>

3 添加 jar

向 solr-webapp 中添加三个 jar。在 dist 中两个还有一个数据库驱动。

4 操作

重启 solr 后，在可视化管理页面中进行数据导入。
注意：
点击导入按钮后，要记得点击刷新按钮。

八、 菜单项目 Documents 使用办法

以 XML 格式举例

1 新增/修改

当 id 不存在时新增，当 id 存在修改。

<doc> 
	<field name="id">8</field> 
	<field name="name">明天更大卖</field> 
	<field name="price">98</field> 
</doc>

2 删除

2.1 根据主键删除

<delete> 
	<id>8</id> 
</delete>

2.2 根据条件删除

<delete> 
	<query>*:*</query> 
</delete>

九、 菜单项目 query 查询使用办法

1 查询全部

只要在 q 参数中写入*:*既是搜索全部数据。

2 条件查询

在 q 参数部分写入 字段名:搜索条件值， 既是条件搜索

3 分页查询

在条件 start,rows 中输入从第几条数据开始查询，查询多少条数据。下标从 0 开始。 类似 MySQL 数据库中的 limit。

4 查询排序

在 sort 条件中输入 字段名 排序规则。 排序规则包括 asc 和 desc。

5 高亮查询

选中 hl 高亮复选框，在hl.fl中输入高亮显示的字段名称，在 hl.simple.pre中输入高 亮前缀，在 hl.simple.post中输入高亮后缀。

十、 使用 SolrJ 操作 Solr

SolrJ 是 Solr 提供的 Java 客户端 API。通过 SolrJ 可以实现 Java 程序对 Solr 中数据的 操作。

大前提：添加 SolrJ 依赖。依赖版本和 Solr 版本严格对应

<dependencies> 
	<dependency> 
		<groupId>org.apache.solr</groupId> 
		<artifactId>solr-solrj</artifactId> 
		<version>8.2.0</version> 
	</dependency> 
</dependencies>

1 新增/修改实现

String url = "http://192.168.32.133:8983/solr/testcore"; 
HttpSolrClient solrClient = new HttpSolrClient.Builder(url).build(); 
SolrInputDocument inputDocument = new SolrInputDocument(); 
inputDocument.addField("id","3"); 
inputDocument.addField("myfield","myfield3"); 
solrClient.add(inputDocument); 
solrClient.commit();

2 删除实现

String url = "http://192.168.32.133:8983/solr/testcore"; 
HttpSolrClient solrClient = new HttpSolrClient.Builder(url).build(); 
solrClient.deleteById("3"); 
solrClient.commit();

3 查询实现

public void testQuery(){
    
     
	try {
    
    
		String url = "http://192.168.52.130:8983/solr/testcore"; 
		HttpSolrClient solrClient = new HttpSolrClient.Builder(url).build();
		//封装了所有查询条件 
		SolrQuery params = new SolrQuery(); 
		params.setQuery("name:丰富的"); 
		//排序
		params.setSort("price", SolrQuery.ORDER.desc);
		//分页
		params.setStart(0); 
		params.setRows(1);
		//高亮
		params.setHighlight(true); 
		params.addHighlightField("name"); 
		params.setHighlightSimplePre("<span>"); 
		params.setHighlightSimplePost("</span>");

		QueryResponse response = solrClient.query(params); 
		SolrDocumentList list = response.getResults(); 
		System.out.println("总条数："+list.getNumFound());

		//高亮数据 
		Map<String, Map<String, List<String>>> highlighting = response.getHighlighting();

		for(SolrDocument doc :list){
    
     
			System.out.println(doc.get("id")); 
			Map<String, List<String>> map = highlighting.get(doc.get("id")); 
			List<String> HLList = map.get("name"); 
			if(HLList!=null&&HLList.size()>0){
    
    //显示高亮数据 
				System.out.println(HLList.get(0)); 
			}else{
    
    
				System.out.println(doc.get("name")); 
			}
			System.out.println(doc.get("price")); 
			System.out.println("==================="); 
		}
		solrClient.close(); 
	} catch (SolrServerException e) {
    
     
		e.printStackTrace(); 
	} catch (IOException e) {
    
     
		e.printStackTrace(); 
	} 
}		

package com.bjsxt.solr;

import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.impl.HttpSolrClient;
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.SolrInputDocument;
import org.apache.solr.common.params.SolrParams;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * 使用SolrJ访问Solr服务。
 */
public class FirstAccess {
    
    
    public static void main(String[] args) {
    
    
        search();
    }

    // 搜索数据
    public static void search(){
    
    
        HttpSolrClient client = null;
        try{
    
    
            String url = "http://192.168.89.140:8983/solr/bjsxt";
            client = new HttpSolrClient.Builder(url).build();

            // 创建搜索条件对象。
            SolrQuery params = new SolrQuery();
            // 提供搜索关键字， q  *:*
            params.setQuery("title_zh_cn:管理");

            // 排序
            params.setSort("id", SolrQuery.ORDER.asc);

            // 分页
            params.setStart(0); // 第几行开始查询
            params.setRows(3); // 查询多少行

            // 高亮
            // 开启高亮
            params.setHighlight(true);
            // 设置高亮字段，如果有多个高亮字段，多次调用当前方法。
            params.addHighlightField("title_zh_cn");
            // 设置高亮前缀
            params.setHighlightSimplePre("<span style='color:red'>");
            // 设置高亮后缀
            params.setHighlightSimplePost("</span>");

            // 搜索数据
            QueryResponse response = client.query(params);

            // 从响应中获取高亮结果数据集合 {主键:{字段名:["高亮数据", "高亮数据"]}}
            Map<String, Map<String, List<String>>> highlightMap = response.getHighlighting();

            // 获取搜索返回结果集合  SolrDocumentList 是List接口的实现。 固定泛型是 SolrDocument
            SolrDocumentList docList = response.getResults();
            System.out.println("本次查询返回数据行数" + docList.size());
            System.out.println("本次搜索总计数据行数" + docList.getNumFound());
            for(SolrDocument doc : docList){
    
    
                System.out.print(doc + "【 id = " + doc.getFieldValue("id")
                        + "， title_zh_cn = " + doc.getFieldValue("title_zh_cn") + "】");

                // 输出高亮
                // 根据当前文档主键查询高亮数据
                Map<String, List<String>> entry = highlightMap.get(doc.getFieldValue("id"));
                if(null != entry && entry.size() > 0){
    
    
                    // 有高亮数据
                    List<String> hlStrList = entry.get("title_zh_cn");
                    System.out.println(" 高亮数据内容是：【" + hlStrList + "】");
                }

                System.out.println();
            }
        }catch(Exception e){
    
    
            e.printStackTrace();
        }finally {
    
    
            try {
    
    
                client.close();
            } catch (IOException e) {
    
    
                e.printStackTrace();
            }
        }
    }

    // 删除数据
    public static void delete(){
    
    
        HttpSolrClient client = null;
        try{
    
    
            String url = "http://192.168.89.140:8983/solr/bjsxt";
            client = new HttpSolrClient.Builder(url).build();

            // 删除数据
            client.deleteById("2000");  // 删除单数据

            client.deleteById(Arrays.asList("100", "101", "102", "103")); // 批量删除

            client.deleteByQuery("title_zh_cn:角色"); // 条件删除， 条件格式 -  字段名:条件数据

            client.commit();
        }catch(Exception e){
    
    
            e.printStackTrace();
        }finally {
    
    
            try {
    
    
                client.close();
            } catch (IOException e) {
    
    
                e.printStackTrace();
            }
        }
    }

    // 保存数据到Solr，如果主键字段id值唯一就是新增，不唯一就是覆盖（更新）
    public static void save(){
    
    
        HttpSolrClient client = null;
        try {
    
    
            // 创建客户端
            String url = "http://192.168.89.140:8983/solr/bjsxt";
            client = new HttpSolrClient.Builder(url).build();

            // 创建要保存的数据对象
            SolrInputDocument doc = new SolrInputDocument();
            doc.addField("id", "2000");
            doc.addField("title_zh_cn", "SolrJ保存数据-二次执行");

            // 执行数据保存
            client.add(doc);

            // 事务管理
            client.commit(); // 提交当前url指向的core collection
            // client.commit("bjsxt");  // 提供core collection名称，指定提交事务

        }catch(Exception e){
    
    
            e.printStackTrace();
        }finally{
    
    
            // 回收资源
            try {
    
    
                client.close();
            } catch (IOException e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

十一、 Spring Data for Apache Solr

1 Spring Data 简介

Spring Data 是 Spring 的顶级项目。里面包含了 N 多个二级子项目，每个子项目对 应一种技术或工具。其目的为了让数据访问更加简单，更加方便的和 Spring 进行整合。

Spring Data 项目如果单独使用是还需要配置 XML 配置文件的，当和 Spring Boot 整合后使用起来非常方便。spring-boot-starter-data-xx就是对应的启动器。

2 实现步骤

2.1 添加依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bjsxt</groupId>
    <artifactId>solr_spring_boot_solr</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.5.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

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

</project>

2.2 编写配置文件

spring:
  data:
    solr:
      host: http://192.168.89.140:8983/solr # 配置solr服务器所在地址

启动类

/**
 * 启动类
 * EnableSolrRepositories注解 - 开启Solr访问能力。
 */
@SpringBootApplication
@EnableSolrRepositories
public class FirstSolrApp {
    
    
    public static void main(String[] args) {
    
    
        SpringApplication.run(FirstSolrApp.class, args);
    }
}

Menu实体类

package com.bjxt.solr.entity;


import org.apache.solr.client.solrj.beans.Field;
import org.springframework.data.annotation.Id;
import org.springframework.data.solr.core.mapping.SolrDocument;

import java.io.Serializable;
import java.util.Objects;

@SolrDocument(collection = "bjsxt")
public class Menu implements Serializable {
    
    
    // @Id - 代表当前字段是唯一主键字段。 在高亮查询的时候，需要检查。
    @Field(value = "id")
    @Id
    private Long menuId;
    @Field(value = "title_zh_cn")
    private String menuName;

    public Menu(){
    
    }

    @Override
    public String toString() {
    
    
        return "Menu{" +
                "menuId=" + menuId +
                ", menuName='" + menuName + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
    
    
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Menu menu = (Menu) o;
        return Objects.equals(menuId, menu.menuId) &&
                Objects.equals(menuName, menu.menuName);
    }

    @Override
    public int hashCode() {
    
    
        return Objects.hash(menuId, menuName);
    }

    public Long getMenuId() {
    
    
        return menuId;
    }

    public void setMenuId(Long menuId) {
    
    
        this.menuId = menuId;
    }

    public String getMenuName() {
    
    
        return menuName;
    }

    public void setMenuName(String menuName) {
    
    
        this.menuName = menuName;
    }
}

2.3 编写测试类

package com.bjsxt.solr.test;

import com.bjxt.solr.FirstSolrApp;
import com.bjxt.solr.entity.Menu;
import org.apache.solr.client.solrj.response.UpdateResponse;
import org.apache.solr.common.SolrInputDocument;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Sort;
import org.springframework.data.solr.core.SolrTemplate;
import org.springframework.data.solr.core.query.*;
import org.springframework.data.solr.core.query.result.HighlightEntry;
import org.springframework.data.solr.core.query.result.HighlightPage;
import org.springframework.data.solr.core.query.result.ScoredPage;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * SpringBootTest测试类型
 */
@SpringBootTest(classes = {
    
    FirstSolrApp.class})
@RunWith(SpringRunner.class)
public class TestSolr {
    
    
    /**
     * SpringData的所有子工程，几乎都会提供一个XxxTemplate类型，
     * 这个Template是用来实现客户端服务器数据交互的对象。
     */
    @Autowired
    private SolrTemplate template;

    /**
     * 高亮搜索
     */
    @Test
    public void testHighlightSearch(){
    
    
        SimpleHighlightQuery query = new SimpleHighlightQuery();
        query.addCriteria(Criteria.where("title_zh_cn").is("管理"));
        // 设置高亮
        // 创建高亮设置对象
        HighlightOptions options = new HighlightOptions();
        // 设置高亮字段名
        options.addField("title_zh_cn");
        // 设置高亮前后缀
        options.setSimplePrefix("<span>");
        options.setSimplePostfix("</span>");
        query.setHighlightOptions(options);

        // 搜索
        HighlightPage<Menu> page = template.queryForHighlightPage("bjsxt", query, Menu.class);
        List<Menu> result = new ArrayList<>();
        // 获取搜索结果中高亮处理过的结果。
        List<HighlightEntry<Menu>> list = page.getHighlighted();
        for(HighlightEntry<Menu> entry: list){
    
    
            // 获取entry中的高亮数据集合
            List<HighlightEntry.Highlight> highlights = entry.getHighlights();
            // 获取没有经过高亮处理的结果对象
            Menu menu = entry.getEntity();
            for (HighlightEntry.Highlight highlight : highlights){
    
    
                // 判断高亮数据的字段是否是自己需要的。
                if(highlight.getField().getName().equals("title_zh_cn")) {
    
    
                    // 获取高亮处理的字符串
                    String highlightString = highlight.getSnipplets().get(0);
                    // 把高亮处理的字符串赋值给对象。
                    menu.setMenuName(highlightString);
                }
            }
            result.add(menu);
        }
        System.out.println(result);
    }

    /**
     * 搜索数据
     */
    @Test
    public void testSearch(){
    
    
        // 创建搜索条件
        SimpleQuery query = new SimpleQuery();
        query.addCriteria(Criteria.where("title_zh_cn").is("管理"));
        // 分页
        query.setOffset(0L); // 第几行开始查询
        query.setRows(2); // 查询多少数据
        // 排序
        query.addSort(Sort.by(Sort.Direction.DESC, "id"));

        // 执行搜索
        // 参数 ：collection - 索引库名称， query - 搜索条件， Class - 实体类对象
        ScoredPage<Menu> scoredPage = template.queryForPage("bjsxt", query, Menu.class);

        // 处理结果
        System.out.println("总计数据行数： " + scoredPage.getTotalElements());
        System.out.println("总计页码数：" + scoredPage.getTotalPages());
        // 搜索的结果集合
        List<Menu> list = scoredPage.getContent();
        System.out.println(list);

    }

    /**
     * 删除数据
     */
    @Test
    public void testDelete(){
    
    
        // 主键删除唯一数据
        UpdateResponse response = template.deleteByIds("bjsxt", "2000");
        System.out.println(response.getStatus() == 0 ? "删除成功" : "删除失败");

        // 根据主键批量删除数据
        response = template.deleteByIds("bjsxt", Arrays.asList("104", "105"));
        System.out.println(response.getStatus() == 0 ? "批量删除成功" : "批量删除失败");

        // 根据条件删除
        SimpleQuery query = new SimpleQuery();
        // Criteria.where("title_zh_cn") - 提供一个搜索条件，对应的字段名是什么
        // criteria.is("参数") - 为这个搜索条件绑定具体的参数值
        query.addCriteria(Criteria.where("title_zh_cn").is("参数"));
        response = template.delete("bjsxt", query);
        System.out.println(response.getStatus() == 0 ? "条件删除成功" : "条件删除失败");

        // 提交事务
        template.commit("bjsxt");
    }

    /**
     * 保存数据
     * 使用SpringData开发数据访问的时候，不要回收资源，因为SpringData会自动维护数据源连接池
     */
    @Test
    public void testSave(){
    
    
        // 创建要新增的对象
        SolrInputDocument doc = new SolrInputDocument();
        doc.addField("id", "2000");
        doc.addField("title_zh_cn", "使用SpringDataForApacheSolr实现数据保存");
        // 数据保存。主键唯一是新增，不为是覆盖。
        UpdateResponse response = template.saveBean("bjsxt", doc);

        System.out.println(response.getStatus() == 0 ? "保存成功" : "保存失败");

        // 提交事务
        template.commit("bjsxt");
    }

}

十二、 SolrCloud

Solr 可以搭建具备容错能力和高可用的 Solr 集群。集群中集群配置、自动负载均衡和 查询故障转移、Zookeeper 集群实现集群协调管理，这些全部功能统称为 SolrCloud。

SolrCloud 是基于 Zookeeper 进行管理的。在 Solr 中已经内置了 Zookeeper 相关内 容，当执行集群创建命令会自动创建 Zookeeper 相关内容。这个使用的是 Zookeeper 的 集群管理功能实现的。

1 搭建

1.1 创建

SolrCloud 已经包含在了 Solr 中，可以直接启动 Solr 集群。

# ./solr -e cloud -noprompt -force

此命令等同于# ./solr -e cloud -force全部参数为默认值。

运行成功后会在 example 文件夹多出 cloud 文件夹。

1.2 停止

# ./solr stop -all

1.3 重新运行

# ./solr start -c -p 8983 -s ../example/cloud/node1/solr/ -force

#./solr start -c -p 7574 -z localhost:9983 -s ../example/cloud/node2/solr/ -force


ElasticSearch