@Test
void testBasicOps(）{
	//创建缓存对象
	Cache<String，String> cache =Caffeine.newBuilder().build();
	//存数据
	cache.put（"food", "螺蛳粉"）；
	//取数据，不存在则返回null
	String food=cache.getIfPresent("gf");
	System.out.println("food ="+food);
	//取数据，不存在则去数据库查询
	String defaultFood=cache.get（"defaultFood", key->{
		//这里可以去数据库根据key查询value
		return "巧克力";
	);
	System.out.println("defaultGF="+defaultFood);
}

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

import com.github.ben-manes.caffeine.cache.Cache; import com.github.ben-manes.caffeine.cache.Caffeine; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration;

@Configuration public class CaffeineConfig {
    // 商品信息缓存：初始存100条，最多存10000条
    @Bean
    public Cache<Long, Item> itemCache() {
        return Caffeine.newBuilder()
                .initialCapacity(100)  // 初始容量
                .maximumSize(10000)    // 最大容量（超了就删旧数据）
                .build();
    }
    // 库存信息缓存：同上
    @Bean
    public Cache<Long, ItemStock> stockCache() {
        return Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(10000)
                .build();
    } }

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import com.github.ben-manes.caffeine.cache.Cache;

@RestController
public class ItemController {
    // 注入配置好的缓存
    @Autowired
    private Cache<Long, Item> itemCache;
    @Autowired
    private Cache<Long, ItemStock> stockCache;
    // 查商品信息：先查缓存，没再查数据库
    @GetMapping("/item/{id}")
    public Item findById(@PathVariable Long id) {
        // 缓存里有就直接拿，没有就执行后面的“查数据库”逻辑
        return itemCache.get(id, key -> itemService.query()
                .ne("status", 3)  // 排除下架商品
                .eq("id", key)     // 按ID查
                .one());           // 查一条
    }
    // 查库存：逻辑同上
    @GetMapping("/item/stock/{id}")
    public ItemStock findStockById(@PathVariable Long id) {
        return stockCache.get(id, key -> stockService.getById(key));
    }
}

Cache<String, String> cache = Caffeine.newBuilder()
        // 设置缓存大小上限为 1
        .maximumSize(1)
        .build();

Cache<String, String> cache = Caffeine.newBuilder()
        .expireAfterWrite(Duration.ofSeconds(10))  // 从最后一次存数据开始算，10秒过期
        .build();

http {
    # 加载Lua模块
    lua_package_path "/usr/local/openresty/lualib/?.lua;;";
    lua_package_cpath "/usr/local/openresty/lualib/?.so;;";
    # 开启Nginx本地缓存（给缓存起个名：item_cache，大小150M）
    lua_shared_dict item_cache 150m;    
    # 其他配置...
}

server {
    listen 8081;  # 端口
    server_name localhost;
    # 用户请求/api/item/xxx时，用Lua脚本处理
    location ~ /api/item/(\d+) {  # 正则匹配：比如/api/item/1001，\d+就是商品ID
        default_type application/json;  # 返回JSON格式
        content_by_lua_file lua/item.lua;  # 用lua/item.lua脚本处理
    }
}

@Component
public class RedisPreheat implements InitializingBean {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private ItemService itemService;

    // 服务启动后自动执行这个方法（InitializingBean的特性）
    @Override
    public void afterPropertiesSet() throws Exception {
        // 1. 查所有商品
        List<Item> itemList = itemService.list();
        // 2. 存到Redis
        for (Item item : itemList) {
            String key = "item:id:" + item.getId();
            String json = JSON.toJSONString(item);
            redisTemplate.opsForValue().set(key, json);
        }
    }
}

http {
    # Tomcat集群：用请求URL的hash值分配，同一URL永远到同一台Tomcat
    upstream tomcat-cluster {
        hash $request_uri;  # 关键：按请求路径hash
        server 192.168.150.1:8081;  # Tomcat 1
        server 192.168.150.1:8082;  # Tomcat 2
    }

    # 反向代理到Tomcat集群
    location /item {
        proxy_pass http://tomcat-cluster;
    }
}

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

canal:
  destination: heima  # Canal实例名（要和Canal服务配置一致）
  server: 192.168.150.101:11111  # Canal服务地址

// 监听tb_item表（商品表）的变化
@CanalTable("tb_item")
@Component
public class ItemCanalHandler implements EntryHandler<Item> {
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private Cache<Long, Item> itemCache;

    // 数据库新增商品时执行
    @Override
    public void insert(Item item) {
        // 更新JVM进程缓存
        itemCache.put(item.getId(), item);
        // 更新Redis
        redisTemplate.opsForValue().set("item:id:" + item.getId(), JSON.toJSONString(item));
    }

    // 数据库修改商品时执行
    @Override
    public void update(Item oldItem, Item newItem) {
        itemCache.put(newItem.getId(), newItem);
        redisTemplate.opsForValue().set("item:id:" + newItem.getId(), JSON.toJSONString(newItem));
    }

    // 数据库删除商品时执行
    @Override
    public void delete(Item item) {
        itemCache.invalidate(item.getId());  // 删进程缓存
        redisTemplate.delete("item:id:" + item.getId());  // 删Redis
    }
}