Redis多级缓存搭建（结合案例学习）

左手的ㄟ右手 2024-03-24 16:56 55阅读 0赞

#### 文章目录 ####

*  一. JVM进程缓存
 *   *  1. 在docker中安装Mysql服务
     *  2. 向数据库中导入数据和导入案例代码
     *  3. 在dokcer中部署nginx服务器实现方向代理
     *  4. 在nginx目录下导入主页面
     *  5. 配置nginx实现反向代理
     *  6. 初步认识Caffine
     *  7. 使用Caffeine实现本地进程缓存
     *  8. 总结
 *  二. LUA语法
 *   *  1. 初识Lua
     *  2. 基本语法
 *  三. 实现多级缓存
 *   *  1. 安装OpenResty（也可以使用Docker部署）
     *  2. OpenResty快速入门
     *  3. 请求参数处理
     *  4. 查询Tomcat
     *  5. Tomcat集群搭建
     *  6. Redis缓存预热
     *  7. 查询Redis缓存
     *  8. Nginx本地缓存
 *  四. 缓存同步策略
 *   *  1. 数据同步策略
     *  2. 安装Canal
     *  3. 监听Canal

传统的缓存测量一般是请求到达Tomcat后，先查询Redis，如果未命中则查数据库，存在以下问题：

*  请求要经过Tomcat处理，Tomcat的性能成为整个系统的瓶颈
 *  Redis缓存失效时，会对数据库产生冲击  
    而多级缓存就是充分利用请求处理每个环节，分别添加缓存，减轻Tomcat压力，提升服务性能  
    ![在这里插入图片描述][5cb2ba8372e547e198212e975dfbb413.png]

## 一. JVM进程缓存 ##

这部分主要实现Tomcat进程缓存，**下面借助案例来实现JVM进程缓存**

### 1. 在docker中安装Mysql服务 ###

1.  docker容器中搭建Mysql服务  
    **下载Mysql镜像**

docker pull mysql:8.0.32

**创建Mysql相关的文件夹**

# 进入/tmp目录
    cd /tmp
    # 创建文件夹
    mkdir mysql
    # 进入mysql目录
    cd mysql

**在docker中启动mysql镜像**

docker run \
     -p 3306:3306 \
     --name mysql \
     -v mysql-conf:/etc/mysql/conf.d \
     -v mysql-logs:/logs \
     -v mysql-data:/var/lib/mysql \
     -e MYSQL_ROOT_PASSWORD=123456 \
     --privileged \
     -d \
     mysql:8.0.32

**在/tmp/mysql/conf目录添加一个my.cnf文件，作为mysql的配置文件：**

# 创建文件
    touch /tmp/mysql/conf/my.cnf

**文件的内容如下：**

[mysqld]
    skip-name-resolve
    character_set_server=utf8
    datadir=/var/lib/mysql
    server-id=1000

**重启Mysql镜像**

docker restart mysql#mysql是你自己命名的镜像名称

**使用navicat连接mysql服务**  
![在这里插入图片描述][6768ee81ded042d499b3c900e1b3a1c7.png]

### 2. 向数据库中导入数据和导入案例代码 ###

**在数据库中新建一个库，并导入sql文件**  
[sql文件网盘通道][sql]，提取码: grr6  
![成功导入][0016c1fd8f6c48fcb5973813fae3fd9d.png]  
**导入工程**  
[工程文件网盘通道][Link 1]，提取码: yhk5

> 记得修改项目中的数据库配置，以及mysql依赖的版本

![在这里插入图片描述][510c66ea0ce6451cbb119daf9d092204.png]

### 3. 在dokcer中部署nginx服务器实现方向代理 ###

#创建挂载文件的目录
    mkdir docker-nginx
    #初步运行doker（主要是为了拷贝要挂载的页面）
    docker run --name nginx -p 8089:80 -d nginx:stable-alpine-perl
    #拷贝配置文件
     docker cp nginx:/etc/nginx/nginx.conf $PWD/docker-nginx/
     docker cp nginx:/etc/nginx/conf.d/ $PWD/docker-nginx/conf/
     docker cp nginx:/usr/share/nginx/html/ $PWD/docker-nginx/html/
     docker cp nginx:/usr/share/nginx/html/ PWD/docker-nginx/html/
    #删除目前运行的nginx
     docker stop nginx
      docker rm nginx 
     #以挂载的方式启动
     docker run -p 8089:80 -v $PWD/nginx.conf:/etc/nginx/nginx.conf -v $PWD/logs:/var/log/nginx -v $PWD/html:/usr/share/nginx/html -v $PWD/conf:/etc/nginx/conf.d --privileged=true --name nginx -d nginx:stable-alpine-perl

部署成功  
![在这里插入图片描述][dee369e2a5fc4738b1994545d9742f9e.png]

### 4. 在nginx目录下导入主页面 ###

[主页面文件通道][Link 2]: 提取码: b2ei

> 将下载的html文件替换原来的html文件即可

![在这里插入图片描述][c8d965891ead4732997ac2e560d4f80c.png]

### 5. 配置nginx实现反向代理 ###

user  nginx;
    worker_processes  auto;
    
    error_log  /var/log/nginx/error.log notice;
    pid        /var/run/nginx.pid;
    
    
    events {
        
        worker_connections  1024;
    }
    
    
    http {
        
        include       /etc/nginx/mime.types;
        default_type  application/octet-stream;
    
        log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                          '$status $body_bytes_sent "$http_referer" '
                          '"$http_user_agent" "$http_x_forwarded_for"';
    
        access_log  /var/log/nginx/access.log  main;
    
        sendfile        on;
        #tcp_nopush     on;
    
        keepalive_timeout  65;
         upstream nginx-cluster{
        
            server 172.16.23.152:8090;   //
        }
        server {
        
            listen       80;
            server_name  172.16.23.152;
    
    	location /api {
        
                proxy_pass http://nginx-cluster;
            }
    
            location / {
        
                root   html;
                index  index.html index.htm;
            }
    
            error_page   500 502 503 504  /50x.html;
            location = /50x.html {
        
                root   html;
            }
        }
        #gzip  on;
    
        include /etc/nginx/conf.d/*.conf;
    }

### 6. 初步认识Caffine ###

**简介**：Caffeine是一个Java本地缓存库，可用于缓存对象以提高应用程序性能。它提供了一种简单的API，可以轻松地在应用程序中集成缓存功能，下面介绍基本使用语法

*  创建缓存实例

Cache<Key, Value> cache = Caffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .build();
    //此代码创建了一个缓存，它最多可以缓存100个对象，并在写入后10分钟后过期
    //在默认情况下，当一个缓存元素过期时候，Caffeine不会立即将其清理和驱逐。而是在一次读写操作后，或者在空闲时间完成对失效数据的驱逐（这样就不会占用CPU资源）

*  向缓存中添加对象

cache.put(key, value);
    //此代码将一个键值对添加到缓存中

*  从缓存中获取对象

Value value = cache.getIfPresent(key);
    //此代码从缓存中获取一个键对应的值，如果缓存中不存在该键，则返回null

*  清除缓存

cache.invalidate(key);
    //此代码从缓存中清除指定的键及其对应的值

*  缓存统计

CacheStats stats = cache.stats();
    //此代码获取缓存的统计信息，例如缓存的命中率、加载时间、写入时间等

这些是Caffeine的基本用法。可以使用更高级的功能，例如缓存的回收策略、加载器和缓存监听器，以实现更复杂的缓存需求  
**案例**：使用之前导入的item-service来操作缓存库

@Test
        void testBasicOps() {
        
            // 创建缓存对象
            Cache<String, String> cache = Caffeine.newBuilder().build();
    
            // 存数据
            cache.put("gf", "迪丽热巴");
    
            // 取数据，不存在则返回null
            String gf = cache.getIfPresent("gf");
            System.out.println("gf = " + gf);
    
            // 取数据，不存在则去数据库查询
            String defaultGF = cache.get("defaultGF", key -> {
        
                // 这里可以去数据库根据 key查询value
                return "柳岩";
            });
            System.out.println("defaultGF = " + defaultGF);
        }

![在这里插入图片描述][b6364df4376643b0b538b42566164429.png]

/*
         基于大小设置驱逐策略：
         */
        @Test
        void testEvictByNum() throws InterruptedException {
        
            // 创建缓存对象
            Cache<String, String> cache = Caffeine.newBuilder()
                    // 设置缓存大小上限为 1
                    .maximumSize(1)
                    .build();
            // 存数据
            cache.put("gf1", "柳岩");
            cache.put("gf2", "范冰冰");
            cache.put("gf3", "迪丽热巴");
            // 延迟10ms，给清理线程一点时间
            Thread.sleep(10L);
            // 获取数据
            System.out.println("gf1: " + cache.getIfPresent("gf1"));
            System.out.println("gf2: " + cache.getIfPresent("gf2"));
            System.out.println("gf3: " + cache.getIfPresent("gf3"));
        }
    
        /*
         基于时间设置驱逐策略：
         */
        @Test
        void testEvictByTime() throws InterruptedException {
        
            // 创建缓存对象
            Cache<String, String> cache = Caffeine.newBuilder()
                    .expireAfterWrite(Duration.ofSeconds(1)) // 设置缓存有效期为 10 秒
                    .build();
            // 存数据
            cache.put("gf", "柳岩");
            // 获取数据
            System.out.println("gf: " + cache.getIfPresent("gf"));
            // 休眠一会儿
            Thread.sleep(1200L);
            System.out.println("gf: " + cache.getIfPresent("gf"));
        }

![在这里插入图片描述][91b3cd68f055461eaf591776de9654b2.png]  
![在这里插入图片描述][319e87d10ea54aefabbc26bf1cc7e735.png]

### 7. 使用Caffeine实现本地进程缓存 ###

**案例需求**  
给根据id查询商品的业务添加缓存，缓存未命中时查询数据库

*  将[Caffeine][]以Bean的形式注入到Spring容器中

@Configuration
    public class CaffeineConfig {
        
        @Bean
        public Cache<Long , Item> itemCache(){
          //商品缓存
            Cache<Long, Item> cache = Caffeine.newBuilder()
                    .initialCapacity(100)
                    .maximumSize(10_000)
                    .build();
            return cache;
        }
        @Bean
        public Cache<Long , ItemStock> stockCache(){
          //库存缓存
            Cache<Long, ItemStock> cache = Caffeine.newBuilder()
                    .initialCapacity(100)
                    .maximumSize(10_000)
                    .build();
            return cache;
        }
    }

*  实现业务

@GetMapping("/{id}")
        public Item findById(@PathVariable("id") Long id){
        
            return  itemCache.get(id,key-> itemService.query()
                    .ne("status", 3).eq("id", id)
                    .one());
        }
    
        @GetMapping("/stock/{id}")
        public ItemStock findStockById(@PathVariable("id") Long id){
        
            
            return stockCache.get(id,key->stockService.getById(id));
        }

*  测试  
    **第一次访问http://localhost:8081/item/10001，会查数据库**  
    ![在这里插入图片描述][988c813922464e09843c653856611dfc.png]  
    **第二次访问直接查询Caffeine缓存，不会查询数据库**  
    ![在这里插入图片描述][dda8187ad6404cd4956fff4146499901.png]

### 8. 总结 ###

至此我们就实现了多级缓存中的Nginx部分的搭建，以及进程缓存的搭建两部分，下面继续实现其它缓存部分  
![在这里插入图片描述][5cb2ba8372e547e198212e975dfbb413.png]

## 二. LUA语法 ##

在实现Nginx本地缓存时，需要结合Nginx+Lua来实现缓存

### 1. 初识Lua ###

[Lua][]是一个轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放，其设计目的是为了嵌入到应用程序中，从而为应用程序提供灵活的扩展和定制功能  
**快速入门**(centos已经默认继承了lua，不需要安装）

1.  在Linux虚拟机的任意目录下，新建一个hello.lua文件

touch hello.lua

1.  添加下面内容

print("hello world")

1.  运行lua脚本

lua hello.lua

![在这里插入图片描述][f22f198282a9425fbc2a44e3e98ca89c.png]

### 2. 基本语法 ###

*  数据类型

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>nil</td> 
   <td>这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>包含两个值：false和true</td> 
  </tr> 
  <tr> 
   <td>number</td> 
   <td>表示双精度类型的浮点数</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>字符串由一对双引号和单引号表示</td> 
  </tr> 
  <tr> 
   <td>function</td> 
   <td>由c或lua编写的函数</td> 
  </tr> 
  <tr> 
   <td>table</td> 
   <td>Lua中的表（table）其实是一个关联数组，数组的索引可以是数字、字符串或表类型，在Lua中，table的创建是通过“构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表（可以理解为java中的map）</td> 
  </tr> 
 </tbody> 
</table>

`可以利用type函数测试给定变量的类型`  
![在这里插入图片描述][180085ef1e424587b75b43d6e67f5e19.png]

*  变量  
    Lua声明变量的时候，不需要指定数据类型

--声明字符串
    local str="jack"
    --声明数字
    local num=21
    --声明bool类型
    local flag=true
    -- 声明数组key为索引的table
    local arr={
        'java','python','lua'}
    --声明table，类似于java的map
    local map={
        name='Jack',age=21}
    --访问数组，lua数组的脚标从1开始
    print(arr[1])
    --访问table
    print(map['name'])
    print(map.name)

*  循环  
    数组、table都可以利用for循环来遍历

--声明数组key未索引的table
    local arr={
        'java','python','lua'}
    --便利数组
    for index,value in ipairs(arr) do
    	print(index,value)
    end

![在这里插入图片描述][1a47eaed7a6f45fca79fc1594968af3c.png]

--声明map
    local map={
        name='jack',age=21}
    for key,value in pairs(map) do
        print(key,value)
    end

*  函数  
    定义函数的语法

local function 函数名(argument1,argument2...,argument)
      --函数体
      return 返回值
    end

条件控制语法：类似java的条件控制，例如if、else语法：

if(布尔表达式)
     then
     --[布尔表达式为true时执行该语句块]
     else
     --[布尔表达式为false执行的语句块]
    end

与java不同，布尔表达式中的逻辑运行是基于英文单词的

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>逻辑与运算，若A为false，则返回A，否则返回B</td> 
   <td>(A and B) 为false</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>逻辑或运算。若A为true，则返回A，否则返回B</td> 
   <td>(A or B)为true</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>逻辑非操作符。与逻辑运算结果相反，如果条件为true，逻辑非为false</td> 
   <td>not (A and B)为true</td> 
  </tr> 
 </tbody> 
</table>

测试控制语法：自定义一个函数，当参数为nil，打印错误消息

local function test(a)
      if(not a)
        then
        print("Array can not be null!")
        return nil;
      end
      print(a)
    end
    
    test(nil)
    test("nihao")

![在这里插入图片描述][2b3d87d3ef4e4216ba896f66425b5ca7.png]

## 三. 实现多级缓存 ##

### 1. 安装OpenResty（也可以使用Docker部署） ###

[OpenResty][]是一基于Nginx的高性能Web平台（用于Nginx定制），用于方便地搭建能够处理超高并发、扩展性极高的动态Web应用、Web服务和动态网关，具备以下特点：

*  具备Nginx的完整功能
 *  基于Lua语言进行扩展，集成了大量精良的Lua库、第三方模块
 *  运行使用Lua自定义业务逻辑、自定义库

**下面安装OpenResty**

*  首先要安装OpenResty的依赖开发库，执行命令：

yum install -y pcre-devel openssl-devel gcc --skip-broken

*  安装OpenResty仓库（插件库）:你可以在你的 CentOS 系统中添加 `openresty` 仓库，这样就可以便于未来安装或更新我们的软件包（通过 `yum check-update` 命令）。运行下面的命令就可以添加我们的仓库：

yum-config-manager --add-repo https://openresty.org/package/centos/openresty.repo

如果提示说命令不存在，则运行：

yum install -y yum-utils

然后再重复上面的命令

*  安装OpenResty

yum install -y openresty

*  安装opm工具:opm是OpenResty的一个管理工具，可以帮助我们安装一个第三方的Lua模块。如果你想安装命令行工具 `opm`，那么可以像下面这样安装 `openresty-opm` 包

yum install -y openresty-opm

*  目录结构：默认情况下，OpenResty安装的目录是：/usr/local/openresty  
    ![在这里插入图片描述][491faece32fa426492a4f765f46fbfd2.png]
 *  配置Nginx的运行环境

#打开配置文件
    vim /etc/profile
    #加入内容
    export NGINX_HOME=/usr/local/openresty/nginx
    export PATH=${NGINX_HOME}/sbin:$PATH
    #让配置生效
    source /etc/profile

*  启动与运行  
    OpenResty底层是基于Nginx的，查看OpenResty目录的nginx目录，可以看到结构和我们直接下载的nginx的基本一致，所以运行方式也是和之前的类似

#启动nginx
    nginx
    #重新加载配置
    nginx -s reload
    #停止
    nginx -s stop

![在这里插入图片描述][7ae02050b0c94312b804058e4146c1a2.png]

### 2. OpenResty快速入门 ###

**案例**：OpenResty快速入门，实现商品详情页数据查询。

*  在nginx.conf的http模块下面，添加对OpenResty的Lua模块的价值：

#加载lua模块
    lua_package_path "/usr/local/openresty/lualib/?.lua;;"
    #加载c模块
    lua_package_cpath "/usr/local/openresty/lualib/?.so;;"

*  在nginx.conf的server下面，添加对/api/item这个路径的监听

location /api/item {
        
    #响应类型，这里返回json
    default_type application/json
    #响应数据由lua/item.lua这个文件来决定
    content_by_lua_file lua/item.lua
    }

![在这里插入图片描述][fc4b9f5211054d31a897b53e30d5068a.png]

### 3. 请求参数处理 ###

OpenResty提供了各种API用来获取不同类型的请求参数  
![在这里插入图片描述][2dc1be6c75d243edb06ced6edc1f72b3.png]  
**下面使用路径占位符的方式来实现商品信息的获取**  
(1) 以正则表达式的方式编写location

location ~ /api/item/(\d+){
        
    	      #响应类型，这里返回json
    		default_type application/json;
    	    	#响应数据由lua/item.lua这个文件来决定
    		content_by_lua_file lua/item.lua;
    	   }

(2) 编写lua脚本

-- 获取路径参数
    local id=ngx.var[1]
    -- 返回假数据，这里的ngx.say()函数，就是写数据到Response中
    ngx.say('{"id":'.. id ..',"name":"SALSA AIR","title":"jackiechai","price":13234,"image":"https://m.360buyimg.com/mobilecms/s720x720_jfs/t6934/364/1195375010/84676/e9f2c55f/597ece38N0ddcbc77.jpg!q70.jpg.webp"}')

![在这里插入图片描述][ae3800778335456bafd713d1693bf3cb.png]

### 4. 查询Tomcat ###

前面已经获取了用户的请求参数，现在就可以利用用户的请求参数来实现查询tomcat的缓存了  
![在这里插入图片描述][149c231765b849628adb68f3b760cab9.png]  
**案例**：获取请求路径中的商品id信息，根据id向Tomcat查询商品信息  
ngixn提供了内部API用以发送http请求：

local resp=ngx.location.capture("/path".{
        
       method=ngx.HTTP_GET,  #请求方式
       args={
        a=1,b=2}, #get方式传参
       body="c=3&d=3" #post方式传参
    })

返回的响应内容包括：

*  resp.status：响应状态码
 *  resp.header：响应头，是一个table
 *  resp.body：响应体，就是响应数据  
    \`注意：这里的path是路径，并不包含ip和端口。这个请求会被nginx内部的server监听并处理。然后我们利用nginx的反向代理功能，就可以将请求代理到tomcat服务器

location /item{
        
    	      proxy_pass http:// 172.16.23.1:8081;
    }

**封装http查询的函数**  
我们可以把http查询的请求封装为一个函数，放到OpenResty函数库中，方便后期使用：

vi /usr/local/openresty/lualib/common.lua

--封装函数，发送http请求，并解析响应
    local function read_http(path,params)
      local resp=ngx.location.capture(path,{
        
          method=ngx.HTTP_GET,
          args=params
      })
      if not resp then
          --记录错误信息返回404
          ngx.log(ngx.ERR,"http not found,path",path,",args:",args)
          ngx.exit(404)
       end
       return resp.body
    --将方法导出
    local _M={
        
      read_http=read_http
    }
    return _M

**重新编写item.lua调用前面我们封装的函数**

--导入common函数库
    local common=require('common')
    local read_http=common.read_http
    --导入cjson库
    local cjson=require('cjson')
    -- 获取路径参数
    local id=ngx.var[1]
    --查询商品信息
    local itemJson=read_http("/item/".. id,nil)
    --查询库存信息
    local stockJson=read_http("/item/stock/"..id,nil)
    -- JSON转化为lua的table
    local item=cjson.decode(itemJson)
    local stock=cjson.decode(stockJson)
    --组合数据
    item.stock=stock.stock
    item.sold=stock.sold
    --返回结果
    ngx.say(cjson.encode(item))

OpenResty提供了一个[cjson][]的模块用来处理JSON的序列化和反序列化

*  引入cjson模块

local cjson=require "cjson"

*  序列化

local obj={
        
       name='jack',
       age=21
    }
    local json=cjson.encode(obj)

*  反序列化：

local json='{"name":"jack","age":21}'
    --反序列化
    local obj=cjson.decode(json);
    print(obj.name)

**显示结果**  
![在这里插入图片描述][7470e1ff5da240baad3566e909ebee15.png]

### 5. Tomcat集群搭建 ###

实际开发中我们同样会实现Tomcat的负载均衡，但是Tomcat实现负载均衡会出现一个问题，就是Tomcat的进程是无法进行共享的，所以我们的目的是，在实现Tomcat负载均衡的同时，让同一个ip地址永远指向一台Tomcat，这样就可以解决进程缓存无法共享的问题。  
**修改nginx.conf配置**

upstream tomcat-cluster {
        
            hash $request_uri;   #采用hash算法
            server 172.16.23.1:8081;
            server 172.16.23.1:8082;
          }
        server {
        
            listen       8090;
            server_name  172.16.23.152;
            location / {
        
                root   html;
                index  index.html index.htm;
            }
            error_page   500 502 503 504  /50x.html;
            location = /50x.html {
        
                root   html;
            }
            location ~ /api/item/(\d+){
        
    	      #响应类型，这里返回json
    		default_type application/json;
    	    	#响应数据由lua/item.lua这个文件来决定
    		content_by_lua_file lua/item.lua;
    	   }
    	   location /item{
        
    	      proxy_pass http://tomcat-cluster;
    	   }

`上面方法就实现了Tomcat集群的负载均衡`

### 6. Redis缓存预热 ###

上面实现了OpenResty向Tomcat发送Http请求，访问进程缓存，现在我们要加入Redis缓存  
![在这里插入图片描述][6d7bbb23aa6e427d9be17c80c40b1a9a.png]  
但现在存在问题：冷启动问题  
**冷启动**：服务刚刚启动时，Redis中并没有缓存，如果所有的数据都在第一次查询时添加缓存，可能给数据库带来很大的压力  
**缓存预热**：在实际开发中，我们可以利用大数据统计用户访问的热点数据，在项目启动时将这些热点数据提前查询并保存到redis中  
**案例**：实现缓存预热

1.  利用Docker安装Redis

docker pull redis:alpine3.17 #拉取镜像

docker run --name redis -p 6380:6379 -d redis:alpine3.17 redis-server --appendonly yes --requirepass 123321

在本地客户端成功连接到redis服务  
![在这里插入图片描述][44b84ba3ef5f439bad1d7aaeeeee0b82.png]  
2. 在item-service中引入redis依赖

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
     </dependency>

1.  配置Redis地址

spring:
      redis:
        host: 172.16.23.152
        port: 6380
        password: 123321

1.  编写初始化Redis的类

@Component
    public class RedisHandler implements InitializingBean {
        
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
        @Autowired
        private ItemService itemService;
        @Autowired
        private ItemStockService itemStockService;
     
        private static final ObjectMapper MAPPER=new ObjectMapper();
        @Override
        public void afterPropertiesSet() throws Exception {
        
              //初始化缓冲
            //1.查询商品信息
            List<Item> items = itemService.list();
            for (Item item : items) {
        
                //2.1 Item序列化为json对象
                String json = MAPPER.writeValueAsString(item);//把一个实例对象转换为json对象
                //2. 放入redis缓冲
                stringRedisTemplate.opsForValue().set("item:id"+item.getId(),json);
            }
            //3. 查询库存信息
            List<ItemStock> itemstock = itemStockService.list();
            for (ItemStock itemStock : itemstock) {
        
                String json = MAPPER.writeValueAsString(itemStock);
                //4. 放入redis缓冲
                stringRedisTemplate.opsForValue().set("itemstock:id"+itemStock.getId(),json);
            }
        }
    }

> `InitializingBean`：实现该接口必须实现`afterPropertiesSet`方法，该方法会在属性注入完成后执行

**预热功能实现**  
![在这里插入图片描述][955221440d204c2e93ab85fb9af78c4a.png]

### 7. 查询Redis缓存 ###

上面已经实现了Redis的缓冲预热功能，下面要实现OpenResty先查询Redis，未命中再查tomcat。OpeanResty提供了操作Redis的模块，我们只需引入该模块就可以操作redis了

*  引入Redis模块，并初始化Redis对象

--引入Redis模块
    local redis=require("resty.redis")
    --初始化Redis对象
    local red=redis:new()
    -- 设置Redis超时时间(建立连接的超时时间，发送请求的超时时间，响应结果的超时时间）
    red:set_timeouts(1000,1000,1000)

*  封装函数，用来释放Redis连接

--关闭redis连接的工具方法，其实就是将连接放入连接池
    local function close_redis(red)
       local pool_max_idle_time=10000 --连接的空闲时间，单位是毫秒
       local pool_size=100 --连接池大小
       local ok,err=red:set_keepalive(pool_max_idle_time,pool_size)
       if not ok then
          ngx.log(ngx.ERR,"放入redis连接失败:",err)
       end
    end

*  封装函数，从Redis读数据并返回

-- 查询redis的方法，ip和port是redis的地址，key是查询的key
    local function read_redis(ip,port,key)
       --获取一个连接
       local ok,err=red:connect(ip,port)
       if not ok then
          ngx.log(ngx.ERR,"连接redis失败：",err)
       end
       --查询redis
       local resp,err=red:get(key)
       --查询失败处理
       if not resp then
          ngx.log(ngx.ERR,"查询Redis失败:",err,"key=",key)
       end
       --得到的数据为空处理
       if resp==ngx.null then
          resp=nil;
          ngx.log(ngx.ERR,"查询Redis数据为空,key=",key)
       end
       close_redis(red)
       return resp
    end

1.  编写Common.lua脚本

--导入redis
    local redis=require('resty.redis')
    --初始化redis
    local red=redis:new()
    --设置redis超时时间
    red:set_timeouts(1000,1000,1000)
    --释放连接函数
    local function close_redis(red)
       local pool_max_idle_time=10000 --连接的空闲时间，单位是毫秒
       local pool_size=100 --连接池大小
       local ok,err=red:set_keepalive(pool_max_idle_time,pool_size)
       if not ok then
          ngx.log(ngx.ERR,"放入redis连接失败:",err)
       end
    end
    --访问数据函数
    local function read_redis(ip,port,key)
       --获取一个连接
       local ok, err = red:connect(ip, port)
       ok, err = red:auth("123321")
       if not ok then
          ngx.log(ngx.ERR,"连接redis失败：",err)
          return nil
       end
       --查询redis
       local resp,err=red:get(key)
       --查询失败处理
       if not resp then
          ngx.log(ngx.ERR,"查询Redis失败:",err,"key=",key)
       end
       --得到的数据为空处理
       if resp==ngx.null then
          resp=nil;
          ngx.log(ngx.ERR,"查询Redis数据为空,key=",key)
       end
       close_redis(red)
       return resp
    end
    -- 封装函数，发送http请求，并解析响应
    local function read_http(path, params)
        local resp = ngx.location.capture(path,{
        
            method = ngx.HTTP_GET,
            args = params,
        })
        if not resp then
            -- 记录错误信息，返回404
            ngx.log(ngx.ERR, "http not found, path: ", path , ", args: ", args)
            ngx.exit(404)
        end
        return resp.body
    end
    -- 将方法导出
    local _M = {
          
        read_http = read_http
        read_redis = read_redis
    }  
    return _M

1.  编写item脚本

--导入common函数库
    local common=require('common')
    local read_http=common.read_http
    local read_redis=common.read_redis
    --导入cjson库
    local cjson=require('cjson')
    -- 获取路径参数
    local id=ngx.var[1]
    --封装函数，先查询redis，再查下http
    local function read_data(key,path,params)
       --查询redis
       local resp =read_redis(ngx.ERR,"172.16.23.152",6380,key)
       --判断redis是否命中
       if not resp then
          --redis查询失败，查询http
          resp=read_http(path,params)
       end
       return resp
    end
    --获取路径参数
    local id=ngx.var[1]
    --查询商品信息
    local itemJson=read_data("item:id:" .. id,"/item/" .. id,nil)
    --查询库存信息
    local stockJson=read_data("itemstock:id:" .. id,"/item/stock/" .. id,nil)
    -- JSON转化为lua的table
    local item=cjson.decode(itemJson)
    local stock=cjson.decode(stockJson)
    --组合数据
    item.stock=stock.stock
    item.sold=stock.sold
    --返回结果
    ngx.say(cjson.encode(item))

**测试关闭tomcat再访问主页，这里我查询商品id为10002**  
![在这里插入图片描述][b921ebe577bb4a8ba3cf0d6195989098.png]

### 8. Nginx本地缓存 ###

> 前面已经实现了redis缓冲、Tomcat缓冲，现在多级缓存中只差在OpenResty添加Nginx本地缓存了

OpenResty为Nginx提供了shard dict功能，可以在Nginx的多个Worker之间共享数据，实现缓存功能

*  开启共享字典，在nginx.conf的http下添加配置：

#共享字典，也就是本地缓存，名称叫做：item_cahce大小为150m
    lua_shared_dict item_cache 150m;

![在这里插入图片描述][8299acd8d2ce446684076d6f235a5233.png]

*  操作共享字典

-- 获取本地缓存对象
    local item_cache=ngx.shared.item_cache
    -- 存储，指定key、value、过期时间，单位s，默认为0代表永不过期
    item_cache:set('key','value',1000)
    -- 读取
    local val=item_cache:get('key')

**案例**：实现查询商品时，优先查询OpenResty的本地缓存

1.  修改item.lua的read\_data函数，优先查询本地缓存，未命中时再查询Redis、Tomcat

--导入common函数库
    local common=require('common')
    local read_http=common.read_http
    local read_redis=common.read_redis
    --导入cjson库
    local cjson=require('cjson')
    -- 导入共享词典，本地缓存
    local item_cache=ngx.shared.item_cache
    --封装函数，先查询redis，再查下http
    local function read_data(key,expire,path,params)
       --查询Nginx本地缓存
       local val=item_cache:get(key)
       if not val then
            ngx.log(ngx.ERR,"本地缓存查询失败，尝试查询Rdis，key：",key)
    	   --查询redis
    	   val =read_redis("127.0.0.1",6380,key)
    	   --判断redis是否命中
    	   if not val then
    	      ngx.log(ngx.ERR,"redis查询失败，尝试查询http，key：",key)
    	      --redis查询失败，查询http
    	      val=read_http(path,params)
    	   end
       end
       --查询成功，把数据写入Nginx本地缓存
       item_cache:set(key,val,expire)
       return val
    end
    --获取路径参数
    local id=ngx.var[1]
    --查询商品信息
    local itemJson=read_data("item:id" .. id,1800,"/item/" .. id,nil)
    --查询库存信息
    local stockJson=read_data("itemstock:id" .. id,60,"/item/stock/" .. id,nil)
    -- JSON转化为lua的table
    local item=cjson.decode(itemJson)
    local stock=cjson.decode(stockJson)
    --组合数据
    item.stock=stock.stock
    item.sold=stock.sold
    --返回结果
    ngx.say(cjson.encode(item))

**测试**：重启nginx后，访问10004号商品，查看日志情况

tail -f logs/error.log
    #该命令将显示出日志文件的最后几行内容，如果有新的内容加入到日志文件，它还会立即显示出新加入的内容

![在这里插入图片描述][35fe2c59fae34e1baebc9e4dfeaf674d.png]

重新访问10004号商品，发现日志没有变化，说明数据确实访问了Nginx本地缓存  
![在这里插入图片描述][66f78377dd614149bc4788d4a0e0864b.png]  
`至此多级缓存搭建完毕`

## 四. 缓存同步策略 ##

> 前面完成了多级缓存的搭建，大大提高了数据查询的效率，但是多级缓存的加入也引起了一个很致命的一个问题，即缓冲一致性问题

### 1. 数据同步策略 ###

**缓冲同步的常见方式有三种**

*  **设置有效期**：给缓冲设置有效期，到期后自动删除。再次查询时更新
    
     *  优势：简单方便
     *  缺点：时效性差，缓冲过期之前可能还是存在数据不一致问题
     *  场景：更新频率较低，时效性要求低的业务
 *  **同步双写**：在修改数据库的同时，直接修改缓存
    
     *  优势：时效性强，缓存与数据库强一致
     *  缺点：有代码侵入，耦合性高
     *  场景：对一致性、时效性要求较高的缓冲数据
 *  **异步通知（例如消息队列）**：修改数据库时发送时间通知，相关服务监听到通知后修改缓存数据
    
     *  优势：低耦合，可以同时通知多个缓冲服务
     *  缺点：时效性一般，可能存在中间不一致状态
     *  场景：时效性要求一般，有多个服务需要同步

> 在上面说到的异步通知，中可以借助MQ实现，而今天我们将利用Canal来实现异步通知（比MQ时效性更强，因为它是直接监听Mysql，而不是通过发送消息，和接收消息）

![在这里插入图片描述][7990a825b2b64b3c98f587e9ad97cf65.png]

### 2. 安装Canal ###

**Canal**：[canal][]是阿里巴巴旗下的一款开源项目，基于java开发。基于数据库增量日志解析，提供增量数据订阅&消费。canal是基于Msql主从同步来实现的，Mysql主从同步的原理如下所示：  
![在这里插入图片描述][0a4aece7f814469984c115cf510f789a.png]

*  Mysql master将数据变更写入二进制日志（binary log），其中的记录的数据叫做binary log events
 *  Mysql slave将master的binary log events拷贝到它的中继日志(relay log)
 *  Mysql slave重放relay log中的事件，将数据变更反映它自己的数据  
    canal就是把自己伪装成了一个Mysql的一个Slave节点，从而监听master的binary log变化，再把得到的变化信息通知给Canal的客户端，进而完成对其它数据库的同步  
    ![在这里插入图片描述][71e3f082061042f6bcfd3ea56cc8de61.png]

**下面开始安装canal**

1.  开启Mysql主从  
    canal是基于Mysql的主从同步功能，因此必须先开启Mysql的主从功能才可以

*  开启binlog  
    打开mysql容器挂载的日志文件`my.cnf`，添加内容：

log-bin=mysql-bin
    binlog-do-db=cache

`log-bin=/home/jakiechai/mysqlinfo/mysql-bin`：设置binary log文件的存放地址和文件名，叫做mysql-bin  
`binlog-do-db=cache`：指定对哪个database记录binary log events  
![在这里插入图片描述][8969453a16654960b6069adee6908b55.png]

1.  设置用户权限  
    接下来添加一个仅用于数据同步的账户，处于安全考虑，这里仅提供对cache这个库的权限操作（创建的用户专门负责数据同步）

create user canal@'%' IDENTIFIED by 'canal';
    GRANT SELECT,REPLICATION SLAVE,REPLICATION CLIENT,SUPER ON *.* TO 'canal'@'%';
    FLUSH PRIVILEGES;

这个配置是在MySQL数据库中创建一个名为“canal”的用户，可以从任何主机使用“%”通配符进行访问，该用户被授予以下权限：  
`SELECT`：允许用户从任何数据库和表中进行SELECT查询操作。  
`REPLICATION SLAVE`：允许用户作为复制从属端从主库接收二进制日志，并复制到从库中。  
`REPLICATION CLIENT`：允许用户使用SHOW MASTER STATUS和SHOW SLAVE STATUS等命令查看复制状态信息。  
`SUPER`：允许用户执行一些需要超级权限才能执行的操作，例如设置全局变量、执行FLUSH HOSTS命令等。  
在MySQL中，用户是基于用户名和主机名进行授权的。上述配置中，“canal”是用户名，“%”表示可以从任何主机进行访问。最后的FLUSH PRIVILEGES命令是用于刷新MySQL的权限表，以使修改后的权限立即生效。  
![在这里插入图片描述][3bde249a5f254414aecc549c13ff9724.png]  
**测试是否成功**

show master status

![在这里插入图片描述][4c72e991a9e94a2babffd91265ef627b.png]  
`mysql的主从同步原理可以结合Redis的主从同步原理来理解`

1.  docker网络部署

*  创建一个网路，将mysql、Canal、MQ放到同一个网络中（这里我使用我之前创建的一个网络）

docker network create (网络名)

![在这里插入图片描述][2d8f9e984195490c8ac39bb9e12c91c1.png]

*  让mysql加入这个网络

docker network connect es-net mysql

1.  docker中安装Canal

*  拉取镜像

docker pull chinayin/canal:1.1.6

*  运行容器

docker run -p 11111:11111 --name canal -e canal.destinations=cache -e canal.instance.master.address=mysql:3306 -e canal.instance.dbUsername=canal -e canal.instance.dbPassword=canal -e canal.instance.connectionCharset=UTF-8 -e canal.instance.tsdb.enable=true -e canal.instance.gtidon=false -e canal.instance.filter.regex=cache\\..* --network es-net -d chinayin/canal:1.1.6
    ##更改canal用户密码
    USE MYSQL;
    SELECT USER,HOST,PLUGIN FROM USER;
    ALTER USER canal@'%' IDENTIFIED WITH mysql_native_password BY '123456';

`-p 11111:11111` ：这是canal的默认监听端口  
`-e canal.destinations=cache`：canal的实例名称  
`-e canal.instance.master.address=mysql:3306`：数据库地址和端口，由于canal和mysql是在同一个网络，所以直接用容器名替换  
`-e canal.instance.dbUsername=canal -e canal.instance.dbPassword=canal`：数据库名和密码（之前创建的）\`\`  
`-e canal.instance.gtidon=false -e canal.instance.filter.regex=cache\\..`：要检讨的表的名称  
**查看运行日志**

docker logs -f canal

**进入maysql容器**

docker exec -it mysql bash

\*\* 查看log-bin日志情况\*\*  
![在这里插入图片描述][b3bc04ebfb6943208db488c979609712.png]  
**查看canal启动日志情况**  
![在这里插入图片描述][942fdc99dbf14400888023c3b75dcb98.png]

### 3. 监听Canal ###

canal提供了各种语言的客户端，当Canal监听到binlog变化时，会通知Canal的客户端。这里使用第三方开源的[canal-starter][]，在SpringBoot中整合  
![在这里插入图片描述][b1dabaf25858416db34049ba187997bf.png]

*  引入依赖

<dependency>
                <groupId>top.javatool</groupId>
                <artifactId>canal-spring-boot-starter</artifactId>
                <version>1.2.1-RELEASE</version>
            </dependency>

*  编写配置

canal: 
       destination: cache
       server: 172.16.23.152：11111

*  编写监听器，监听Canal消息

[canal][canal 1]推送给canal-client的是被修改的这一行数据，而我们引入的canal-client则会帮我们把行数据封装到Item实体类中，这个过程需要知道数据库和实体之间的映射关系，要用到JPA的几个注解（不熟悉JPA可以看我[这篇文章][Link 3]）

@Data
    @TableName("tb_item")
    public class Item {
        
        @TableId(type = IdType.AUTO)
        @Id
        private Long id;//商品id
        private String name;//商品名称
        private String title;//商品标题
        private Long price;//价格（分）
        private String image;//商品图片
        private String category;//分类名称
        private String brand;//品牌名称
        private String spec;//规格
        private Integer status;//商品状态 1-正常，2-下架
        private Date createTime;//创建时间
        private Date updateTime;//更新时间
        @TableField(exist = false)
        @Transient
        private Integer stock;
        @TableField(exist = false)
        @Transient
        private Integer sold;
    }

[5cb2ba8372e547e198212e975dfbb413.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2c1380e176b54e7c93ccc70b54103401.png
[6768ee81ded042d499b3c900e1b3a1c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/ecaf131985134f10919c6e8e5863d038.png
[sql]: https://pan.baidu.com/s/1V0gqnhSC5b4puP7Jk_5KPA
[0016c1fd8f6c48fcb5973813fae3fd9d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d238e4af0c444adeb56ccc8853238ff9.png
[Link 1]: https://pan.baidu.com/s/1W4U0anW9F2DwRpFJy-zMOw
[510c66ea0ce6451cbb119daf9d092204.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/43dcd866a7e24edaa64b393e3a18666a.png
[dee369e2a5fc4738b1994545d9742f9e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/7ba4129f5eed44d19047458d34ad239c.png
[Link 2]: https://pan.baidu.com/s/1NOqsGT8N1cFcLg5r2XAuSw
[c8d965891ead4732997ac2e560d4f80c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/0de373c6b0984138ab1916e904e2f93b.png
[b6364df4376643b0b538b42566164429.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/28bdc0b9a0ae4a96b0e60e8bca7640c3.png
[91b3cd68f055461eaf591776de9654b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c64e591d628b440bb11ba94b9be65ab7.png
[319e87d10ea54aefabbc26bf1cc7e735.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5e7f33807329457c8d02f801b6b30d1d.png
[Caffeine]: https://github.com/ben-manes/caffeine
[988c813922464e09843c653856611dfc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2da98ecd6f5f415ca864c6819b220889.png
[dda8187ad6404cd4956fff4146499901.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d0d0499168654f3b9ea32e7afdb83b4e.png
[Lua]: https://www.lua.org/
[f22f198282a9425fbc2a44e3e98ca89c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/0baba11fc4c04056bafd1288dd57e17f.png
[180085ef1e424587b75b43d6e67f5e19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/7c35d6abc9494f1a80a65fecbb020524.png
[1a47eaed7a6f45fca79fc1594968af3c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e8e00ee52bb241cb8301f7e6850e8ec9.png
[2b3d87d3ef4e4216ba896f66425b5ca7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2aa6cb391cda4b2f8cf70b5b58d3c72f.png
[OpenResty]: https://openresty.org/cn/
[491faece32fa426492a4f765f46fbfd2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/de4b973f68bb495dbd30e0b4e04191cf.png
[7ae02050b0c94312b804058e4146c1a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c07ae8a6901549d8a504df83034e8390.png
[fc4b9f5211054d31a897b53e30d5068a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d6ecec7af86148e693a51f6181eb4fb0.png
[2dc1be6c75d243edb06ced6edc1f72b3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e2987c2ff28b48abbf6d6da32db0bcda.png
[ae3800778335456bafd713d1693bf3cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2aff40a86b184b17b815ef7b78c90cfe.png
[149c231765b849628adb68f3b760cab9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/88f012c3a8744982be09df16f1f90f7a.png
[cjson]: https://github.com/openresty/lua-cjson/
[7470e1ff5da240baad3566e909ebee15.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/7b5064ddc4bc4670b723416b70bc31e1.png
[6d7bbb23aa6e427d9be17c80c40b1a9a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/53251d8dfa994d39826e4d9ba28f8125.png
[44b84ba3ef5f439bad1d7aaeeeee0b82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/bc473b346fbb4e3aba0201f652dd7e8c.png
[955221440d204c2e93ab85fb9af78c4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/26c249c6a50e4133bb4b9b1aeb23af74.png
[b921ebe577bb4a8ba3cf0d6195989098.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a7e60997a525435daf388098fbd3000f.png
[8299acd8d2ce446684076d6f235a5233.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/9c745b7b3b5f4dc082f2129f68eefa8d.png
[35fe2c59fae34e1baebc9e4dfeaf674d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/bd1c4b5e118942039f2ab76cb6de03cd.png
[66f78377dd614149bc4788d4a0e0864b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/0be51761410c42bdaffee20b269fe1c7.png
[7990a825b2b64b3c98f587e9ad97cf65.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/72425a8ab5b6462cb8a749a7b399a2d9.png
[canal]: https://github.com/alibaba/canal
[0a4aece7f814469984c115cf510f789a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/166509babc1c4389994397f46884aad5.png
[71e3f082061042f6bcfd3ea56cc8de61.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a17c10671b544663aec72073725b63e5.png
[8969453a16654960b6069adee6908b55.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f1f795e4bd4842b6b0ad32a8d3d4fc9a.png
[3bde249a5f254414aecc549c13ff9724.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/8f2e8a8555b64524be9a145af131d966.png
[4c72e991a9e94a2babffd91265ef627b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/6bd3951a4d5647fb8b8a129c27ac8fa2.png
[2d8f9e984195490c8ac39bb9e12c91c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/8a399e5802d244efb541932b8dd8005a.png
[b3bc04ebfb6943208db488c979609712.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/4e1e14b3253c459da0710622551a9b3d.png
[942fdc99dbf14400888023c3b75dcb98.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/4b01ed4f5ebe4a91ae1b3df21a81f039.png
[canal-starter]: https://github.com/NormanGyllenhaal/canal-client
[b1dabaf25858416db34049ba187997bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a6bbf4bc7f054d5ea3ffc8a81f00a6c2.png
[canal 1]: https://mp.weixin.qq.com/s?__biz=MzI4NjE4NTUwNQ==&mid=2247493900&idx=3&sn=abfafac5eed2a17a75781a249383f701&chksm=ebe26842dc95e154721c2f2f6897e233e46b2b33cce671b0da5bd53e3bbc7b79524b674457a6&scene=27
[Link 3]: https://blog.csdn.net/qq_43456605/article/details/130134136