# 1，jvm进程缓存



传统缓存的问题

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

多级缓存方案

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

多级缓存

# 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
```
启动集群

```shell
# 第1个
redis-server 7001/redis.conf
# 第2个
redis-server 7002/redis.conf
# 第3个
redis-server 7003/redis.conf
```
从节点连接主节点

```shell
slaveof 192.168.42.10 7001

```
执行命令临时的主从关系

![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哨兵

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

服务器状态监控

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

流程

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

搭建哨兵集群

创建s1 s2 s3 并添加sentinel.conf文件

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

```config
# 端口
port 27001
sentinel announce-ip 192.168.42.10
# 声明集群 2 是超过 2各判断master下线
sentinel monitor mymaster 192.168.42.10 7001 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
# 工作目录
dir "/tmp/s1"

```

启动redis的sentinel

```shell
redis-sentinel ./s2/sentinel.conf 
```

RedisTemplate哨兵模式

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

读写分离

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

# 5.Redis分片集群

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

搭建分片集群

创建目录存放redis.conf的配置文件

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

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

一键启动

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

关闭命令

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

创建集群

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

查看集群状态

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

散列插槽（判断key在哪一个插槽上）

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

控制同类数据放在同一节点

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

集群伸缩

添加节点进入集群

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

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)