aizuda-cache

aizuda:
  redis:
    enable: true
    mode: single # 可选值：single, cluster, sentinel
    host: localhost
    port: 6379
    password: yourPassword
    database: 0
    # 集群模式
    #      nodes:
    #        - node1:6379
    #        - node2:6379
    # 哨兵模式
    #      sentinelMaster: mymaster
    #      sentinels:
    #        - 127.0.0.1:26379
    #        - 127.0.0.1:26380
    cacheConfigs:
      defaultCache:
        ttl: 600 # 10 分钟
        keyPrefix: "default:"
      myCache:
        ttl: 60 # 1 分钟
        keyPrefix: "my:"

// 需要引入依赖 implementation("org.springframework.boot:spring-boot-starter-data-redis")
@Service
public class MyService {
    @Resource
    private RedisTemplateCache redisTemplateCache;

    @Cacheable(value = "myCache", key = "#id")
    public String getDataFromRedis(Long id) {
        // 不使用注解 @Cacheable 调用 redisTemplateCache 操作
        return "Some data";
    }
}

@Bean
public CacheErrorHandler errorHandler() {
    return new CacheErrorHandler() {
        ...
    };
}

import java.util.concurrent.TimeUnit;

// 需要引入依赖 implementation("com.github.ben-manes.caffeine:caffeine")
public class UserService {

    // 最多缓存 500 个用户，过期时间为 10 分钟
    private static final LocalCacheCaffeine<String, String> userCache = new LocalCacheCaffeine<>(500, 10, TimeUnit.MINUTES);

    public String getUserInfo(String userId) {
        // 尝试从缓存中获取用户信息
        String userInfo = userCache.get(userId);

        if (userInfo == null) {
            // 模拟从数据库加载用户数据
            userInfo = loadUserFromDb(userId);
            // 缓存加载的数据
            userCache.set(userId, userInfo);
        }

        return userInfo;
    }

    private String loadUserFromDb(String userId) {
        // 模拟从数据库加载用户信息
        System.out.println("Loading user from database...");
        return "User-" + userId;
    }

    public static void main(String[] args) {
        UserService service = new UserService();

        // 第一次访问时，缓存为空，从数据库加载
        System.out.println(service.getUserInfo("user1"));

        // 第二次访问时，从缓存获取
        System.out.println(service.getUserInfo("user1"));
    }
}

import com.github.benmanes.caffeine.cache.CacheLoader;
import com.github.benmanes.caffeine.cache.LoadingCache;

public class CaffeineUtilWithLoader {

    private LoadingCache<String, String> cache;

    public CaffeineUtilWithLoader() {
        cache = Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .maximumSize(1000)
                .build(new CacheLoader<String, String>() {
                    @Override
                    public String load(String key) throws Exception {
                        // 自动加载逻辑，这里模拟从数据库加载
                        return loadFromDatabase(key);
                    }
                });
    }

    // 获取缓存，如果缓存中不存在则自动加载
    public String get(String key) {
        try {
            return cache.get(key);
        } catch (Exception e) {
            return null;
        }
    }

    private String loadFromDatabase(String key) {
        // 模拟从数据库加载数据
        System.out.println("Loading data from database for key: " + key);
        return "Value-for-" + key;
    }
}