Redis高级(2) —- 多级缓存

传统的缓存的请求要经过Tomcat,性能收到Tomcat限制; 同时若Redis中不存在所需要的数据,还要去MySql中进行进一步的查找操作,也比较耗时; 设置后就可以采用多级缓存方案

image-20240228155655591

JVM进程缓存

我们把缓存分为两类：

  • 分布式缓存，例如Redis：
    • 优点：存储容量更大、可靠性更好、可以在集群间共享
    • 缺点：访问缓存有网络开销
    • 场景：缓存数据量较大、可靠性要求较高、需要在集群间共享
  • 进程本地缓存，例如HashMap、GuavaCache：
    • 优点：读取本地内存，没有网络开销，速度更快
    • 缺点：存储容量有限、可靠性较低、无法共享
    • 场景：性能要求较高，缓存数据量较小

Caffeine

Caffeine是一个基于Java8开发的，提供了近乎最佳命中率的高性能的本地缓存库。目前Spring内部的缓存使用的就是Caffeine。

它的使用也很简单

缓存使用的基本API：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
void testBasicOps() {
    // 构建cache对象
    Cache<String, String> cache = Caffeine.newBuilder().build();

    // 存数据
    cache.put("gf", "迪丽热巴");

    // 取数据
    String gf = cache.getIfPresent("gf");
    System.out.println("gf = " + gf);

    // 取数据，包含两个参数：
    // 参数一：缓存的key
    // 参数二：Lambda表达式，表达式参数就是缓存的key，方法体是查询数据库的逻辑
    // 优先根据key查询JVM缓存，如果未命中，则执行参数二的Lambda表达式
    String defaultGF = cache.get("defaultGF", key -> {
        // 根据key去数据库查询数据
        return "柳岩";
    });
    System.out.println("defaultGF = " + defaultGF);
}

在创建它时,可以配置他的最大缓存数量,初始缓存数量,缓存过期时间等

多级缓存

下面是目标要实现的缓存架构

yeVDlwtfMx

OpenResty

我们可以通过先OpenResty借助nginx实现反向代理

  • windows上的nginx用来做反向代理,将前端查询的ajax请求代理到centos上的OpenResty集群
  • OpenResty集群用来编写多级缓存的业务

具体配置过程省略

  • 网页访问请求首先通过nginx转发到centos服务器上的nginx端口

    1
    2
    3
    upstream nginx-cluster{
        server 192.168.159.137:8081;
    }

  • centos服务器上的nginx在接收到转发过来的请求后,调用OpenResty进行根据编写的lua脚本进行进一步的处理并返回请求的数据

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    #lua 模块
    lua_package_path "/usr/local/openresty/lualib/?.lua;;";
    #c模块     
    lua_package_cpath "/usr/local/openresty/lualib/?.so;;";  	...
    server{
    	   location /api/item {
               #默认响应类型
               default_type application/json;
               #响应结果
               content_by_lua_file lua/item.lua;
           }
    }

获取参数的API

image-20210821101433528

Tomcat

通过上面的参数我们获取到了反向代理后传入的API,这里先来实现从OpenResty到Tomcat的请求查询

首先将打入的 请求按照标记拦截,进行响应处理后转发到主机的服务端口

先配置一个方法,用来发送http请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
-- 封装函数，发送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请求查询失败, path: ", path , ", args: ", args)
        ngx.exit(404)
    end
    return resp.body
end
-- 将方法导出
local _M = {  
    read_http = read_http
}  
return _M

然后编写查询的lua脚本,分别查询商品数据和库存数据,然后进行合并,最后返回查询结果的json数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#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;


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

    server {
        listen       8081;
        server_name  localhost;
        
        location /item {
    	    	proxy_pass http://192.168.159.1:8081;
    	    }
        
        location ~ /api/item/(\d+) {
            #默认响应类型
            default_type application/json;
            #响应结果
            content_by_lua_file lua/item.lua;
        }
        
        location / {
            root   html;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

这里花了好长时间排查BUG,因为一直不返回结果; 又不知道这里怎么debug,最后是一步一步排查,做了一个下午才成功返回数据的

负载均衡

由于集群进程之间的缓存是不共享的, 而Tomcat的默认负载均4衡采用轮询的方式, 这样就会造成缓存的失效;
所以这里就引入一个hash的的负载均衡 hash $request_uri ,对于某个商品, 就去特定的服务器进行查询

Redis缓存预热

冷启动: 服务刚刚启动时,由于缓存还没有载入,在初次访问数据时会访问数据库,可能造成数据库压力过大

缓存预热:在实际开发中我们可以统计出热点数据, 在项目启动时将数据预载入Redis

这里直接在虚拟机上安装redis,在对应服务启动时,先从mysql中拉取对应的数据列表,再遍历列表将数据存入Redis即可

最后修改item.lua的逻辑即可实现多级缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
-- 导入common函数库
local common = require('common')
local read_http = common.read_http
local read_redis = common.read_redis
-- 导入cjson库
local cjson = require('cjson')

-- 封装查询函数
function read_data(key, path, params)
    -- 查询本地缓存
    local 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
    -- 返回数据
    return val
end

-- 获取路径参数
local id = ngx.var[1]

-- 查询商品信息
local itemJSON = read_data("item:id:" .. id,  "/item/" .. id, nil)
-- 查询库存信息
local stockJSON = read_data("item:stock: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

-- 把item序列化为json 返回结果
ngx.say(cjson.encode(item))

nginx本地缓存

image-20210821114742950

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

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

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

2）操作共享字典：

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

实现本地缓存查询

1）修改/usr/local/openresty/lua/item.lua文件，修改read_data查询函数，添加本地缓存逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
-- 导入共享词典，本地缓存
local item_cache = ngx.shared.item_cache

-- 封装查询函数
function read_data(key, expire, 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, expire)
    -- 返回数据
    return val
end

2）修改item.lua中查询商品和库存的业务，实现最新的read_data函数：

image-20210821115108528

其实就是多了缓存时间参数，过期后nginx缓存会自动删除，下次访问即可更新缓存。

这里给商品基本信息设置超时时间为30分钟，库存为1分钟。

因为库存更新频率较高，如果缓存时间过长，可能与数据库差异较大。

3）完整的item.lua文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
-- 导入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

-- 封装查询函数
function read_data(key, expire, 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, expire)
    -- 返回数据
    return val
end

-- 获取路径参数
local id = ngx.var[1]

-- 查询商品信息
local 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的table
local item = cjson.decode(itemJSON)
local stock = cjson.decode(stockJSON)
-- 组合数据
item.stock = stock.stock
item.sold = stock.sold

-- 把item序列化为json 返回结果
ngx.say(cjson.encode(item))