# 1.Redis持久化



![image.png](/static/img/15fcababaf222915ece91c539644cf65.image.webp)

RDB

![image.png](/static/img/a491304458af13a58f011e84f0f4ef8c.image.webp)

安装redis

官网下载redis安装包

![image.png](/static/img/58d34b4a50cb1817e81ebc7fe0c0a407.image.webp)

解压缩

![image.png](/static/img/ad00a81fb140c6abc8a1c2aeda304071.image.webp)

进入redis文件夹编译

![image.png](/static/img/8da649764571f6df16ba8a23ff291607.image.webp)

修改基础配置

![image.png](/static/img/5653ce1fafc2ca9ecc8b9b46265a7690.image.webp)

启动和停止

![image.png](/static/img/12daa581d61e1c241f1d7aa473227598.image.webp)

RDB会在redis关闭时执行，默认将数据存储在运行redis的目录

RDB相关配置

![image.png](/static/img/24ec7ada65c8794d7418663fe23938fd.image.webp)

RDB底层实现

![image.png](/static/img/c9c374b35391b5112f5600c02516d0e9.image.webp)

# AOF持久化

![image.png](/static/img/7df5293ba92008e2b444f52bbe9d51a8.image.webp)

AOF默认关闭

![image.png](/static/img/44a7f733764f663c8e12d9029e8201d8.image.webp)

AOF缺点解决

![image.png](/static/img/d49c703304c5f631adc49263157af841.image.webp)

配置自动触发BGREWRITEAOF

![image.png](/static/img/f659385a0810f739ecd69b0125f7ddb1.image.webp)

持久化方案对比

![image.png](/static/img/7c238ac9d0fe87b4c379f57f0e965735.image.webp)

# 3.Redis主从搭建

![image.png](/static/img/830c6f34a128cebce001d7b5163570fa.image.webp)

创建3个文件夹，分别拷贝配置文件

![image.png](/static/img/ce8d956455e892d2d89bbbf008de0599.image.webp)

分别修改配置文件

```SHELL
sed -i -e 's/6379/7001/g' -e 's/dir .\//dir \/tmp\/7001\//g' 7001/redis.conf
sed -i -e 's/6379/7002/g' -e 's/dir .\//dir \/tmp\/7002\//g' 7002/redis.conf
sed -i -e 's/6379/7003/g' -e 's/dir .\//dir \/tmp\/7003\//g' 7003/redis.conf
```

```SHELL
sed -i '1a replica-announce-ip 192.168.42.10' 7001/redis.conf
sed -i '1a replica-announce-ip 192.168.42.10' 7002/redis.conf
sed -i '1a replica-announce-ip 192.168.42.10' 7003/redis.conf
```
执行命令临时的主从关系

![image.png](/static/img/c50aed958a5558a8f4149574bfda8ea4.image.webp)

查看主从关系

```shell
[root@localhost tmp]# redis-cli -p 7001
127.0.0.1:7001> INFO replication
# Replication
role:master
connected_slaves:2
slave0:ip=192.168.42.10,port=7002,state=online,offset=84,lag=1
slave1:ip=192.168.42.10,port=7003,state=online,offset=84,lag=1

```

数据同步原理

第一次同步（全量同步）

![image.png](/static/img/67031721c3c7cb8b1120e25f7d94691a.image.webp)

![image.png](/static/img/043d9e65e0a62e390204f7dd21b15674.image.webp)

![image.png](/static/img/6f5b560768409fac9ed8ee1b35d61361.image.webp)

优化集群

![image.png](/static/img/098926137a91279b4b53cebb4f18c521.image.webp)

# 4.Redis哨兵

Redis分布式缓存

# 1.ACID原则



![image.png](/static/img/04a3f1208fe89608e7b0585366522eac.image.webp)

![image.png](/static/img/73adf4a53cd0ecb93f0a0f828b63dae8.image.webp)

# 2.解决分布式事务

cap定理

![image.png](/static/img/f1b7e4bd7253e9748c42f57da3e26d2b.image.webp)

base理论

![image.png](/static/img/ff54d31f75d8bd91509b8152d01fbfc9.image.webp)

# 3.初识seata

![image.png](/static/img/a253691bce007d771ddcac229c877be0.image.webp)

# 4.seata部署

官网下载seata

https://seata.apache.org/release-history/seata-server

配置register.conf

![image.png](/static/img/de5a4bf7c5c6c8cfd7dee772abe4af0e.image.webp)

修改为nacos相关配置

![image.png](/static/img/d1f124b1d452b730ab51fd421f8aa565.image.webp)

在nacos添加seata的配置


```config
# 数据存储方式，db代表数据库
store.mode=db
store.db.datasource=druid
store.db.dbType=mysql
## mysql 5.xx
store.db.driverClassName = "com.mysql.jdbc.Driver"
## mysql 8.0
#store.db.driverClassName=com.mysql.cj.jdbc.Driver
# 对应导入的数据库
store.db.url=jdbc:mysql://127.0.0.1:3306/seata?useUnicode=true&rewriteBatchedStatements=true&useSSL=false
store.db.user=root
store.db.password=qpj@123456
store.db.minConn=5
store.db.maxConn=30
store.db.globalTable=global_table
store.db.branchTable=branch_table
store.db.queryLimit=100
store.db.lockTable=lock_table
store.db.distributedLockTable=distributed_lock
​
# 对应 ${spring.application.name}-group，指定需要分布式事务的模块
service.vgroupMapping.seata-validate-demo-group=default
service.vgroupMapping.default=default
      
store.db.maxWait=5000
# 事务、日志等配置
server.recovery.committingRetryPeriod=1000
server.recovery.asynCommittingRetryPeriod=1000
server.recovery.rollbackingRetryPeriod=1000
server.recovery.timeoutRetryPeriod=1000
server.maxCommitRetryTimeout=-1
server.maxRollbackRetryTimeout=-1
server.rollbackRetryTimeoutUnlockEnable=false
server.undo.logSaveDays=7
server.undo.logDeletePeriod=86400000
​
# 客户端与服务端传输方式
transport.serialization=seata
transport.compressor=none
# 关闭metrics功能，提高性能
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898

```

在mysql中建表

创建数据库


```sql
CREATE DATABASE `seata` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;
```


```sql
-- -------------------------------- The script used when storeMode is 'db' --------------------------------
-- the table to store GlobalSession data
CREATE TABLE IF NOT EXISTS `global_table`
(
    `xid`                       VARCHAR(128) NOT NULL,
    `transaction_id`            BIGINT,
    `status`                    TINYINT      NOT NULL,
    `application_id`            VARCHAR(32),
    `transaction_service_group` VARCHAR(32),
    `transaction_name`          VARCHAR(128),
    `timeout`                   INT,
    `begin_time`                BIGINT,
    `application_data`          VARCHAR(2000),
    `gmt_create`                DATETIME,
    `gmt_modified`              DATETIME,
    PRIMARY KEY (`xid`),
    KEY `idx_status_gmt_modified` (`status` , `gmt_modified`),
    KEY `idx_transaction_id` (`transaction_id`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;
​
-- the table to store BranchSession data
CREATE TABLE IF NOT EXISTS `branch_table`
(
    `branch_id`         BIGINT       NOT NULL,
    `xid`               VARCHAR(128) NOT NULL,
    `transaction_id`    BIGINT,
    `resource_group_id` VARCHAR(32),
    `resource_id`       VARCHAR(256),
    `branch_type`       VARCHAR(8),
    `status`            TINYINT,
    `client_id`         VARCHAR(64),
    `application_data`  VARCHAR(2000),
    `gmt_create`        DATETIME(6),
    `gmt_modified`      DATETIME(6),
    PRIMARY KEY (`branch_id`),
    KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;
​
-- the table to store lock data
CREATE TABLE IF NOT EXISTS `lock_table`
(
    `row_key`        VARCHAR(128) NOT NULL,
    `xid`            VARCHAR(128),
    `transaction_id` BIGINT,
    `branch_id`      BIGINT       NOT NULL,
    `resource_id`    VARCHAR(256),
    `table_name`     VARCHAR(32),
    `pk`             VARCHAR(36),
    `status`         TINYINT      NOT NULL DEFAULT '0' COMMENT '0:locked ,1:rollbacking',
    `gmt_create`     DATETIME,
    `gmt_modified`   DATETIME,
    PRIMARY KEY (`row_key`),
    KEY `idx_status` (`status`),
    KEY `idx_branch_id` (`branch_id`),
    KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;
​
CREATE TABLE IF NOT EXISTS `distributed_lock`
(
    `lock_key`       CHAR(20) NOT NULL,
    `lock_value`     VARCHAR(20) NOT NULL,
    `expire`         BIGINT,
    primary key (`lock_key`)
) ENGINE = InnoDB
  DEFAULT CHARSET = utf8mb4;
​
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('AsyncCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryRollbacking', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('TxTimeoutCheck', ' ', 0);

```

项目中引入seata依赖

![image.png](/static/img/d6fd74b37daf61195cc1f0614558861a.image.webp)

微服务继承seata

![image.png](/static/img/324fc8c89490b6ed1ca66874bf18e47a.image.webp)

XA模式原理

![image.png](/static/img/25f98f014c2926f13f5430b4e7d2bb53.image.webp)

先执行操作但是不提交，在全部服务成功之后最后提交，一旦有操作失败就回滚操作

seata中的XA

![image.png](/static/img/fe41c89a0ff4d3699a4b66a38d6c0600.image.webp)

实现XA模式

![image.png](/static/img/fdf8f806035632394291d1354062cb26.image.webp)

AT模式

AT模式会直接提交，会记录前后更新的快照

![image.png](/static/img/467de18c3581a118c1e9a243462176fd.image.webp)

启用AT模式

导入seata数据库

```sql
-- seata_demo.undo_log definition
​
CREATE TABLE `undo_log` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `context` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int(11) NOT NULL,
  `log_created` datetime NOT NULL,
  `log_modified` datetime NOT NULL,
  `ext` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=63 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;

```

配置中修改为AT模式重启服务

TCC模式

![image.png](/static/img/05741f50abe5e893da9d100c4136da85.image.webp)

![image.png](/static/img/6f94080e0caf34bcea44c3cf693da3cb.image.webp)

![image.png](/static/img/6c2e9acde53da2445287771beac47eae.image.webp)

saga模式

![image.png](/static/img/20351b871cc8921c7b14c08beabe3799.image.webp)

模式对比

![image.png](/static/img/f1157f47bc9cf55c3b4fcc259b0cedf5.image.webp)

# 5.高可用

TC异地多机房容灾架构

![image.png](/static/img/f4532c98ac1a315bc0e036c354aa559b.image.webp)

分布式事务

# 1.下载sentinaljar包



![image.png](/static/img/6b265e5130e5a26dfeebdd3bb56f68da.image.webp)
# 2.启动jar包

![image.png](/static/img/ff19ad587fe4fa6e9ecaa42ef5018d07.image.webp)


```cmd
java -jar sentinel-dashboard-1.8.1.jar
```
# 3.进入控制台

![image.png](/static/img/b4954275d25c06945b708fae511d7988.image.webp)

# 4.配置sentinel

![image.png](/static/img/f15daa09340373e4ae9bb2b65b71b9ae.image.webp)

# 5.在项目中引入sentinal

```POM

        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
```
配置XML

```XML
    sentinel:
      transport:
        dashboard: localhost:8070
```

![image.png](/static/img/8c9f9c06c115fc79a238e9f48dfc117d.image.webp)

# 6.配置sentinel

簇点链路

![image.png](/static/img/bdc4731b016368804b94e94c57bc9e2d.image.webp)


![image.png](/static/img/60645968f7383b34acae25db3aa9ba82.image.webp)

高级选项

![image.png](/static/img/5c1f5cb9b6d89f0a054ba96ba8d07331.image.webp)

## (1)关联限流

当一个服务请求达到阈值对另一个服务做限制

![image.png](/static/img/dfe1f4bf7ea795e18059b8de135ec270.image.webp)

案例

![image.png](/static/img/23737c5d1c81a7f08aafaf236c5fa102.image.webp)

编写测试服务端点


```java
    @GetMapping("query")
    public String queryOrderTest(){
        return "查询数据";
    }

    @GetMapping("update")
    public String updateOrderTest(){
        return "更新数据";
    }
```

发送请求使Sentinel监控服务端点


![image.png](/static/img/7ee164c5017c65a20f8ace76c0ca78bf.image.webp)

添加关联端点

![image.png](/static/img/a3331a7e6b157814aeb951ced0a1f0bf.image.webp)

模拟请求update，query被限流

![image.png](/static/img/ab2a283cf9d63fe64c0eb3cade65c0bf.image.webp)

## (2)链路模式

只统计从指定链路访问本资源的请求

![image.png](/static/img/820ae612f68d7fe8b8fc58dd433371ac.image.webp)

例子

![image.png](/static/img/88f7ae634b07fbde1460247a4783d838.image.webp)


```java
// controller

    @GetMapping("query")
    public String queryOrderTest(){
        // 调用查询商品的方法
        orderService.queryGoods();
        System.out.println("查询订单");
        return "查询订单";
    }

    @GetMapping("save")
    public String saveOrderTest(){
        // 调用查询商品的方法
        orderService.queryGoods();
        System.out.println("新增订单");
        return "新增订单";
    }
```


```java
// service 模拟查询数据

    public void queryGoods()
    {
        System.err.println("查询商品");
    }
```

修改sentinel监控 关闭context整合

![image.png](/static/img/50f73e2ec66fcd99534662d58e3b2adc.image.webp)

显示出service的方法

![image.png](/static/img/7c3fd41f53795f3c6a3b3f3b536527ab.image.webp)

配置关联限制

![image.png](/static/img/710aa2545162edc9cc1e750d82fd0fad.image.webp)

## (3)流控效果

决定请求失败时如何处理

![image.png](/static/img/88013a0df782491eeb5b5516aad14a1a.image.webp)

![image.png](/static/img/49994f725388b1ebbb7446836ff26acf.image.webp)

配置 warn up

![image.png](/static/img/d1151d65b57077b858df0f8b075915cb.image.webp)

请求逐步通过

![image.png](/static/img/9713160c3ba6ca6a8439bbfe67b90817.image.webp)

## (4)排队等待

让进入的请求按照规定的时间间隔排队

![image.png](/static/img/e0fd76b5f7d1e3a5dc9a850f19a1a5cc.image.webp)

![image.png](/static/img/c5406da25485b5ea5ce5139f8232e58b.image.webp)

## (5)热点参数配置

![image.png](/static/img/e37e528e724c1cf07675733254eec421.image.webp)

例子

![image.png](/static/img/5fb170f565035f689690068fdd8490ae.image.webp)
![image.png](/static/img/aef6442af9ac3e4dcb72d94ffc965c72.image.webp)

修改代码


```java
    @SentinelResource("hot")  // 添加注解
    @GetMapping("{orderId}")
    public Order queryOrderByUserId(@PathVariable("orderId") Long orderId,@RequestHeader(value = "Truth",required = false) String truth) {
        System.out.println("truth"+truth);
        return orderService.queryOrderById(orderId);
    }
```


![image.png](/static/img/9049d0e26bea86c50bab3995e8f9fa12.image.webp)

# 7.线程隔离和降级
## (1)FegienClient整合Sentienl

线程隔离(舱闭模式)   熔断降级

![image.png](/static/img/3c7970b9cb53916617cc411cd735fa5e.image.webp)

想办法编写备用方案

![image.png](/static/img/9cea9eaba945fb971f6f79c5de4d74e0.image.webp)

步骤一

![image.png](/static/img/f5d64042ff05997935eb1f03a0a2db85.image.webp)

步骤二

![image.png](/static/img/8745d1f700f537be864ade7497db2823.image.webp)

```XML
feign:
  sentinel:
    enabled: true # 开启Feign对sentinel的支持
```
编写Factory

```java
package cn.itcast.feign.clients.fallback;

import cn.itcast.feign.clients.UserClient;
import cn.itcast.feign.pojo.User;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;


@Slf4j
public class UserClientFallBackFactory implements FallbackFactory<UserClient> {
    @Override
    public UserClient create(Throwable throwable) {
        return new UserClient (){
            @Override
            public User getUserById(Long id) {
                log.error("查询日志异常",throwable);
                return new User();
            }
        };
    }
}

```

添加到Bean管理

```java
    @Bean
    public UserClientFallBackFactory userClientFallBackFactory(){
        return new UserClientFallBackFactory();
    }
```

修改装饰器

```java
@FeignClient(value = "userservice",fallbackFactory = UserClientFallBackFactory.class)

```

![image.png](/static/img/9c603ce88d1e471f2965c68b02fc53c9.image.webp)

隔离方式

![image.png](/static/img/6240f7d101ba2f77df98a8c5e947a07b.image.webp)

两种隔离方式的优缺点

![image.png](/static/img/367d02223d4ce997f5acfae2b107808d.image.webp)

实现线程隔离

![image.png](/static/img/dcbf73a4462d23308d7eab2663fa7a4d.image.webp)

![image.png](/static/img/5a05c8e42ddb77a8cafc7777d80f1063.image.webp)

超出限制的请求会执行Factory中的方法

```console
2025-10-28 22:58:33.338 ERROR 22416 --- [nio-8080-exec-6] c.i.f.c.f.UserClientFallBackFactory      : 查询日志异常

com.alibaba.csp.sentinel.slots.block.flow.FlowException: null
```

熔断降级

![image.png](/static/img/40bc4f26258da1c5c8bc1a4e9ecd129b.image.webp)

熔断策略-慢调用

![image.png](/static/img/47139feb33c543345e68de50a816b11d.image.webp)

熔断策略-异常比例，异常数

![image.png](/static/img/e9bfda411168141e8d2b2b2918276227.image.webp)

# 8.授权规则

对请求者的身份进行判断

![image.png](/static/img/2552f5093016bbca5b3838f56905d363.image.webp)

![image.png](/static/img/d7529976cdf6cb71aea4b6905561e6fb.image.webp)

在网关的请求添加请求头判断是否为网关的请求

![image.png](/static/img/79177054b98105dde9404d83911be658.image.webp)


```java
package cn.itcast.order.sentinel;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.RequestOriginParser;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;


@Component
public class HeaderOriginParser implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest request) {
        // 尝试获取请求头
        String origin = request.getHeader("origin");
        if (StringUtils.isEmpty(origin)) {
            return "blank";
        }
        return origin;
    }
}
// 对服务端重写原有的接口
```

```XML
在gateway端添加origin请求头
            - AddRequestHeader=origin,gateway

```
在sentinel添加规则

![image.png](/static/img/762b51d21eaeb28534c97284c5398511.image.webp)

阻止除了网关来源的请求访问服务

自定义异常

![image.png](/static/img/652edb288e3d3006d113c49cfe72cce8.image.webp)

实现接口


```java
package cn.itcast.order.sentinel;

import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;




@Component
public class SentinelBlockHandler implements BlockExceptionHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws Exception {
        String msg = "未知异常";
        int status = 429;
        if (e instanceof FlowException) {
            msg = "请求被限流了";
        }else if (e instanceof DegradeException) {
            msg = "请求被降级了";
        } else if (e instanceof ParamFlowException) {
            msg = "热点参数限流";
        } else if (e instanceof AuthorityException) {
            msg = "请求没有权限";
            status = 401;
        }
        httpServletResponse.setContentType("application/json;charset=utf-8");
        httpServletResponse.setStatus(status);
        httpServletResponse.getWriter().println("{\"message\":\""+msg+"\",\"status\":"+status+"}");

    }
}

```

规则持久化

解决sentinel在服务重启时配置的规则消失

规则管理模式

规则管理有3种模式

原始模式（不支持持久化）

pull模式

![image.png](/static/img/d9ed5b40d324eb7205df222c34c1b3a8.image.webp)

push模式

![image.png](/static/img/975bee47a15e1ebd455c333986a17ab8.image.webp)

Sentienl

# 1.数据聚合



![image.png](/static/img/b3bd2c9dae71111fffd4302995b1c97f.image.webp)

DSL实现聚合

![image.png](/static/img/a390a659aac3e5744081997fb4edfd03.image.webp)

```DSL
GET /hotel/_search
{
  "size": 0,
  "aggs":{
    "brandAgg":{
      "terms":{
        "field": "brand",
        "size": 20
      }
    }
  }
}
```
自定义排序规则

![image.png](/static/img/025fe922c1b17b9678a9394e0caae7b0.image.webp)


```DSL
GET /hotel/_search
{
  "size": 0,
  "aggs":{
    "brandAgg":{
      "terms":{
        "field": "brand",
        "size": 20
        ,
         "order": {
          "_count": "asc"
        }
      }
    }
  }
}
```
限定搜索范围

![image.png](/static/img/a699815cf33c107fbe45dd64b64e1a3c.image.webp)

```DSL
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "lte": 200
      }
    }
  }, 
  "size": 0,
  "aggs":{
    "brandAgg":{
      "terms":{
        "field": "brand",
        "size": 20
        ,
         "order": {
          "_count": "asc"
        }
      }
    }
  }
}
```
嵌套聚合

![image.png](/static/img/d818a1d391991c6abca28173cd302a4c.image.webp)

```DSL
GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20
      },
      "aggs": {
        "scoreAgg": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}
```
嵌套聚合排序

```DSL
GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAgg": {
      "terms": {
        "field": "brand",
        "size": 20,
        "order": {
          "scoreAgg.avg": "desc"
        }
      },
      "aggs": {
        "scoreAgg": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}
```
RestClient实现聚合

![image.png](/static/img/916665525ac5b6d5996d23a53a595565.image.webp)

```java
    @Test
    public void testClientJuHe() throws IOException {
        SearchRequest request = new SearchRequest("hotel");
        request.source().size(0);
        request.source().aggregation(
                AggregationBuilders.terms("brand_agg")
                        .field("brand")
                        .size(20)
        );
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        System.out.println(response);
    }
```
# 2.自动补全分词

![image.png](/static/img/cebb7339e5271acbfe895d0e656b7c57.image.webp)

自定义分词器

![image.png](/static/img/fe512659c100df40e4b1dec363ddad8d.image.webp)


![image.png](/static/img/07a90fa9378057f8b85a34cf15e1214d.image.webp)

```DSL
// 自定义拼音分词器
PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": { 
        "my_analyzer": { 
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": {
        "py": { 
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
   "properties": { 
    "name":{
      "type":"text",
      "analyzer":"my_analyzer"
    }
    }
  }
}
```
settings中配置的分词器只对当前索引库生效,除非指明索引库

```DSL
POST /test/_analyze
{
  "text": ["如家酒店真不错"],
  "analyzer": "my_analyzer"
}

```
自动补全查询

![image.png](/static/img/9acb2309ab49d7ac2052999ec8304139.image.webp)

自动补全测试

```DSL
// 自动补全的索引库
PUT test
{
  "mappings": {
    "properties": {
      "title":{
        "type": "completion"
      }
    }
  }
}
// 示例数据
POST test/_doc
{
  "title": ["Sony", "WH-1000XM3"]
}
POST test/_doc
{
  "title": ["SK-II", "PITERA"]
}
POST test/_doc
{
  "title": ["Nintendo", "switch"]
}

// 自动补全查询
POST /test/_search
{
  "suggest": {
    "title_suggest": {
      "text": "s", // 关键字
      "completion": {
        "field": "title", // 补全字段
        "skip_duplicates": true, // 跳过重复的
        "size": 10 // 获取前10条结果
      }
    }
  }
}
```

实现酒店项目自动补全功能


```DSL
// 酒店数据索引库
PUT /hotel
{
  "settings": {
    "analysis": {
      "analyzer": {
        "text_anlyzer": {
          "tokenizer": "ik_max_word",
          "filter": "py"
        },
        "completion_analyzer": {
          "tokenizer": "keyword",
          "filter": "py"
        }
      },
      "filter": {
        "py": {
          "type": "pinyin",
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "id":{
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "text_anlyzer",
        "search_analyzer": "ik_smart",
        "copy_to": "all"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword",
        "copy_to": "all"
      },
      "city":{
        "type": "keyword"
      },
      "starName":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword",
        "copy_to": "all"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      },
      "all":{
        "type": "text",
        "analyzer": "text_anlyzer",
        "search_analyzer": "ik_smart"
      },
      "suggestion":{
          "type": "completion",
          "analyzer": "completion_analyzer"
      }
    }
  }
}
```
自动补全的restAPI

![image.png](/static/img/798f41fb2633de9997c888092da9f2bb.image.webp)

解析结果

![image.png](/static/img/74dcc1b148bcc35e54b3b0b1e27880ed.image.webp)

```java
    @Test
    public void testSuggestions() throws IOException {
        SearchRequest request = new SearchRequest("hotel");
        request.source().suggest(
                new SuggestBuilder().addSuggestion(
                        "suggestions",
                        SuggestBuilders.completionSuggestion("suggestion")
                                .prefix("hp")
                                .skipDuplicates(true)
                                .size(10)
                )
        );


        SearchResponse response = client.search(request, RequestOptions.DEFAULT);

        Suggest suggest = response.getSuggest();

        CompletionSuggestion completionSuggestion=  suggest.getSuggestion("suggestions");

        List<CompletionSuggestion.Entry.Option> options = completionSuggestion.getOptions();

        for (CompletionSuggestion.Entry.Option option : options) {
            String s = option.getText().toString();
            System.out.println(s);
        }
    }
```

实现酒店的自动补全


```java
@Override
    public List<String> suggestion(String key) {
        SearchRequest request = new SearchRequest("hotel");
        request.source().suggest(
                new SuggestBuilder().addSuggestion(
                        "suggestions",
                        SuggestBuilders.completionSuggestion("suggestion")
                                .prefix(key)
                                .skipDuplicates(true)
                                .size(10)
                )
        );


        try {
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);

            Suggest suggest = response.getSuggest();

            CompletionSuggestion completionSuggestion=  suggest.getSuggestion("suggestions");

            List<CompletionSuggestion.Entry.Option> options = completionSuggestion.getOptions();

            List<String> result = new ArrayList<>();

            for (CompletionSuggestion.Entry.Option option : options) {
                String s = option.getText().toString();
                result.add(s);
            }
            return result;
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
```
# 3.数据同步


![image.png](/static/img/29523f5ff855b2d56c1a39443583ea4c.image.webp)

## (1)同步调用

![image.png](/static/img/e44bda5084aa7f08e67b26f666ef5fb0.image.webp)

## (2)异步通知

![image.png](/static/img/95cd48cea9bf94780c7e1f1eb100626e.image.webp)

## (3)监听binlog

![image.png](/static/img/3c982d4e848e74bd37bf02adcd24ed82.image.webp)

总结

![image.png](/static/img/2dee8e0ab4a4f16f73d57fb89666bebb.image.webp)

ElasticSearch(2)

# 1.elasticsearch中的搜索结果处理


案例1

![image.png](/static/img/599817cdfa41175414210d2944e3b2fb.image.webp)


```DSL
GET /hotel/_search
{
  "query":{
    "match_all": {}
  },
    "sort":[
      {
      "score":"desc"
        
      },
      {
        "price":"asc"
    }
    ]
}

```
案例2

![image.png](/static/img/fd5537b4ddbc79477a696e79f2550a05.image.webp)

```DSL
# 31.034661 121.612282
GET /hotel/_search
{
  "query":{
    "match_all": {}
  },
  "sort":[
    {
      "_geo_distance": {
        "location": {
          "lat": 31.034661,
          "lon": 121.612282
        },
        "order": "asc",
        "unit": "km"
      }
    }]
}
```
# 2.分页结果

![image.png](/static/img/661d3d913087eecd8cc3556fafc11981.image.webp)

示例

```DSL
GET /hotel/_search
{
  "query":{
    "match_all": {}
  },
  "sort":[
    {
      "price":"asc"
    }
    ],
    "from": 0,
    "size": 20
}
```
深度分页问题

![image.png](/static/img/33e5371276e71222de599d7ebf30fff1.image.webp)

解决方案

![image.png](/static/img/7af7671f30fe6ace60c44e342f285e7f.image.webp)

# 3.结果高亮显示

![image.png](/static/img/86589a24119d1664d4dd130591542400.image.webp)

```DSL
GET /hotel/_search
{
  "query":{
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"
      }
    }
  }
}
```
# 4.使用RestClient实现es查询
快速入门
![image.png](/static/img/b6b3f17eb31721e68a45bf75b3151120.image.webp)

```java
    @Test
    void testMatchAll() throws IOException {
//        准备reuqest
        SearchRequest request = new SearchRequest("hotel");
//        准备DSL
        request.source().query(QueryBuilders.matchAllQuery());
//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);

        System.out.println(response);
    }
```

解析结果


![image.png](/static/img/edae04a5514f506e13ee96801c7b71db.image.webp)

```java
    @Test
    void testMatchAll() throws IOException {
//        准备reuqest
        SearchRequest request = new SearchRequest("hotel");
//        准备DSL
        request.source().query(QueryBuilders.matchAllQuery());
//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);

        SearchHits searchHits = response.getHits();

        long total = searchHits.getTotalHits().value;

        SearchHit[] hits = searchHits.getHits();

        for (SearchHit hit : hits) {

            String json = hit.getSourceAsString();

            System.out.println(json);
        }

    }
```

match查询


![image.png](/static/img/874bcd79b1cf35facb107c14d9ed990b.image.webp)


```java
    @Test
    void testMatch() throws IOException {
//        准备reuqest
        SearchRequest request = new SearchRequest("hotel");
//        准备DSL
        request.source().query(QueryBuilders.matchQuery("all","如家"));
//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);

        SearchHits searchHits = response.getHits();

        long total = searchHits.getTotalHits().value;

        SearchHit[] hits = searchHits.getHits();

        for (SearchHit hit : hits) {

            String json = hit.getSourceAsString();

            System.out.println(json);
        }

    }
```

精确查询


![image.png](/static/img/254fa6cf6ef6532fd7c66aa0cea2a111.image.webp)

复合查询


![image.png](/static/img/97cf0db2085e7c1f796100831bbcd1c8.image.webp)


```java
    @Test
    void testBoolQuery() throws IOException {
//        准备reuqest
        SearchRequest request = new SearchRequest("hotel");
//       创建boolQueryBuilder对象
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
//      添加term
        boolQueryBuilder.must(QueryBuilders.termQuery("city","上海"));
//        添加range
        boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").lte(250));

        request.source().query(boolQueryBuilder);

//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);

        SearchHits searchHits = response.getHits();

        long total = searchHits.getTotalHits().value;

        SearchHit[] hits = searchHits.getHits();

        for (SearchHit hit : hits) {

            String json = hit.getSourceAsString();

            System.out.println(json);
        }

    }
```

# 5.使用RestClient实现结果处理


![image.png](/static/img/b3c25962c1c92050f629cd2a77a8ca9a.image.webp)


```java
    @Test
    void testPageAndSort() throws IOException {
//        准备reuqest

        int page = 2, size = 5;
        SearchRequest request = new SearchRequest("hotel");
        request.source().query(QueryBuilders.matchAllQuery());
        request.source().sort("price", SortOrder.ASC);
        request.source().from((page-1)*size).size(size);
//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        long total = searchHits.getTotalHits().value;
        System.out.println("共"+total+"条数据");
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String json = hit.getSourceAsString();
            HotelDoc hotelDoc = JSON.parseObject(json,HotelDoc.class);
            System.out.println(hotelDoc.toString());
        }

    }
```

RestClient处理高亮

![image.png](/static/img/d580f20d55590a061bd2b89688e47d1a.image.webp)


```java
    @Test
    void testHeightLight() throws IOException {
//        准备reuqest
        int page = 2, size = 5;
        SearchRequest request = new SearchRequest("hotel");
        request.source().query(QueryBuilders.matchQuery("all","如家"));
        request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
//        发送请求
        SearchResponse response = client.search(request,RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        long total = searchHits.getTotalHits().value;
        System.out.println("共"+total+"条数据");
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            String json = hit.getSourceAsString();
            HotelDoc hotelDoc = JSON.parseObject(json,HotelDoc.class);
            Map<String,HighlightField> highlightFields = hit.getHighlightFields();
            if (!CollectionUtils.isEmpty(highlightFields)){
//              根据字段名获取高亮结果
                HighlightField highlightField = highlightFields.get("name");
                if (highlightField!=null){
//                  获取高亮值
                    String name = highlightField.getFragments()[0].string();
//                  覆盖非非高亮结果
                    hotelDoc.setName(name);
                }

            }
//
            System.out.println("hotelDoc = "+hotelDoc.toString());
        }

    }
```

地理距离排序


![image.png](/static/img/43bdaa86eeba48f54065980d628d1732.image.webp)

添加权重



![image.png](/static/img/91f0c490400dbe3bff5758c3a81d2ed9.image.webp)


案例关键代码


```java
package cn.itcast.hotel.service.impl;

import cn.itcast.hotel.mapper.HotelMapper;
import cn.itcast.hotel.pojo.Hotel;
import cn.itcast.hotel.pojo.HotelDoc;
import cn.itcast.hotel.pojo.PageResult;
import cn.itcast.hotel.pojo.RequestParams;
import cn.itcast.hotel.service.IHotelService;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.geo.GeoPoint;
import org.elasticsearch.common.unit.DistanceUnit;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.swing.text.Highlighter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
public class HotelService extends ServiceImpl<HotelMapper, Hotel> implements IHotelService {

    // 注入Elasticsearch的高级客户端
    @Autowired
    private RestHighLevelClient client;

    /**
     * 酒店搜索方法
     * @param requestParams 搜索请求参数
     * @return 分页结果
     */
    @Override
    public PageResult search(RequestParams requestParams) {
        try {
            // 1. 准备SearchRequest，指定索引名为"hotel"
            SearchRequest request = new SearchRequest("hotel");

            // 2. 构建基本查询条件
            buildBasicQuery(requestParams, request);

            // 3. 设置分页参数
            int page = requestParams.getPage();
            int size = requestParams.getSize();
            request.source().from((page-1)*size).size(size);

            // 4. 地理位置排序（如果提供了位置参数）
            String location = requestParams.getLocation();
            if(location != null && !"".equals(location)){
                request.source().sort(SortBuilders.geoDistanceSort("location", new GeoPoint(location))
                        .order(SortOrder.ASC)  // 按距离升序排序
                        .unit(DistanceUnit.KILOMETERS));  // 距离单位为公里
            }

            // 5. 执行搜索请求
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            
            // 6. 处理搜索结果并返回
            return handleResponse(response);
        } catch (IOException e) {
            throw new RuntimeException("搜索酒店失败", e);
        }
    }

    /**
     * 构建基本查询条件
     * @param requestParams 请求参数
     * @param request SearchRequest对象
     */
    private void buildBasicQuery(RequestParams requestParams, SearchRequest request) {
        // 1. 创建布尔查询构建器
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

        // 2. 关键字查询
        String key = requestParams.getKey();
        if (key == null || key.equals("")){
            // 如果关键字为空，则匹配所有文档
            boolQueryBuilder.must(QueryBuilders.matchAllQuery());
        } else {
            // 否则在"all"字段中搜索关键字
            boolQueryBuilder.must(QueryBuilders.matchQuery("all", key));
        }

        // 3. 城市过滤条件
        if (requestParams.getCity() != null && !requestParams.getCity().equals("")){
            boolQueryBuilder.filter(QueryBuilders.termQuery("city", requestParams.getCity()));
        }

        // 4. 品牌过滤条件
        if (requestParams.getBrand() != null && !requestParams.getBrand().equals("")){
            boolQueryBuilder.filter(QueryBuilders.termQuery("brand", requestParams.getBrand()));
        }

        // 5. 星级过滤条件
        if (requestParams.getStarName() != null && !requestParams.getStarName().equals("")){
            boolQueryBuilder.filter(QueryBuilders.termQuery("starName", requestParams.getStarName()));
        }

        // 6. 价格范围过滤
        if (requestParams.getMaxPrice() != null && requestParams.getMinPrice() != null){
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price")
                    .gte(requestParams.getMinPrice())  // 大于等于最小值
                    .lte(requestParams.getMaxPrice())); // 小于等于最大值
        }

        // 7. 构建函数评分查询（广告置顶功能）
        FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery(
                boolQueryBuilder,
                new FunctionScoreQueryBuilder.FilterFunctionBuilder[]{
                        new FunctionScoreQueryBuilder.FilterFunctionBuilder(
                                QueryBuilders.termQuery("isAd", true),  // 广告标识字段
                                ScoreFunctionBuilders.weightFactorFunction(10)  // 权重因子为10
                        )
                }
        );
        
        // 8. 将查询设置到请求中
        request.source().query(functionScoreQueryBuilder);
    }

    /**
     * 处理搜索响应结果
     * @param response Elasticsearch的搜索响应
     * @return 分页结果对象
     */
    public PageResult handleResponse(SearchResponse response) {
        PageResult pageResult = new PageResult();
        
        // 1. 获取命中结果
        SearchHits searchHits = response.getHits();
        
        // 2. 设置总命中数
        long total = searchHits.getTotalHits().value;
        pageResult.setTotal(total);
        
        // 3. 处理每条命中记录
        SearchHit[] hits = searchHits.getHits();
        List<HotelDoc> hotelDocList = new ArrayList<>();
        
        for (SearchHit hit : hits) {
            // 3.1 将JSON格式的源数据转换为HotelDoc对象
            String json = hit.getSourceAsString();
            HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
            
            // 3.2 处理距离排序值（如果有）
            Object[] sortValues = hit.getSortValues();
            if (sortValues != null && sortValues.length > 0) {
                Object sortValue = sortValues[0];
                hotelDoc.setDistance(sortValue);
            }
            
            // 3.3 处理高亮字段（如果有）
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if (!CollectionUtils.isEmpty(highlightFields)) {
                HighlightField highlightField = highlightFields.get("name");
                if (highlightField != null) {
                    // 获取高亮后的名称
                    String name = highlightField.getFragments()[0].string();
                    hotelDoc.setName(name);
                }
            }
            
            // 3.4 将处理后的酒店文档添加到列表
            hotelDocList.add(hotelDoc);
        }
        
        // 4. 设置结果列表并返回
        pageResult.setHotels(hotelDocList);
        return pageResult;
    }
}
```