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

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

• 请求要经过Tomcat处理，Tomcat的性能成为整个系统的瓶颈
• Redis缓存失效时，会对数据库产生冲击
  而多级缓存就是充分利用请求处理每个环节，分别添加缓存，减轻Tomcat压力，提升服务性能
  

一. 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服务

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

在数据库中新建一个库，并导入sql文件
sql文件网盘通道，提取码: grr6

导入工程
工程文件网盘通道，提取码: yhk5

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

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

部署成功

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

主页面文件通道: 提取码: b2ei

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

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);
    }

 /*
     基于大小设置驱逐策略：
     */
    @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"));
    }

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，会查数据库
  
  第二次访问直接查询Caffeine缓存，不会查询数据库
  

8. 总结

至此我们就实现了多级缓存中的Nginx部分的搭建，以及进程缓存的搭建两部分，下面继续实现其它缓存部分

二. LUA语法

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

1. 初识Lua

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

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

touch hello.lua

2. 添加下面内容

print("hello world")

3. 运行lua脚本

lua hello.lua

2. 基本语法

• 数据类型

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

可以利用type函数测试给定变量的类型

• 变量
  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

--声明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不同，布尔表达式中的逻辑运行是基于英文单词的

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

测试控制语法：自定义一个函数，当参数为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")

三. 实现多级缓存

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
  
• 配置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

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
}

3. 请求参数处理

OpenResty提供了各种API用来获取不同类型的请求参数

下面使用路径占位符的方式来实现商品信息的获取
(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"}')

4. 查询Tomcat

前面已经获取了用户的请求参数，现在就可以利用用户的请求参数来实现查询tomcat的缓存了

案例：获取请求路径中的商品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)

显示结果

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缓存

但现在存在问题：冷启动问题
冷启动：服务刚刚启动时，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服务

2. 在item-service中引入redis依赖

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

3. 配置Redis地址

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

4. 编写初始化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方法，该方法会在属性注入完成后执行

预热功能实现

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

2. 编写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

8. Nginx本地缓存

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

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

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

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

• 操作共享字典

-- 获取本地缓存对象
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
#该命令将显示出日志文件的最后几行内容，如果有新的内容加入到日志文件，它还会立即显示出新加入的内容

重新访问10004号商品，发现日志没有变化，说明数据确实访问了Nginx本地缓存

至此多级缓存搭建完毕

四. 缓存同步策略

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

1. 数据同步策略

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

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

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

2. 安装Canal

Canal：canal是阿里巴巴旗下的一款开源项目，基于java开发。基于数据库增量日志解析，提供增量数据订阅&消费。canal是基于Msql主从同步来实现的，Mysql主从同步的原理如下所示：

• 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的客户端，进而完成对其它数据库的同步
  

下面开始安装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

2. 设置用户权限
   接下来添加一个仅用于数据同步的账户，处于安全考虑，这里仅提供对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的权限表，以使修改后的权限立即生效。

测试是否成功

show master status

mysql的主从同步原理可以结合Redis的主从同步原理来理解

3. docker网络部署

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

docker network create (网络名)

• 让mysql加入这个网络

docker network connect es-net mysql

4. 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日志情况**

查看canal启动日志情况

3. 监听Canal

canal提供了各种语言的客户端，当Canal监听到binlog变化时，会通知Canal的客户端。这里使用第三方开源的canal-starter，在SpringBoot中整合

• 引入依赖

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

@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;
}