多级缓存之实现多级缓存

浅浅的花香味﹌ 2024-02-19 11:42 105阅读 0赞

多级缓存的实现离不开`Nginx`编程，而`Nginx`编程又离不开`OpenResty`。

### 1. `OpenResty`快速入门 ###

我们希望达到的多级缓存架构如图：

![在这里插入图片描述][c54231bb7ec849c4a0dd323d3f5bd289.png_pic_center]

其中：

*  `windows`上的`nginx`用来做反向代理服务，将前端的查询商品的`ajax`请求代理到`OpenResty`集群
 *  `OpenResty`集群用来编写多级缓存业务

#### 1.1. 反向代理流程 ####

现在，商品详情页使用的是假的商品数据。不过在浏览器中，可以看到页面有发起`ajax`请求查询真实商品数据。

这个请求如下：

![在这里插入图片描述][ec83b69a1e4347748cea25ed73e058a5.png_pic_center]

请求地址是`localhost`，端口是80，就被`windows`上安装的`Nginx`服务给接收到了。然后代理给了`OpenResty`集群：

![在这里插入图片描述][c7666651686c48a189237e32f4cb953f.png_pic_center]

我们需要在`OpenResty`中编写业务，查询商品数据并返回到浏览器。

但是这次，我们先在`OpenResty`接收请求，返回假的商品数据。

#### 1.2. `OpenResty`监听请求 ####

`OpenResty`的很多功能都依赖于其目录下的`Lua`库，需要在`nginx.conf`中指定依赖库的目录，并导入依赖：

1）添加对`OpenResty`的`Lua`模块的加载

修改`/usr/local/openresty/nginx/conf/nginx.conf`文件，在其中的`http`下面，添加下面代码：

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

2）监听`/api/item`路径

修改`/usr/local/openresty/nginx/conf/nginx.conf`文件，在`nginx.conf`的`server`下面，添加对`/api/item`这个路径的监听：

location  /api/item {
        # 默认的响应类型
        default_type application/json;
        # 响应结果由lua/item.lua文件来决定
        content_by_lua_file lua/item.lua;
    }

这个监听，就类似于`SpringMVC`中的`@GetMapping("/api/item")`做路径映射。

而`content_by_lua_file lua/item.lua`则相当于调用`item.lua`这个文件，执行其中的业务，把结果返回给用户。相当于`java`中调用`service`。

#### 1.3. 编写`item.lua` ####

1）在`/usr/loca/openresty/nginx`目录创建文件夹：`lua`

![在这里插入图片描述][8ad75d76f654456fb1b0ca0496f64e71.png_pic_center]

2）在`/usr/loca/openresty/nginx/lua`文件夹下，新建文件：`item.lua`

![在这里插入图片描述][814ff690e0c74b36bb2e98927248de36.png_pic_center]

3）编写`item.lua`，返回假数据

`item.lua`中，利用`ngx.say()`函数返回数据到`Response`中

ngx.say('{"id":10001,"name":"SALSA AIR","title":"RIMOWA 21寸托运箱拉杆箱 SALSA AIR系列果绿色 820.70.36.4","price":17900,"image":"https://m.360buyimg.com/mobilecms/s720x720_jfs/t6934/364/1195375010/84676/e9f2c55f/597ece38N0ddcbc77.jpg!q70.jpg.webp","category":"拉杆箱","brand":"RIMOWA","spec":"","status":1,"createTime":"2019-04-30T16:00:00.000+00:00","updateTime":"2019-04-30T16:00:00.000+00:00","stock":2999,"sold":31290}')

4）重新加载配置

nginx -s reload

刷新商品页面：`http://localhost/item.html?id=1001`，即可看到效果：

![在这里插入图片描述][6290ccc8b6404c1d9504b0abf097f7b0.png_pic_center]

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

我们在`OpenResty`接收前端请求，但是返回的是假数据。

要返回真实数据，必须根据前端传递来的商品`id`，查询商品信息才可以。

那么如何获取前端传递的商品参数呢？

#### 2.1. 获取参数的`API` ####

`OpenResty`中提供了一些`API`用来获取不同类型的前端请求参数：

![在这里插入图片描述][af75fbb1bdd14a8aa58dbedab06abdaf.png_pic_center]

#### 2.2. 获取参数并返回 ####

在前端发起的`ajax`请求如图：

![在这里插入图片描述][bf6bbd14d1384bd0ab2375b020720d5d.png_pic_center]

可以看到商品`id`是以路径占位符方式传递的，因此可以利用正则表达式匹配的方式来获取`ID`

1）获取商品`id`

修改`/usr/loca/openresty/nginx/nginx.conf`文件中监听`/api/item`的代码，利用正则表达式获取`ID`：

location ~ /api/item/(\d+) {
        # 默认的响应类型
        default_type application/json;
        # 响应结果由lua/item.lua文件来决定
        content_by_lua_file lua/item.lua;
    }

2）拼接`ID`并返回

修改`/usr/loca/openresty/nginx/lua/item.lua`文件，获取`id`并拼接到结果中返回：

-- 获取商品id
    local id = ngx.var[1]
    -- 拼接并返回
    ngx.say('{"id":' .. id .. ',"name":"SALSA AIR","title":"RIMOWA 21寸托运箱拉杆箱 SALSA AIR系列果绿色 820.70.36.4","price":17900,"image":"https://m.360buyimg.com/mobilecms/s720x720_jfs/t6934/364/1195375010/84676/e9f2c55f/597ece38N0ddcbc77.jpg!q70.jpg.webp","category":"拉杆箱","brand":"RIMOWA","spec":"","status":1,"createTime":"2019-04-30T16:00:00.000+00:00","updateTime":"2019-04-30T16:00:00.000+00:00","stock":2999,"sold":31290}')

3）重新加载并测试

运行命令以重新加载`OpenResty`配置：

nginx -s reload

刷新页面可以看到结果中已经带上了`ID`：

![在这里插入图片描述][6d61899349fb434b9d061b687ffc4371.png_pic_center]

### 3. 查询`Tomcat` ###

拿到商品`ID`后，本应去缓存中查询商品信息，不过目前我们还未建立`nginx`、`redis`缓存。因此，这里我们先根据商品`id`去`tomcat`查询商品信息。我们实现如图部分：

![在这里插入图片描述][2ee5082d676a474aafca2f1d0c1dd5d8.png_pic_center]

需要注意的是，我们的`OpenResty`是在虚拟机，`Tomcat`是在`Windows`电脑上。两者`IP`一定不要搞错了。

![在这里插入图片描述][b398cad86bbb4cea9f5c0fc76098c6c0.png_pic_center]

#### 3.1. 发送`http`请求的`API` ####

`nginx`提供了内部`API`用以发送`http`请求：

local resp = ngx.location.capture("/path",{
        
        method = ngx.HTTP_GET,   -- 请求方式
        args = {
        a=1,b=2},  -- get方式传参数
    })

返回的响应内容包括：

*  `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; 
     }

原理如图：

![在这里插入图片描述][dfbad27375114062b1ea94939e746ff4.png_pic_center]

#### 3.2. 封装`http`工具 ####

下面，我们封装一个发送`Http`请求的工具，基于`ngx.location.capture`来实现查询`tomcat`。

1）添加反向代理，到`windows`的`Java`服务

因为`item-service`中的接口都是`/item`开头，所以我们监听`/item`路径，代理到`windows`上的`tomcat`服务。

修改 `/usr/local/openresty/nginx/conf/nginx.conf`文件，添加一个`location`：

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

以后，只要我们调用`ngx.location.capture("/item")`，就一定能发送请求到`windows`的`tomcat`服务。

2）封装工具类

之前我们说过，`OpenResty`启动时会加载以下两个目录中的工具文件：

![在这里插入图片描述][0d60281919684c8486cc661ed3c1e255.png_pic_center]

所以，自定义的`http`工具也需要放到这个目录下。

在`/usr/local/openresty/lualib`目录下，新建一个`common.lua`文件：

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请求查询失败, path: ", path , ", args: ", args)
            ngx.exit(404)
        end
        return resp.body
    end
    -- 将方法导出
    local _M = {
          
        read_http = read_http
    }  
    return _M

这个工具将`read_http`函数封装到`_M`这个`table`类型的变量中，并且返回，这类似于导出。

使用的时候，可以利用`require('common')`来导入该函数库，这里的`common`是函数库的文件名。

3）实现商品查询

最后，我们修改`/usr/local/openresty/lua/item.lua`文件，利用刚刚封装的函数库实现对`tomcat`的查询：

-- 引入自定义common工具模块，返回值是common中返回的 _M
    local common = require("common")
    -- 从 common中获取read_http这个函数
    local read_http = common.read_http
    -- 获取路径参数
    local id = ngx.var[1]
    -- 根据id查询商品
    local itemJSON = read_http("/item/".. id, nil)
    -- 根据id查询商品库存
    local itemStockJSON = read_http("/item/stock/".. id, nil)

这里查询到的结果是`json`字符串，并且包含商品、库存两个`json`字符串，页面最终需要的是把两个`json`拼接为一个`json`：

![在这里插入图片描述][3d9b3c2881ef41fe88a2aa407552e09b.png_pic_center]

这就需要我们先把`JSON`变为`lua`的`table`，完成数据整合后，再转为`JSON`。

#### 3.3. `CJSON`工具类 ####

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

官方地址： [https://github.com/openresty/lua-cjson/][https_github.com_openresty_lua-cjson]

1）引入`cjson`模块：

local cjson = require "cjson"

2）序列化：

local obj = {
        
        name = 'jack',
        age = 21
    }
    -- 把 table 序列化为 json
    local json = cjson.encode(obj)

3）反序列化：

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

#### 3.4. 实现`Tomcat`查询 ####

下面，我们修改之前的`item.lua`中的业务，添加`json`处理功能：

-- 导入common函数库
    local common = require('common')
    local read_http = common.read_http
    -- 导入cjson库
    local cjson = require('cjson')
    
    -- 获取路径参数
    local id = ngx.var[1]
    -- 根据id查询商品
    local itemJSON = read_http("/item/".. id, nil)
    -- 根据id查询商品库存
    local itemStockJSON = 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
    
    -- 把item序列化为json 返回结果
    ngx.say(cjson.encode(item))

#### 3.5. 基于`ID`负载均衡 ####

刚才的代码中，我们的`tomcat`是单机部署。而实际开发中，`tomcat`一定是集群模式：

![在这里插入图片描述][f8f0d148661c4afaa78eac47fe92c554.png_pic_center]

因此，`OpenResty`需要对`tomcat`集群做负载均衡。

而默认的负载均衡规则是轮询模式，当我们查询`/item/10001`时：

*  第一次会访问8081端口的`tomcat`服务，在该服务内部就形成了`JVM`进程缓存
 *  第二次会访问8082端口的`tomcat`服务，该服务内部没有`JVM`缓存（因为`JVM`缓存无法共享），会查询数据库
 *  …

你看，因为轮询的原因，第一次查询8081形成的`JVM`缓存并未生效，直到下一次再次访问到8081时才可以生效，缓存命中率太低了。

怎么办？

如果能让同一个商品，每次查询时都访问同一个`tomcat`服务，那么`JVM`缓存就一定能生效了。

也就是说，我们需要根据商品`id`做负载均衡，而不是轮询。

##### 1）原理 #####

`nginx`提供了基于请求路径做负载均衡的算法：

`nginx`根据请求路径做`hash`运算，把得到的数值对`tomcat`服务的数量取余，余数是几，就访问第几个服务，实现负载均衡。

例如：

*  我们的请求路径是 `/item/10001`
 *  `tomcat`总数为2台（8081、8082）
 *  对请求路径`/item/1001`做`hash`运算求余的结果为1
 *  则访问第一个`tomcat`服务，也就是8081

只要`id`不变，每次`hash`运算结果也不会变，那就可以保证同一个商品，一直访问同一个`tomcat`服务，确保`JVM`缓存生效。

##### 2）实现 #####

修改`/usr/local/openresty/nginx/conf/nginx.conf`文件，实现基于`ID`做负载均衡。

首先，定义`tomcat`集群，并设置基于路径做负载均衡：

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

然后，修改对`tomcat`服务的反向代理，目标指向`tomcat`集群：

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

重新加载`OpenResty`

nginx -s reload

##### 3）测试 #####

启动两台`tomcat`服务：

![在这里插入图片描述][a3a6065b85fb4214ade93396cd754414.png_pic_center]

同时启动：

![在这里插入图片描述][76ada5e4f1ae468493d3221613638233.png_pic_center]

清空日志后，再次访问页面，可以看到不同`id`的商品，访问到了不同的`tomcat`服务：

![在这里插入图片描述][23bf1176098c4bafaaced51fa4631b67.png_pic_center]

![在这里插入图片描述][851b7c451413423a8d00e2bd48245786.png_pic_center]

### 4. `Redis`缓存预热 ###

`Redis`缓存会面临冷启动问题：

**冷启动**：服务刚刚启动时，`Redis`中并没有缓存，如果所有商品数据都在第一次查询时添加缓存，可能会给数据库带来较大压力。

**缓存预热**：在实际开发中，我们可以利用大数据统计用户访问的热点数据，在项目启动时将这些热点数据提前查询并保存到`Redis`中。

我们数据量较少，并且没有数据统计相关功能，目前可以在启动时将所有数据都放入缓存中。

1）利用`Docker`安装`Redis`

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

2）在`item-service`服务中引入`Redis`依赖

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

3）配置`Redis`地址

spring:
      redis:
        host: 192.168.150.101

4）编写初始化类

缓存预热需要在项目启动时完成，并且必须是拿到`RedisTemplate`之后。

这里我们利用`InitializingBean`接口来实现，因为`InitializingBean`可以在对象被`Spring`创建并且成员变量全部注入后执行。

package com.dcxuexi.item.config;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.dcxuexi.item.pojo.Item;
    import com.dcxuexi.item.pojo.ItemStock;
    import com.dcxuexi.item.service.IItemService;
    import com.dcxuexi.item.service.IItemStockService;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Component;
    
    import java.util.List;
    
    @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);
            }
        }
    }

### 5. 查询`Redis`缓存 ###

现在，`Redis`缓存已经准备就绪，我们可以再`OpenResty`中实现查询`Redis`的逻辑了。如下图红框所示：

![在这里插入图片描述][f42851a3df244f03a7f6762a485fb29f.png_pic_center]

当请求进入`OpenResty`之后：

*  优先查询`Redis`缓存
 *  如果`Redis`缓存未命中，再查询`Tomcat`

#### 5.1. 封装`Redis`工具 ####

`OpenResty`提供了操作`Redis`的模块，我们只要引入该模块就能直接使用。但是为了方便，我们将`Redis`操作封装到之前的`common.lua`工具库中。

修改`/usr/local/openresty/lualib/common.lua`文件：

1）引入`Redis`模块，并初始化`Redis`对象

-- 导入redis
    local redis = require('resty.redis')
    -- 初始化redis
    local red = redis:new()
    red:set_timeouts(1000, 1000, 1000)

2）封装函数，用来释放`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

3）封装函数，根据`key`查询`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

4）导出

-- 将方法导出
    local _M = {
          
        read_http = read_http,
        read_redis = read_redis
    }  
    return _M

完整的`common.lua`：

-- 导入redis
    local redis = require('resty.redis')
    -- 初始化redis
    local red = redis:new()
    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是查询的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
    
    -- 封装函数，发送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,
        read_redis = read_redis
    }  
    return _M

#### 5.2. 实现`Redis`查询 ####

接下来，我们就可以去修改`item.lua`文件，实现对`Redis`的查询了。

查询逻辑是：

*  根据`id`查询`Redis`
 *  如果查询失败则继续查询`Tomcat`
 *  将查询结果返回

1）修改`/usr/local/openresty/lua/item.lua`文件，添加一个查询函数：

-- 导入common函数库
    local common = require('common')
    local read_http = common.read_http
    local read_redis = common.read_redis
    -- 封装查询函数
    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

2）而后修改商品查询、库存查询的业务：

![在这里插入图片描述][dd10b16e44aa4ec19fb4b7dfa7577663.png_pic_center]

3）完整的`item.lua`代码：

-- 导入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))

### 6. `Nginx`本地缓存 ###

现在，整个多级缓存中只差最后一环，也就是`nginx`的本地缓存了。如图：

#### 6.1. 本地缓存`API` ####

`OpenResty`为`Nginx`提供了 **`shard dict`** 的功能，可以在`nginx`的多个`worker`之间共享数据，实现缓存功能。![在这里插入图片描述][83b6dd8b68ab4f5dbd0711f9e815db6d.png_pic_center]

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

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

2）操作共享字典：

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

#### 6.2. 实现本地缓存查询 ####

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

-- 导入共享词典，本地缓存
    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`函数：

![在这里插入图片描述][732b6e39f5c9427d85b1bb88070145f1.png_pic_center]

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

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

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

3）完整的item.lua文件：

-- 导入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))

[c54231bb7ec849c4a0dd323d3f5bd289.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/e6830d9f7433437580d8124440b8f464.png
[ec83b69a1e4347748cea25ed73e058a5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/fb459f7039cc42f29ff5ff3f31aaa1ad.png
[c7666651686c48a189237e32f4cb953f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/cd4aa3565e834f8a88305463691f4eb0.png
[8ad75d76f654456fb1b0ca0496f64e71.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/75fa65059bca4ad59e5a248256b19092.png
[814ff690e0c74b36bb2e98927248de36.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/15eff8b5b4b04b7da026372d260c5149.png
[6290ccc8b6404c1d9504b0abf097f7b0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/cb246e53729c4442af5c4f69f9214c89.png
[af75fbb1bdd14a8aa58dbedab06abdaf.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/9a1b638f692040d5b99aece72832ab83.png
[bf6bbd14d1384bd0ab2375b020720d5d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/06b6dbe031664f4f8575829b94c441b4.png
[6d61899349fb434b9d061b687ffc4371.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/68b20422518244a0bfae0ee144d941d9.png
[2ee5082d676a474aafca2f1d0c1dd5d8.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/e0289f4ad1874f95867771a5f1f63e15.png
[b398cad86bbb4cea9f5c0fc76098c6c0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/ea240f05b4f741b99e7ec25a6a19b75b.png
[dfbad27375114062b1ea94939e746ff4.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/6ac4a079a2c0462aaf7d70b48bd5f728.png
[0d60281919684c8486cc661ed3c1e255.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/d40d01bf6db84a0ea8d48dd2b9ca68b6.png
[3d9b3c2881ef41fe88a2aa407552e09b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/82b83e061dc243a88808a18591bbbc02.png
[https_github.com_openresty_lua-cjson]: https://github.com/openresty/lua-cjson/
[f8f0d148661c4afaa78eac47fe92c554.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/830854e5ce8c4bc9960497be0468e6e8.png
[a3a6065b85fb4214ade93396cd754414.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/7f152f1a6a784ac082445dd42d6eb710.png
[76ada5e4f1ae468493d3221613638233.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/998c81fd60114dd7ae9bfc0d1d12dadd.png
[23bf1176098c4bafaaced51fa4631b67.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/d874c439650d480a804414e0f3c93433.png
[851b7c451413423a8d00e2bd48245786.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/8fa98b2e0bcd4ad193857cae591c3c1a.png
[f42851a3df244f03a7f6762a485fb29f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/456b48341ef74cd98a2dc1ef369e40ae.png
[dd10b16e44aa4ec19fb4b7dfa7577663.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/ed48e2787301468fb36fb2e6cb0b1098.png
[83b6dd8b68ab4f5dbd0711f9e815db6d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/1176ff2db16a4db8a411b8f69bf8cd07.png
[732b6e39f5c9427d85b1bb88070145f1.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/6560f0ecedd04bf392f5a51e3bb00144.png