Redis13-多级缓存

已于 2024-08-12 20:30:40 修改
阅读量319 收藏 5
点赞数 7
分类专栏： Redis 文章标签： 缓存 redis
于 2024-08-12 20:30:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73902080/article/details/141132844
版权

目录

概述

JVM进程缓存

Caffeine

实现进程缓存

Lua语法

初识Lua

变量和循环

Lua的数据类型

声明变量

循环

条件控制、函数

函数

条件控制

实现多级缓存

安装OpenResty

OpenResty快速入门

请求参数处理

查询Tomcat

发送http请求的API

封装http工具

CJSON工具类

实现Tomcat查询

基于ID负载均衡

Redis缓存预热

查询Redis缓存

Nginx本地缓存

概述

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

  • 请求要经过Tomcat处理，Tomcat的性能成为整个系统的瓶颈
  • Redis缓存失效时，会对数据库产生冲击

多级缓存就是充分利用请求处理的每个环节，分别添加缓存，减轻Tomcat压力，提升服务性能：

  • 浏览器访问静态资源时，优先读取浏览器本地缓存
  • 访问非静态资源（ajax查询数据）时，访问服务端
  • 请求到达Nginx后，优先读取Nginx本地缓存
  • 如果Nginx本地缓存未命中，则去直接查询Redis（不经过Tomcat）
  • 如果Redis查询未命中，则查询Tomcat
  • 请求进入Tomcat后，优先查询JVM进程缓存
  • 如果JVM进程缓存未命中，则查询数据库

用作缓存的Nginx是业务Nginx， 需要部署为集群，再有专门的Nginx用来做反向代理，Tomcat也要部署为集群模式：

多级缓存的关键有两个：

  1. 在nginx中编写业务，实现nginx本地缓存、Redis、Tomcat的查询
  2. 在Tomcat中实现JVM进程缓存

JVM进程缓存

Caffeine

缓存在日常开发中启动至关重要的作用，由于是存储在内存中，数据的读取速度是非常快的，能大量减少对数据库的访问，减少数据库的压力

缓存分为两类：

  1. 分布式缓存，例如Redis：

    • 优点：存储容量更大、可靠性更好、可以在集群间共享

    • 缺点：访问缓存有网络开销

    • 场景：缓存数据量较大、可靠性要求较高、需要在集群间共享

  2. 进程本地缓存，例如HashMap、GuavaCache：

    • 优点：读取本地内存，没有网络开销，速度更快

    • 缺点：存储容量有限、可靠性较低、无法共享

    • 场景：性能要求较高，缓存数据量较小

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

GitHub地址：https://github.com/ben-manes/caffeine

缓存使用的基本API：

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

Caffeine提供了三种缓存驱逐策略：

  • 基于容量：设置缓存的数量上限
// 创建缓存对象
Cache<String, String> cache = Caffeine.newBuilder()
    .maximumSize(1) // 设置缓存大小上限为 1
    .build();
  • 基于时间：设置缓存的有效时间
// 创建缓存对象
Cache<String, String> cache = Caffeine.newBuilder()
    // 设置缓存有效期为 10 秒，从最后一次写入开始计时 
    .expireAfterWrite(Duration.ofSeconds(10)) 
    .build();
  • 基于引用：设置缓存为软引用或弱引用，利用GC来回收缓存数据，性能较差，不建议使用

注意：在默认情况下，当一个缓存元素过期的时候，Caffeine不会自动立即将其清理和驱逐，而是在一次读或写操作后或者在空闲时间完成对失效数据的驱逐

实现进程缓存

利用Caffeine实现下列需求：

  • 给根据id查询商品的业务添加缓存，缓存未命中时查询数据库

  • 给根据id查询商品库存的业务添加缓存，缓存未命中时查询数据库

  • 缓存初始大小为100

  • 缓存上限为10000

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.heima.item.pojo.Item;
import com.heima.item.pojo.ItemStock;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CaffeineConfig {

    @Bean
    public Cache<Long, Item> itemCache(){
        return Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(10_000)
                .build();
    }

    @Bean
    public Cache<Long, ItemStock> stockCache(){
        return Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(10_000)
                .build();
    }
}
@RestController
@RequestMapping("item")
public class ItemController {

    @Autowired
    private IItemService itemService;
    @Autowired
    private IItemStockService stockService;

    @Autowired
    private Cache<Long, Item> itemCache;
    @Autowired
    private Cache<Long, ItemStock> stockCache;
    
    // ...其它略
    
    @GetMapping("/{id}")
    public Item findById(@PathVariable("id") Long id) {
        return itemCache.get(id, key -> itemService.query()
                .ne("status", 3).eq("id", key)
                .one()
        );
    }

    @GetMapping("/stock/{id}")
    public ItemStock findStockById(@PathVariable("id") Long id) {
        return stockCache.get(id, key -> stockService.getById(key));
    }
}

Lua语法

初识Lua

Lua 是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放，其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能

官网：The Programming Language Lua

Lua经常嵌入到C语言开发的程序中，例如游戏开发、游戏插件等

Nginx本身也是C语言开发，因此也允许基于Lua做拓展

CentOS7默认已经安装了Lua语言环境，所以可以直接运行Lua代码

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

2）添加下面的内容

print("Hello World!")

3）运行

 

变量和循环

Lua的数据类型

Lua提供了type()函数来判断一个变量的数据类型：  

声明变量

Lua声明变量的时候无需指定数据类型，而是用local来声明变量为局部变量：

-- 声明字符串，可以用单引号或双引号
local str = 'hello'
-- 字符串拼接可以使用 ..
local str2 = 'hello' .. 'world'
-- 声明数字
local num = 21
-- 声明布尔类型
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：

-- 访问table，用key访问
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

遍历table：

-- 声明map，也就是table
local map = {name='Jack', age=21}
-- 遍历table
for key,value in pairs(map) do
   print(key, value) 
end

条件控制、函数

函数

定义函数：

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

例如，定义一个函数，用来打印数组：

function printArr(arr)
    for index, value in ipairs(arr) do
        print(value)
    end
end

条件控制

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

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

需求：

自定义一个函数，可以打印table，当参数为nil时，打印错误信息

function printArr(arr)
    if not arr then
        print('数组不能为空！')
    end
    for index, value in ipairs(arr) do
        print(value)
    end
end

实现多级缓存

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

安装OpenResty

OpenResty是一个基于Nginx的高性能Web平台，用于方便地搭建能够处理超高并发、扩展性极高的动态Web应用、Web服务和动态网关

具备下列特点：

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

官方网站： 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

3.安装OpenResty

yum install -y openresty

4.安装opm工具

yum install -y openresty-opm

5. 默认情况下，OpenResty安装的目录是：/usr/local/openresty

6.配置nginx的环境变量

打开配置文件：

vi /etc/profile

在最下面加入：

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

让配置生效：

source /etc/profile

7.修改/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;
        }
    }
}

启动：

nginx

访问：

OpenResty快速入门

多级缓存架构：

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

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

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

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

5）编写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}')

6）重新加载配置

nginx -s reload

请求参数处理

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

前端的ajax请求：

商品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）重新加载并测试

nginx -s reload

结果：

查询Tomcat

OpenResty是在虚拟机，Tomcat是在Windows电脑上

发送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; 
 }

封装http工具

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

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

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

2）封装工具类

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

 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：

需要先把JSON变为lua的table，完成数据整合后，再转为JSON  

CJSON工具类

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

官方地址： 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)

实现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))

基于ID负载均衡

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

例如：

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

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

修改/usr/local/openresty/nginx/conf/nginx.conf文件，定义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

启动两个：

不同id的商品，访问到了不同的tomcat服务：

Redis缓存预热

Redis缓存会面临冷启动问题

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

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

实现：

引入Redis依赖

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

配置Redis地址

spring:
  redis:
    host: 192.168.150.101

编写初始化类：利用InitializingBean接口来实现，因为InitializingBean可以在对象被Spring创建并且成员变量全部注入后执行

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.heima.item.pojo.Item;
import com.heima.item.pojo.ItemStock;
import com.heima.item.service.IItemService;
import com.heima.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);
        }
    }
}

查询Redis缓存

当请求进入OpenResty之后：

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

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

查询逻辑：

  • 根据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）修改商品查询、库存查询的业务：  

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

Nginx本地缓存

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

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')

实现：

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

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

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))
Onlooker129
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis高级篇-多级缓存
无私のZ的博客
09-13 1795
Redis高级篇-多级缓存
Redis --- 多级缓存
乌云的博客
05-06 1240
传统的缓存策略一般是请求到达Tomcat后，先查询Redis，如果未命中则查询数据库，如图： 存在下面的问题：多级缓存就是充分利用请求处理的每个环节，分别添加缓存，减轻Tomcat压力，提升服务性能：在多级缓存架构中，Nginx内部需要编写本地缓存查询、Redis查询、Tomcat查询的业务逻辑，因此这样的nginx服务不再是一个反向代理服务器，而是一个编写业务的Web服务器了。因此这样的业务Nginx服务也需要搭建集群来提高并发，再有专门的nginx服务来做反向代理，如图： 另外，我们的Tomcat服务将
Redis高级-多级缓存
m0_74221471的博客
11-18 102
redis多级缓存
Redis高级篇 - 多级缓存
十二间记，知不足而奋斗，望远山而前行。千里不辞行路远，时光早晚到天涯。
05-31 622
Redis多级缓存
微服务高级篇（四）：多级缓存：Nginx本地缓存 --- Redis缓存 --- 进程缓存
shendaiyan的博客
03-25 1481
修改nginx.conf：注意events {http {# lua 模块.lua;;# c模块.so;;server {# 监听反向代理来的请求：/api/item# 响应类型，这里返回json# 响应数据由 lua/item.lua这个文件来决定root html;root html;修改item.lua获取id=10003的参数，将10003使用..拼接并返回给页面-- 获取路径参数-- 返回结果。
Redis-Redis多级缓存架构（实践）
weixin_43874650的博客
11-27 775
4.分布式读写锁的机制（读读共享，读写互斥，写写互斥）读写锁底层实现的是读写操作都是抢同一把锁，已控制拿锁的顺序。若是读读操作，则底层实现的是可重入锁机制。1.基于缓存，对热点数据进行刷新过期时间，以实现。2.前端有处理失效的情况，那么可考虑使用。如：前端缓存，本地缓存，redis缓存。1.当热点数据突然迸发时，容易出现。3.可对某些不重要的服务可进行做。3.使用分布式读写锁，可解决。“数据库与缓存双写不一致”“热点数据进行缓存重建”场景，则可通过前端进行。
Redis进阶学习08--多级缓存
m0_53157173的博客
05-10 1169
Redis进阶学习08--多级缓存什么是多级缓存JVM进程缓存环境准备docker安装mysqldocker安装nginx反向代理初识Caffeine实现JVM进程缓存需求实现Lua语法入门初识LuaHelloWorld变量和循环Lua的数据类型声明变量循环条件控制、函数函数条件控制实现多级缓存原始方式安装OpenResty安装开发库安装OpenResty仓库安装OpenResty安装opm工具目录结构配置nginx的环境变量启动和运行docker方式安装OpenResty快速入门反向代理流程OpenRes
Redis -- 缓存雪崩问题
ros275229的博客
04-05 768
Redis -- 缓存雪崩问题
redis总结_多级缓存
m0_45364328的博客
08-01 511
传统的缓存策略一般是请求到达Tomcat后，先查询Redis，如果未命中则查询数据库，如图存在下面的问题•请求要经过Tomcat处理，Tomcat的性能成为整个系统的瓶颈•Redis缓存失效时，会对数据库产生冲击浏览器访问静态资源时，优先读取浏览器本地缓存访问非静态资源（ajax查询数据）时，访问服务端请求到达Nginx后，优先读取Nginx本地缓存如果Nginx本地缓存未命中，则去直接查询Redis（不经过Tomcat）如果Redis查询未命中，则查询Tomcat。......
Redis--缓存击穿、缓存穿透、缓存雪崩
IT深耕十余载，大道之简
08-06 1038
Redis的缓存击穿、缓存穿透和缓存雪崩是Redis缓存使用中常见的三种问题，它们对系统的性能和稳定性有着显著的影响。以下是对这三种问题的详细解析及相应的解决方案。
redis多级缓存搭建资料
05-31
总结，Redis多级缓存的搭建涉及到多个层面，包括缓存设计、数据同步策略、一致性管理以及高可用性。理解这些知识点，能帮助你构建高效、稳定的缓存系统，优化应用程序的性能。通过学习提供的资料，你将能深入理解并...
微服务 - 多级缓存相关资料及软件
04-02
多级缓存是指在一个系统中设置多个不同层次的高速缓存，通常由近似于内存访问速度的高速缓存（如CPU缓存）和较慢但容量较大的二级缓存（如Redis或Memcached）组成。这种设计允许快速访问常用数据，减少对主存储器...
Redis高级使用-缓存架构、缓存穿透、缓存雪崩
12-26
在Redis中，缓存架构可以分为多级缓存，包括Redis自身的缓存、内存缓存、磁盘缓存等。 缓存穿透是指客户端向缓存系统请求数据，但是缓存系统中没有该数据，于是缓存系统向后端系统请求数据，这样会对后端系统造成...
redis实战-redis-action.zip
11-07
Redis是一款高性能的键值对数据库，常用于缓存、消息队列、计数器等多种场景。在"redis实战-redis-action.zip"这个压缩包中，很可能是包含了一个关于Redis实际应用的项目或教程，名为"redis-action-master"。在这个...
Java编程代码-多级缓存-源代码+讲义+资料
10-26
在Java编程中，多级缓存通常指的是在应用层面构建的一种优化策略，例如在本地内存、分布式缓存（如Redis、Memcached）和数据库之间形成的数据存储层次。 源代码部分可能包括以下几个关键组件： 1. **本地缓存**：...
Python删除lru_cache缓存
最新发布
ithongchou的博客
08-08 176
根据具体的使用场景，可以选择适合的方法来管理和清除缓存。是一个装饰器，用于添加缓存功能以提高函数的性能。如果你想清除或者删除。时，最简单的方法是直接调用。在 Python 中，
MemoryCache 缓存 实用
白高林的专栏
08-08 255
MemoryCache 缓存 实用
146. LRU 缓存
m0_63530048的博客
08-08 318
双向链表用来维护“最近最少使用”，hashmap用来比较方便的根据key取value
清除 Nuxt 状态缓存：clearNuxtState
08-07 1093
提供了一种简单而有效的方式来管理组件中的状态缓存。当你需要清除或重置状态时，这个方法将非常有用。通过上面的示例，你可以开始在你的 Nuxt 应用中使用，以确保状态的有效性和一致性。编程智域 前端至全栈交流与成长清除 Nuxt 数据缓存：clearNuxtData | cmdragon’s Blog。
redis的多级缓存
09-11
Redis的多级缓存指的是在系统中同时使用多个层次的缓存，其中Redis作为其中一级缓存的一种。在多级缓存中，Redis通常用作一个高速且可靠的缓存层，可以在内存中存储大量的数据，并提供快速的数据读取和写入操作。 具体而言，多级缓存的架构可以将数据存储在多个不同的缓存层中，以提供更好的性能和可扩展性。一种常见的多级缓存架构是将Redis与其他缓存系统（如Memcached）结合使用。在这种情况下，Redis通常用于存储较长时间的数据，而其他缓存系统则用于存储短时间内频繁访问的数据。 使用多级缓存的好处包括： 1. 提高缓存的命中率：通过将数据存储在多个缓存层中，系统可以更有效地利用缓存，减少对底层数据存储的访问次数，从而提高性能。 2. 提供更好的扩展性：如果系统需要处理更多的请求，可以增加更多的缓存层，以提供更大的缓存容量和更好的性能。 3. 提高系统的可靠性：通过将数据复制到多个缓存层，可以提高系统的可靠性，即使某一级缓存发生故障，仍然可以从其他级别的缓存中获取数据。 总而言之，Redis的多级缓存是一种使用多个缓存层来提高系统性能和可靠性的架构。它可以通过将数据存储在不同的缓存层中，以及合理配置和管理这些缓存层，来提供更好的缓存效果和系统性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值