ToB企服应用市场:ToB评测及商务社交产业平台

标题: Redis --- 多级缓存【一篇文章带你深入了解缓存架构】 [打印本页]

作者: 羊蹓狼 时间: 2025-2-19 09:04
标题: Redis --- 多级缓存【一篇文章带你深入了解缓存架构】
传统的缓存策略一样平常是请求到达Tomcat后，先查询Redis，在查询数据库。但是如许会有很多标题：

请求都需要经过Tomcat处理，而Tomcat的性能就会成为整个体系的瓶颈。
倘若Redis缓存失效，会对数据库短时间内造成巨大冲击。

而我们为了解决上面两种标题，提出了多级缓存处理方案。
多级缓存就是充分利用请求处理的每个环节，分别添加缓存，以此来减轻Tomcat的压力，提升服务性能，通常有下面这几层：

浏览器客户端缓存：浏览器可以将静态资源缓存，随后检验数据是否发生变化（无变化直接返回304状态码），假如为304则数据无变化，直接将数据从浏览器中取出。
nginx本地缓存：将非静态资源缓存。
Redis缓存
Tomcat进程缓存：在服务器内部利用一个map等形式形成一个进程缓存。

所以为了学习多级缓存，我们需要学习以下知识：

JVM进程缓存
Lua语法编写nginx
实现多级缓存
缓存同步策略

JVM进程缓存

1.安装Mysql：

后期做数据同步需要用到MySQL的主从功能，所以需要我们在虚拟机中利用Docker命令来运行一个MySQL容器。不会安装的可以参考下面教程：Linux --- 怎样安装Docker命令而且利用docker安装Mysql【一篇内容直接解决】
（1）准备目次：

为了方便后期设置MySQL，我们先准备两个目次，用于挂载容器的数据和设置文件目次：

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

复制代码

（2）运行命令：

进入mysql目次后，执行下面的Docker命令：

docker run \
-p 3306:3306 \
--name mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123 \
--privileged \
-d \
mysql:5.7.25

复制代码

（3）修改设置：

在/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

复制代码

（4）重启：

设置修改后，必须重启容器：

docker restart mysql

复制代码

随后在navicat连接即可：（留意：这里主秘密用虚拟机的IP，可以利用ifconfig命令查察本身的虚拟机IP地址）

2.运行nginx服务：

我们将一个nginx文件夹拷贝到一个非中文目次下，运行这个nginx服务：

start nginx.exe

复制代码

我们打开控制台，可以看到页面有发起ajax查询数据，而这个请求地址同样是80端口，所以被当前的nginx反向代理了：

可以查察nginx.conf以此来看详细信息：

http {
include mime.types;
default_type application/octet-stream;
sendfile on;
#tcp_nopush on;
keepalive_timeout 65;
# nginx的业务集群，可以实现下面三个缓存：nginx的本地缓存、redis缓存、tomcat查询
upstream nginx-cluster{
server 192.168.150.101:8081; #对应的nginx业务集群
}
server {
listen 80;
server_name localhost;
location /api { # 监听/api路径，反向代理到nginx-cluster集群
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;
}
}
}

复制代码

# nginx的业务集群，可以实现下面三个缓存：nginx的本地缓存、redis缓存、tomcat查询
upstream nginx-cluster{
server 192.168.150.101:8081; #对应的nginx业务集群
}

复制代码

而我们上面的代码就相当于下面化红框的部门：

3.本地进程缓存：

进行本地进程缓存我们一样平常利用Caffeine。Caffeine 是一个高性能的 Java 本地缓存库，广泛应用于 Spring Boot 项目中来缓存数据。Caffeine 提供了比 Guava Cache 更高的性能，同时支持高级特性如缓存过期、最大容量、自动加载等。下面有两个Caffeine教学地址：

Caffeine官网教学
高并发处理 --- Caffeine内存缓存库

这里不给详细教学，参考下面的方法进行利用即可：

public class CaffeineTest {
@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);
}
}

复制代码

以及缓存驱逐策略：

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.junit.jupiter.api.Test;
import java.time.Duration;
public class CaffeineTest {
/*
基于大小设置驱逐策略：
*/
@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"));
}
}

复制代码

Lua语法入门

在上面我们利用 Caffeine 实现 Tomcat 本地进程缓存，那么接下来我们就要利用 Lua 脚本实现 nginx 的本地缓存。
Lua 是一种轻量级、可扩展的脚本语言，广泛应用于嵌入式体系、游戏开辟、Web 应用、Nginx 设置等范畴。Lua 语法简洁，学习曲线平缓，适合快速上手。可以查察下面官网：Lua官网
在我们的Centos是自带Lua环境，可以在Linux虚拟机直接利用。
1.数据范例：

我们直接输入lua命令就可以打开lua控制台，随后直接就能编译我们想要的结果：

2.根本语法：

（1）变量和数据范例：

Lua 是动态范例语言，变量的范例是在运行时确定的，所以不需要指定命据范例。

local x = 10 -- 定义一个局部变量 x
y = 20 -- 定义一个全局变量 y

复制代码

（2）表（table）：

表是 Lua 中的唯一数据结构，可以用来体现数组、字典、聚集等。
留意：Lua中数组访问是从角标1开始，而没有角标0。
声明数组key为索引的table：

local t = {} -- 创建一个空表
t[1] = "Hello" -- 数组形式
t["name"] = "Lua" -- 字典形式
print(t[1]) -- 输出：Hello
print(t["name"]) -- 输出：Lua

复制代码

声明table，类似Java的map：

local map = {name='Jack',age='21'}
print(map['name'])
print(map.name)

复制代码

（3）判定与循环：

Lua 支持常见的控制结构，如条件语句和循环。
条件语句：

local a = 10
if a > 5 then
print("a is greater than 5")
elseif a == 5 then
print("a is equal to 5")
else
print("a is less than 5")
end

复制代码

循环：

local i = 1
-- while循环
while i <= 5 do
print(i)
i = i + 1
end
-- for循环
for i = 1, 5 do
print(i)
end

复制代码

（4）函数：

函数定义：

function greet(name)
return "Hello, " .. name
end
print(greet("Lua")) -- 输出：Hello, Lua

复制代码

匿名函数：

local add = function(a, b)
return a + b
end
print(add(2, 3)) -- 输出：5

复制代码

OpenResty

OpenResty 是基于 Nginx 和 Lua 的一个高性能 Web 应用服务器，它将 LuaJIT（高效的 Lua 实现）集成到 Nginx 中，使得开辟者能够用 Lua 语言高效地处理 HTTP 请求、响应和其他各种 Web 功能。它不但可以充分发挥 Nginx 高性能的特点，还结合了 Lua 的灵活性和高效性，极大地扩展了 Nginx 的本事。
OpenResty 提供了大量的库和模块，支持动态 Web 编程，能够实现各种 Web 应用和服务，适适用于开辟 API 网关、动态 Web 应用、负载均衡器、Web 缓存等。下面是官网地址：OpenResty开源官方
1.安装OpenResty：

（1）安装OpenResty的依赖开辟库：

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

复制代码

（2）安装OpenResty仓库：

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

复制代码

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

yum install -y yum-utils

复制代码

然后再重复上面的命令。
（3）安装OpenResty：

yum install -y openresty

复制代码

默认环境下，OpenResty安装的目次是：/usr/local/openresty
（4）安装opm工具：

opm是OpenResty的一个管理工具，可以资助我们安装一个第三方的Lua模块。
假如我们想安装命令行工具 opm，那么可以像下面如许安装 openresty-opm 包：

yum install -y openresty-opm

复制代码

（5）设置nginx的环境变量：

打开设置文件：（留意：必须在OpenResty目次下运行命令）

vi /etc/profile

复制代码

在最下面加入两行：

export NGINX_HOME=/usr/local/openresty/nginx
export PATH=${NGINX_HOME}/sbin:$PATH

复制代码

NGINX_HOME：背面是OpenResty安装目次下的nginx的目次
然后让设置生效：

source /etc/profile

复制代码

2.启动OpenResty：

OpenResty底层是基于Nginx的，查察OpenResty目次的nginx目次，结构与windows中安装的nginx根本一致，所以运行方式与nginx根本一致：

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

复制代码

nginx的默认设置文件解释太多，影响后续我们的编辑，这里将nginx.conf中的解释部门删除，保留有效部门。
修改/usr/local/openresty/nginx/conf/nginx.conf文件，内容如下：

#user nobody;
worker_processes 1;
error_log logs/error.log;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
server {
listen 8081;
server_name localhost;
location / {
root html;
index index.html index.htm;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
}

复制代码

在Linux的控制台输入命令以启动nginx：

nginx

复制代码

然后访问页面：http://192.168.88.133:8081，留意ip地址更换为你本身的虚拟机IP，而且要关闭防火墙。随后运行乐成访问网页可以得到下面图片样式。

3.在OpenResty中接受请求：

在上面的nginx的设置中，我们介绍了下面代码：

# nginx的业务集群，可以实现下面三个缓存：nginx的本地缓存、redis缓存、tomcat查询
upstream nginx-cluster{
server 192.168.88.133:8081; #对应的nginx业务集群
}
server {
listen 80;
server_name localhost;
location /api { # 监听/api路径，反向代理到nginx-cluster集群
proxy_pass http://nginx-cluster;
}
}

复制代码

而且当访问 "/api" 的时间，会反向代理访问 nginx 的业务集群，而这个业务集群地址就是我们设置的 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/(\d+) {
# 响应类型，这里返回json
default_type application/json;
# 响应数据由 lua/item.lua 这个文件来决定
content_by_lua_file lua/item.lua;
}

复制代码

随后我们在/nginx/lua/item.lua文件中添加下面代码就可以实现：

-- 获取路径参数（\d+）
local id = ngx.var[1]
-- 返回结果
ngx.say('{"name":"zhangsan","age":"21"}')

复制代码

ngx.say 是 OpenResty 中提供的一个函数，它用于向客户端输出数据。这会将数据发送到 HTTP 响应体中，作为客户端吸收到的响应内容。在这一行代码输出一个 JSON 字符串 {"name":"zhangsan","age":"21"}，并作为 HTTP 响应返回给客户端。
工作流程：

当客户端访问一个设置了这段代码的 Nginx 路由时，Nginx 会通过 Lua 执行这行代码。
ngx.say() 会将这个 JSON 字符串作为响应返回给客户端。
客户端收到响应后，可以将其作为 JSON 数据进行解析，提取出 name 和 age 的值。

最后重新加载设置：

nginx -s reload

复制代码

而OpenResty提供了各种API用来获取不同范例的请求参数：

4.怎样实现从OpenResty到Tomcat的查询：

执行流程概述：

客户端请求到达 Nginx。
Nginx 代理请求到 OpenResty，执行 Lua 脚本。
OpenResty 的 Lua 脚本向内部路径 /path 发起请求。
Nginx 代理请求到 Tomcat，Tomcat 处理请求并返回响应。
OpenResty 捕获 Tomcat 的响应并返回给客户端。

客户端 → Nginx → OpenResty (Lua 脚本) → Nginx (反向代理) → Tomcat → Nginx (返回) → OpenResty → 客户端

复制代码

下面是案例：

（1）发送Http请求：

起首需要查询商品信息，nginx提供了内部的API用来发送Http请求，比方下面例子：

local resp = ngx.location.capture("/path",{ -- /path 是目标路径，表示请求将被发往这个 Nginx 路由
method = ngx.HTTP_GET, -- 请求方式
args = {a = 1,b = 2}, -- get方式传参数，最终请求的 URL 会是 /path?a=1&b=2
body = "c=3&d=4" -- post方式传参数
})

复制代码

其返回响应内容包括：

resp.status：响应状态码
resp.header：响应头，是一个table
resp.body：响应体，就是响应数据

但是这里的path是路径，并不包含IP以及端标语，所以这个请求会被nginx内部的server监听并处理。但是我们需要将这个请求发送给Tomcat服务器，所以还需要编写一个server来对这个路径做反向代理：

location /path {
# 这里是windows电脑的ip和Java的服务接口，需要确保windows防火墙处于关闭状态
proxy_pass http://192.168.150.1:8081;
}

复制代码

上面这段设置的作用是，当访问 /path 路径时，Nginx 会将请求代理到 http://192.168.150.1:8081，即转发到 Windows 电脑上的 Java 服务接口。
（2）函数封装：

假如上面的内容需要反复调用，我们可以将Http查询封装一个函数方法，放到OpenResty函数库中，方便后期利用。
起首在 /usr/local/openresty/lualib 目次下创建common.lua文件：

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

复制代码

留意：在前面我们设置了下面命令：

#lua 模块
lua_package_path "/usr/local/openresty/lualib/?.lua;;";

复制代码

如许就可以直接自动加载该lua模块。
之后再common.lua中封装http查询的函数：

local function read_http(path,params)
local resp = ngx.location.capture(path,{ -- path 是传递的目标路径，表示请求将被发往这个 Nginx 路由
method = ngx.HTTP_GET, -- 请求方式
args = params, -- get方式传参数，最终请求的 URL 会是 /path?a=1&b=2
})
-- 如果 ngx.location.capture 返回 nil（表示请求失败），则进入错误处理逻辑
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
}
-- 返回模块 _M，使得 read_http 函数可以在其他地方使用。
return _M

复制代码

  总结：

  起首我们利用nginx的API也就是【ngx.location.capture】去发起请求，指定请求路径，请求方式以及请求参数，在这里，我们发起的请求是被nginx捕获，然后需要我们编写一个反向代理也就是【location 地址{}】将发起的请求拦截下来并代理【proxy_pass 地址】到目标服务器（Tomcat）。
  （3）向Tomcat查询数据：

在我们上面对nginx设置时写入了下面代码：

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

复制代码

在这里请求进入item.lua，随后由这个文件内部执行http查询：

-- 获取路径参数（\d+）
local id = ngx.var[1]
-- 返回结果
ngx.say('{"name":"zhangsan","age":"21"}')

复制代码

起首导入common函数库：

-- 导入common函数库
local common = require('common'); -- 内部是文件名
-- 因为接受的函数返回的是一张表，需要接收内部的read_http
local read_http = common.read_http;

复制代码

然后利用函数read_http去查询商品与库存信息：

-- 查询商品信息：
-- 用..拼接id，随后因为无参传递所以可以直接写nil
local itemJSON = read_http("/item/" ..id, nil);
-- 查询库存信息：
local stockJSON = read_http("/item/stock/" ..id, nil);

复制代码

但是这个是返回的JSON格式，需要我们转换成lua的table，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);

复制代码

所以我们可以根据上面实例编写代码，将JSON转化为lua的table：

-- 导入cjson库local cjson = require('cjson')-- 查询商品信息：
-- 用..拼接id，随后因为无参传递所以可以直接写nil
local itemJSON = read_http("/item/" ..id, nil);
-- 查询库存信息：
local stockJSON = read_http("/item/stock/" ..id, nil);
-- 将JSON转化为lua的tablelocal item = cjson.decode(itemJSON);local stock = cjson.decode(stockJSON);-- 组合数据：将库存数据放入商品中并返回item.stock = stock.stock;item.sold = stock.sold;-- 为了返回结果，需要将item序列化为JSONngx.say(cjson.encode(item));

复制代码

完整代码展示：

-- 导入common函数库
local common = require('common'); -- 内部是文件名
-- 因为接受的函数返回的是一张表，需要接收内部的read_http
local read_http = common.read_http;-- 导入cjson库local cjson = require('cjson')-- 获取路径参数（\d+）local id = ngx.var[1]-- 查询商品信息：
-- 用..拼接id，随后因为无参传递所以可以直接写nil
local itemJSON = read_http("/item/" ..id, nil);
-- 查询库存信息：
local stockJSON = read_http("/item/stock/" ..id, nil);
-- 将JSON转化为lua的tablelocal item = cjson.decode(itemJSON);local stock = cjson.decode(stockJSON);-- 组合数据：将库存数据放入商品中并返回item.stock = stock.stock;item.sold = stock.sold;-- 为了返回结果，需要将item序列化为JSONngx.say(cjson.encode(item));

复制代码

随后OpenResty Lua 脚本执行完毕后，终极将响应数据发送给客户端。
团体流程分析：

在我们这个场景中，客户端发起一个请求到 Nginx，Nginx 转发请求到 OpenResty 的 Lua 脚本，Lua 脚本根据路径参数查询商品和库存信息，最后将合并后的数据以 JSON 格式返回给客户端。

客户端 → Nginx → OpenResty (Lua 脚本) → Nginx (代理请求) → 后台服务 (Tomcat) → Nginx (响应返回) → OpenResty → 客户端

复制代码

① 起首 客户端发起请求：客户端向 Nginx 发起一个 HTTP 请求：

GET /api/item/123

复制代码

② 随后 Nginx 吸收请求并路由到 OpenResty： Nginx 吸收到该请求，并根据设置将其转发给 OpenResty 的 Lua 脚本进行处理：

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

复制代码

③ 之后 OpenResty 执行 Lua 脚本：进入 OpenResty 后，item.lua 脚本开始执行。一样平常我们在脚本中写入查询服务器并返回数据给客户端的代码。
在脚本中，通过自封装的 read_http 方法向 Nginx 内部路径发起请求：

local itemJSON = read_http("/item/" .. id, nil)
local stockJSON = read_http("/item/stock/" .. id, nil)

复制代码

这些请求会通过 ngx.location.capture 发起，而且是 内部请求，不会直接袒露给客户端。read_http 会发送请求并获取响应。
④ 再然后，Nginx 代理请求到后台服务（如 Tomcat）：

location /item/ {
# 这里是windows电脑的ip和Java的服务接口，需要确保windows防火墙处于关闭状态
proxy_pass http://192.168.150.1:8081;
}

复制代码

⑤ 最后在 item.lua 脚本内， OpenResty 将最闭幕果利用 ngx.say() 返回给客户端：

ngx.say(cjson.encode(item))

复制代码

5.对Tomcat做负载均衡处理：

在上面我们通过向Tomcat发送请求查询数据并封装返回，但是在实际项目中Tomcat会是一个集群，所以我们在OpenResty给Tomcat发送请求时必须对Tomcat实现负载均衡处理。

而做负载均衡处理时也很简单，只需要在 http 内利用【upstream 集群名称 {tomcat端标语}】就可以实现对{}内的每一台Tomcat做轮询的负载均衡：

upstream tomcat-cluster {
server 192.168.150.1:8081;
server 192.168.150.1:8081;
}

复制代码

而在前面对于反向代理设置，我们需要在 server 内将 /item 路径的请求代理到 Tomcat 集群：

location /item {
proxy_pass http://tomcat-cluster;
}

复制代码

但是由于不同进程缓存不共享，所以假如我们第一次访问8081，第二次访问8082后，第二次是无法利用8081的缓存的，所以我们需要保证相同的id永远访问相同的服务器，以此来达到利用进程缓存的目标。
那么接下来我们就需要利用【hash $request_uri】其中request_uri是请求路径，而hash是对这个路径进行哈希运算得到一个哈希值，随后对Tomcat服务器数量取模，如许只要路径稳固就可以保证路径可以精确访问同一台Tomcat服务器上，随后我们在http内改写设置文件：

upstream tomcat-cluster {
hash $request_uri;
server 192.168.150.1:8081;
server 192.168.150.1:8081;
}

复制代码

利用 Redis 实现多级缓存

在上面我们利用OpenResty与Tomcat来配合实现缓存效果，那么为了低落对Tomcat服务器的压力，我们可以在二者之间加入Redis进行优化。

如上图，我们在请求到达OpenResty后优先查询Redis，假如Redis缓存未掷中在查询Tomcat，那么接下来我们围绕这一目标进行讲解。
1.冷启动与缓存预热：

冷启动是指体系或服务在启动时，由于Redis中并没有缓存，假如所有的商品数据都在第一次查询时添加缓存，肯定会给数据库造成较大的压力。
而为了解决这种现象，我们一样平常会接纳缓存预热来解决标题。
缓存预热是指在体系启动或者服务启动时，提前将需要的热点数据加载到缓存中，以便在后续的请求中能够快速响应。缓存预热是为了避免在缓存为空时发生频繁的缓存穿透或缓存未掷中，从而影响体系性能。
而我们可以在体系或服务启动前，提前将一些热点数据存储到缓存中。
利用下面命令在 Linux 虚拟机中创建Redis（我利用的是Centos7）：

docker run --name redis -p 6379:6379 -d redis redis-server --appendonly yes

复制代码

随后我们进行依赖以及设置Redis地址，之后在 /config/RedisHandler 编写初始化类：
为了实现体系或服务启动后来预热加载，我们可以利用 InitializingBean ，它是 Spring 的一个接口，其中包含一个方法 afterPropertiesSet()，该方法会在 Spring 完成依赖注入后自动调用，适用于需要在 Bean 初始化完成后执行某些操纵的场景。
别的还需要用到 Spring 默认的 json 处理器 ObjectMapper ，将类序列化成 json 串。

@Component
public class RedisHandler implements InitializingBean {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private IItemService itemService;
@Autowired
private IItemStockService itemStockService;
// Spring默认的json处理器
private static final ObjectMapper MAPPER = new ObjectMapper();
// 这个方法会在Bean创建完成并且Autowired注入以后执行
@Override
public void afterPropertiesSet() throws Exception {
// 初始化缓存
// 查询商品信息
List<Item> itemList = itemService.list();
// 放入缓存
for (Item item : itemList) {
// 将 item 序列化为json
String json = MAPPER.writeValueAsString(item);
// 存入redis
stringRedisTemplate.opsForValue().set("item:id:" + item.getId(), json);
}
}
}

复制代码

2.实现OpenResty优先查Redis查不到在查Tomcat：

为了在OpenResty中操纵Redis模块，我们可以利用OpenResty内部的模块 “resty.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)
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

复制代码

之后我们将上面三段代码合并：

-- 省略上面对 read_http 的代码------------------------------------- 下面是 read_redis 代码-- 引入Redis模块
local redis = require("resty.redis")
-- 初始化Redis对象
local red = redis:new()
-- 设置Redis超时时间
-- (建立连接的超时时间,发送请求的超时时间,响应结果的超时时间)
red:set_timeouts(1000,1000,1000) -- 关闭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的方法 ip和port是redis地址，key是查询的keylocal function read_redis(ip, port, key) -- 获取一个连接 local ok, err = red:connect(ip, port) 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 -- 关闭Redis连接 close_redis(red) return respend-- 将方法导出local _M = { read_http = read_http, read_redis = read_redis}return _M

复制代码

那么接下来我们就在item.lua去利用上面封装的方法：
我们直接将查询过程（优先查Redis，查不到查Tomcat）封装一个函数：

-- 封装查询函数
function read_data(key,path,params)
-- 查询Redis
local resp = read_redis("127.0.0.1", 6379, key)
-- 判断查询结果
if not resp then
ngx.log(ngx.ERR, "redis查询失败，尝试查询http,key: ",key)
-- redis查询失败，去查询http
resp = read_http(path,params)
end
return resp
end

复制代码

随后在下面直接调用这个函数即可得到响应数据：

-- 导入common函数库
local common = require('common'); -- 内部是文件名
-- 因为接受的函数返回的是一张表，需要接收内部的read_http
local read_http = common.read_http;local read_redis = common.read_redis-- 导入cjson库local cjson = require('cjson')-- 封装查询函数
function read_data(key,path,params)
-- 查询Redis
local resp = read_redis("127.0.0.1", 6379, key)
-- 判断查询结果
if not resp then
ngx.log(ngx.ERR, "redis查询失败，尝试查询http,key: ",key)
-- redis查询失败，去查询http
resp = read_http(path,params)
end
return resp
end-- 获取路径参数（\d+）local id = ngx.var[1]-- 查询商品信息：-- 用..拼接id，随后因为无参通报所以可以直接写nillocal itemJSON = read_data("item:id:" .. id, "/item/" .. id, nil);-- 查询库存信息：local stockJSON = read_data("item:stock:id:" .. id, "/item/stock/" .. id, nil);-- 将JSON转化为lua的tablelocal item = cjson.decode(itemJSON);local stock = cjson.decode(stockJSON);-- 组合数据：将库存数据放入商品中并返回item.stock = stock.stock;item.sold = stock.sold;-- 为了返回结果，需要将item序列化为JSONngx.say(cjson.encode(item));

复制代码

3.怎样在nginx添加本地缓存？

我们还想要在请求到OpenResty后优先查找nginx本地缓存，未掷中在查Redis，在未掷中在查Tomcat。
OpenResty为 Nginx 提供了 shared dict 的功能，可以在nginx的多个worker之间共享数据（在nginx中有一个master进程和多个worker进程），实现缓存功能，通常是通过 lua_shared_dict 和 OpenResty 提供的 lua 模块来实现的。
起首在http内利用【lua_shared_dict】开启共享辞书（本地缓存）：

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

复制代码

而操纵共享辞书时，我们先获取本地缓存对象，然后存储后读取：

-- 获取本地缓存对象
local cache = ngx.shared.my_cache
-- 存储，指定key、value、过期时间(单位s，默认为0代表永不过期)
cache:set("key", "value", 60)
-- 从缓存中读取数据
local value = cache:get("key")
-- 删除指定键的缓存
cache:delete("key")
-- 清空所有缓存
cache:flush_all()

复制代码

那么接下来我们开启共享辞书后再item.lua内加入查询nginx本地缓存逻辑：
在这里我们需要优先查找nginx本地缓存，未掷中在查Redis，在未掷中在查Tomcat。
留意：我们需要加入过期时间（单元为秒）

-- 获取本地缓存对象
local item_cache = ngx.shared.my_cache
-- 封装查询函数
function read_data(key, expireTime, path ,params)
-- 查询本地缓存
local val = item_cache:get(key)
if not val then
ngx.log(ngx.ERR, "本地缓存查询失败，尝试查询Redis,key: ", key)
-- 查询Redis
val = read_redis("127.0.0.1", 6379, key)
-- 判断查询结果
if not val then
ngx.log(ngx.ERR, "redis查询失败，尝试查询http,key: ", key)
-- redis查询失败，去查询http
val = read_http(path, params)
end
end
-- 查询成功后，先把数据写入本地缓存然后再返回数据
item_cache:set(key, val, expireTime)
return val
end

复制代码

随后完整代码如下：

-- 导入common函数库
local common = require('common'); -- 内部是文件名
-- 因为接受的函数返回的是一张表，需要接收内部的read_http
local read_http = common.read_http;local read_redis = common.read_redis-- 导入cjson库local cjson = require('cjson')-- 获取本地缓存对象
local item_cache = ngx.shared.my_cache
-- 封装查询函数
function read_data(key, expireTime, path ,params)
-- 查询本地缓存
local val = item_cache:get(key)
if not val then
ngx.log(ngx.ERR, "本地缓存查询失败，尝试查询Redis,key: ", key)
-- 查询Redis
val = read_redis("127.0.0.1", 6379, key)
-- 判断查询结果
if not val then
ngx.log(ngx.ERR, "redis查询失败，尝试查询http,key: ", key)
-- redis查询失败，去查询http
val = read_http(path, params)
end
end
-- 查询成功后，先把数据写入本地缓存然后再返回数据
item_cache:set(key, val, expireTime)
return val
end-- 获取路径参数（\d+）local id = ngx.var[1]-- 查询商品信息：-- 用..拼接id，随后因为无参通报所以可以直接写nillocal itemJSON = read_data("item:id:" .. id, 1800, "/item/" .. id, nil);-- 查询库存信息：local stockJSON = read_data("item:stock:id:" .. id, 60, "/item/stock/" .. id, nil);-- 将JSON转化为lua的tablelocal item = cjson.decode(itemJSON);local stock = cjson.decode(stockJSON);-- 组合数据：将库存数据放入商品中并返回item.stock = stock.stock;item.sold = stock.sold;-- 为了返回结果，需要将item序列化为JSONngx.say(cjson.encode(item));

复制代码

利用下面代码可以查察报错日志：

tail -f logs/error.log

复制代码

缓存同步策略

缓存同步（Cache Synchronization）是指在分布式体系中，多个缓存副本的数据一致性标题。当多个缓存存储相同的数据时，需要保证这些缓存副本中的数据保持同步，以避免出现脏数据（比方，一处更新了数据，但其他缓存副本还没及时更新）。

在大多数缓存，我们都可以接纳异步通知的方式来实现：
第一种就是基于MQ的异步通知：

而第二种就是基于Canal的异步通知：

Canal 是阿里巴巴开源的一个增量订阅&消费的组件，主要用于将数据库的变更实时地同步到其他体系，如缓存或消息队列中。Canal 支持 MySQL、Oracle 等数据库的 binlog（变乱日志）增量订阅，可以将数据库中的变更（如更新、插入、删除等）捕捉并实时推送到卑鄙体系。
1.Canal工作原理：

Canal 是基于Mysql的主从同步来实现的：MySQL 的主从同步（Master-Slave Replication）是指在一个 MySQL 数据库集群中，将主库（Master）上的数据实时地复制到从库（Slave）中，以便从库能用来读取数据，提高体系的读写性能。主从同步在高可用性和负载均衡中具有广泛应用。
MySQL主从同步原理：
MySQL Master 将数据变更写入二进制日志（Binary Log），其中记录的数据叫 binary log events，而 MySQL Slave 会开启一个线程将 MySQL Master 的 binary log events 拷贝到它的中继日志（relay log），随后 MySQL Slave 重放 relay log 中变乱，将数据变更反映它本身的数据。

而Canal将本身伪装成MySQL的一个 Slave 节点，从而监听 Master 的 Binary Log 变化，随后再把得到的变化通知给Canal的客户端，以此来完成对其他数据库的同步。

2.安装和设置Canal：

由于Canal是基于MySQL的主从同步功能，因此必须先开启MySQL的主从功能才可以，所以需要我们去修改MySQL的设置文件：
起首进入 /mysql/conf/my.cnf：

vi /tmp/mysql/conf/my.cnf

复制代码

随后添加下面内容：

log-bin=/var/lib/mysql/mysql-bin
binlog-do-db=Eleven

复制代码

log-bin=/var/lib/mysql/mysql-bin：设置binary log文件的存放地址和文件名，叫做mysql-bin
binlog-do-db=Eleven：指定对哪个database记录binary log events，这里记录Eleven这个库

终极效果：

[mysqld]
skip-name-resolve
character_set_server=utf8
datadir=/var/lib/mysql
server-id=1000log-bin=/var/lib/mysql/mysql-binbinlog-do-db=heima

复制代码

接下来添加一个仅用于数据同步的账户，出于安全思量，这里仅提供对Eleven这个库的操纵权限：

CREATE USER canal@'%' IDENTIFIED BY 'canal';
GRANT SELECT, REPLICATION SLAVE, REPLICATION CLIENT, SUPER ON *.* TO 'canal'@'%' IDENTIFIED BY 'canal';
FLUSH PRIVILEGES;

复制代码

重启mysql容器即可：

docker restart mysql

复制代码

测试设置是否乐成：在mysql控制台，或者Navicat中，输入命令：

show master status;

复制代码

在然后我们需要创建一个网络，将MySQL、Canal、MQ放到同一个Docker网络中：

docker network create eleven

复制代码

让mysql加入这个网络：

docker network connect eleven mysql

复制代码

随后我们将Canal镜像压缩包上传到虚拟机中，随后通过命令导入：

docker load -i canal.tar

复制代码

然后运行命令创建Canal容器：

docker run -p 11111:11111 --name canal \
-e canal.destinations=eleven \
-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=eleven\\..* \
--network eleven \
-d canal/canal-server:v1.1.5

复制代码

随后测试Canal是否于MySQL连接乐成：

docker -exec -it canal bash
tail -f canal-server/logs/canal/canal/canal.log
tail -f canal-server/logs/eleven/eleven.log

复制代码

3.Canal的客户端：

由于官方提供的API比较麻烦，所以我们利用GitHub上开源的canal-starter。
起首引入依赖：

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

复制代码

随后导入设置：

canal:
destination: eleven # Canal 实例名，确保与 Canal 配置一致
server: 192.168.150.101:11111 # Canal 服务器地址

复制代码

随后我们需要去监听Canal：
起首需要定义ItemHandler类，而且该类需要去实现 EntryHandler<Item> 接口以此对 Item 范例的数据变更进行处理（指定表关联的实体类），而且还需要对类加入注解@CanalTable("表名")以此来表明这个类用于监听数据库表 tb_item 的数据变动，随后Canal 会将数据库表变更的数据推送到这个处理类的相应方法（insert、update、delete）。
那怎样将表中数据变成item实体类呢？所以我们需要先再item实体类添加Canal内部的注解去标记录体类与表中的映射关系：

@Data
@TableName("tb_item")
public class Item {
@TableId(type = IdType.AUTO)
@Id
private Long id;//商品id
@Column(name = "name")
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;
}

复制代码

@TableName("tb_item")：告诉 MyBatis-Plus 该实体类 Item 对应的是数据库中的 tb_item 表。
@TableId(type = IdType.AUTO)：标明该字段是数据库表中的主键，并指定主键的生成策略。type = IdType.AUTO 体现主键由数据库自动生成（比方自增）。
@Id：用于标记该字段为主键。在代码中与 @TableId 配合利用，主要是为了支持一些需要与 JPA 相关的功能，比方通过 Spring Data 来进行数据库操纵时，能够精确识别主键字段。
@Column(name = "name")：JPA 的注解，指定该字段对应的数据库表列名。假如字段名与数据库列名不同，可以通过这个注解来映射。
@TableField(exist = false)：告诉 MyBatis-Plus 该字段不需要与数据库表的列进行映射。
@Transient：JPA 的注解，标记字段为暂时的，不会映射到数据库表中。

下面就是ItemHandler的代码：

@CanalTable("tb_item")
@Component
public class ItemHandler implements EntryHandler<Item> {
@Autowired
private RedisHandler redisHandler;
@Autowired
private Cache<Long, Item> itemCache;
@Override
public void insert(Item item) {
// 写数据到JVM进程缓存
itemCache.put(item.getId(), item);
// 写数据到redis
redisHandler.saveItem(item);
}
@Override
public void update(Item before, Item after) {
// 写数据到JVM进程缓存
itemCache.put(after.getId(), after);
// 写数据到redis
redisHandler.saveItem(after);
}
@Override
public void delete(Item item) {
// 删除数据到JVM进程缓存
itemCache.invalidate(item.getId());
// 删除数据到redis
redisHandler.deleteItemById(item.getId());
}
}

复制代码

随后写出RedisHandler的代码操纵Redis缓存：

@Component
public class RedisHandler implements InitializingBean {
@Autowired
private StringRedisTemplate redisTemplate;
@Autowired
private IItemService itemService;
@Autowired
private IItemStockService stockService;
private static final ObjectMapper MAPPER = new ObjectMapper();
@Override
public void afterPropertiesSet() throws Exception {
// 初始化缓存
// 1.查询商品信息
List<Item> itemList = itemService.list();
// 2.放入缓存
for (Item item : itemList) {
// 2.1.item序列化为JSON
String json = MAPPER.writeValueAsString(item);
// 2.2.存入redis
redisTemplate.opsForValue().set("item:id:" + item.getId(), json);
}
// 3.查询商品库存信息
List<ItemStock> stockList = stockService.list();
// 4.放入缓存
for (ItemStock stock : stockList) {
// 2.1.item序列化为JSON
String json = MAPPER.writeValueAsString(stock);
// 2.2.存入redis
redisTemplate.opsForValue().set("item:stock:id:" + stock.getId(), json);
}
}
public void saveItem(Item item) {
try {
String json = MAPPER.writeValueAsString(item);
redisTemplate.opsForValue().set("item:id:" + item.getId(), json);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
}
public void deleteItemById(Long id) {
redisTemplate.delete("item:id:" + id);
}
}

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)