Spring Boot 的 3 种二级缓存落地方式

springboot+mybatis+redis实现二级缓存 Mybatis提供了对缓存的支持,分为一级缓存和二级缓存,其查询顺序为:二级缓存>一级缓存->数据库,最原始是直接查询数据库,为了提高效率和节省资源,引入了一级缓存,为了进一步提高效率,引入了二级缓存。Mybatis一级缓存是sqlSession级别的缓存,缓存的数据只在sqlSession内有效。Mybatis二级缓存是mapper级别的缓存,同一个namespace公用这一个缓存,对sqlSession是共享的。 阅读详情

在高并发系统设计中,缓存是提升性能的关键策略之一。随着业务的发展,单一的缓存方案往往无法同时兼顾性能、可靠性和一致性等多方面需求。

此时,二级缓存架构应运而生,本文将介绍在Spring Boot中实现二级缓存的三种方案。

一、二级缓存概述

1.1 什么是二级缓存

二级缓存是一种多层次的缓存架构,通常由以下两个层次组成:

  • 一级缓存(本地缓存):直接在应用服务器内存中,访问速度极快,但容量有限且在分布式环境下无法共享
  • 二级缓存(分布式缓存):独立的缓存服务,如Redis或Memcached,可被多个应用实例共享,容量更大

二级缓存的工作流程通常是:先查询本地缓存,若未命中则查询分布式缓存,仍未命中才访问数据库,并将结果回填到各级缓存中。

1.2 为什么需要二级缓存

单一缓存方案存在明显局限性:

  • 仅使用本地缓存:无法在分布式环境下保持数据一致性,每个实例都需要从数据库加载数据
  • 仅使用分布式缓存:每次访问都需要网络IO,无法发挥本地缓存的性能优势

二级缓存结合了两者优势:

  • 利用本地缓存的高性能,大幅减少网络IO
  • 通过分布式缓存保证数据一致性
  • 减轻数据库压力,提高系统整体吞吐量
  • 更好的故障隔离,即使分布式缓存不可用,本地缓存仍可提供部分服务

二、Spring Cache + Redis方案

2.1 基本原理

该方案利用Spring Cache提供的缓存抽象,配合Caffeine(本地缓存)和Redis(分布式缓存)实现二级缓存。

Spring Cache提供了统一的缓存操作接口,可以通过简单的注解实现缓存功能。

2.2 实现步骤

2.2.1 添加依赖

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- 缓存支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    
    <!-- Redis支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <!-- Caffeine本地缓存 -->
    <dependency>
        <groupId>com.github.ben-manes.caffeine</groupId>
        <artifactId>caffeine</artifactId>
    </dependency>
    
    <!-- 序列化支持 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
</dependencies>

2.2.2 配置二级缓存管理器

@Configuration
@EnableCaching
public class CacheConfig {

    @Value("${spring.application.name:app}")
    private String appName;
    
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 创建Redis缓存管理器
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(getRedisCacheConfigurationWithTtl(3600)) // 默认1小时过期
                .withCacheConfiguration("userCache", getRedisCacheConfigurationWithTtl(1800)) // 用户缓存30分钟
                .withCacheConfiguration("productCache", getRedisCacheConfigurationWithTtl(7200)) // 产品缓存2小时
                .build();
        
        // 创建Caffeine缓存管理器
        CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager();
        caffeineCacheManager.setCaffeine(Caffeine.newBuilder()
                .initialCapacity(100) // 初始容量
                .maximumSize(1000) // 最大容量
                .expireAfterWrite(5, TimeUnit.MINUTES) // 写入后5分钟过期
                .recordStats()); // 开启统计
        
        // 创建二级缓存管理器
        return new LayeringCacheManager(caffeineCacheManager, redisCacheManager);
    }
    
    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(long seconds) {
        return RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(seconds))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .disableCachingNullValues()
                .computePrefixWith(cacheName -> appName + ":" + cacheName + ":");
    }
    
    // 二级缓存管理器实现
    public static class LayeringCacheManager implements CacheManager {
        
        private final CacheManager localCacheManager;
        private final CacheManager remoteCacheManager;
        private final Map<String, Cache> cacheMap = new ConcurrentHashMap<>();
        
        public LayeringCacheManager(CacheManager localCacheManager, CacheManager remoteCacheManager) {
            this.localCacheManager = localCacheManager;
            this.remoteCacheManager = remoteCacheManager;
        }
        
        @Override
        public Cache getCache(String name) {
            return cacheMap.computeIfAbsent(name, cacheName -> {
                Cache localCache = localCacheManager.getCache(cacheName);
                Cache remoteCache = remoteCacheManager.getCache(cacheName);
                return new LayeringCache(localCache, remoteCache);
            });
        }
        
        @Override
        public Collection<String> getCacheNames() {
            Set<String> names = new LinkedHashSet<>();
            names.addAll(localCacheManager.getCacheNames());
            names.addAll(remoteCacheManager.getCacheNames());
            return names;
        }
        
        // 二级缓存实现
        static class LayeringCache implements Cache {
            private final Cache localCache;
            private final Cache remoteCache;
            
            public LayeringCache(Cache localCache, Cache remoteCache) {
                this.localCache = localCache;
                this.remoteCache = remoteCache;
            }
            
            @Override
            public String getName() {
                return localCache.getName();
            }
            
            @Override
            public Object getNativeCache() {
                return this;
            }
            
            @Override
            public ValueWrapper get(Object key) {
                // 先查本地缓存
                ValueWrapper wrapper = localCache.get(key);
                if (wrapper != null) {
                    return wrapper;
                }
                
                // 本地未命中,查远程缓存
                wrapper = remoteCache.get(key);
                if (wrapper != null) {
                    Object value = wrapper.get();
                    // 回填本地缓存
                    localCache.put(key, value);
                }
                
                return wrapper;
            }
            
            @Override
            public <T> T get(Object key, Class<T> type) {
                // 先查本地缓存
                T value = localCache.get(key, type);
                if (value != null) {
                    return value;
                }
                
                // 本地未命中,查远程缓存
                value = remoteCache.get(key, type);
                if (value != null) {
                    // 回填本地缓存
                    localCache.put(key, value);
                }
                
                return value;
            }
            
            @Override
            public <T> T get(Object key, Callable<T> valueLoader) {
                // 先查本地缓存
                try {
                    T value = localCache.get(key, () -> {
                        // 本地未命中,查远程缓存
                        try {
                            return remoteCache.get(key, valueLoader);
                        } catch (Exception e) {
                            // 远程缓存未命中或异常,执行valueLoader加载数据
                            T newValue = valueLoader.call();
                            if (newValue != null) {
                                remoteCache.put(key, newValue); // 填充远程缓存
                            }
                            return newValue;
                        }
                    });
                    return value;
                } catch (Exception e) {
                    // 本地缓存异常,尝试直接读远程缓存
                    try {
                        return remoteCache.get(key, valueLoader);
                    } catch (Exception ex) {
                        if (ex instanceof RuntimeException) {
                            throw (RuntimeException) ex;
                        }
                        throw new IllegalStateException(ex);
                    }
                }
            }
            
            @Override
            public void put(Object key, Object value) {
                remoteCache.put(key, value);  // 先放入远程缓存
                localCache.put(key, value);   // 再放入本地缓存
            }
            
            @Override
            public void evict(Object key) {
                remoteCache.evict(key);  // 先清远程缓存
                localCache.evict(key);   // 再清本地缓存
            }
            
            @Override
            public void clear() {
                remoteCache.clear();  // 先清远程缓存
                localCache.clear();   // 再清本地缓存
            }
        }
    }
}

2.2.3 使用缓存注解

@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    @Cacheable(cacheNames = "userCache", key = "#id")
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    @Override
    @CachePut(cacheNames = "userCache", key = "#user.id")
    public User saveUser(User user) {
        return userRepository.save(user);
    }
    
    @Override
    @CacheEvict(cacheNames = "userCache", key = "#id")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

2.2.4 缓存同步问题

在分布式环境下,需要保证缓存一致性。我们可以通过Redis的发布订阅机制实现:

@Configuration
public class CacheEvictionConfig {

    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        return container;
    }
    
    @Bean
    public RedisCacheMessageListener redisCacheMessageListener(RedisMessageListenerContainer listenerContainer, 
                                                              CacheManager cacheManager) {
        return new RedisCacheMessageListener(listenerContainer, cacheManager);
    }
    
    // 缓存消息监听器
    public static class RedisCacheMessageListener {
        
        private static final String CACHE_CHANGE_TOPIC = "cache:changes";
        
        private final CacheManager cacheManager;
        
        public RedisCacheMessageListener(RedisMessageListenerContainer listenerContainer, CacheManager cacheManager) {
            this.cacheManager = cacheManager;
            listenerContainer.addMessageListener((message, pattern) -> {
                String body = new String(message.getBody());
                CacheChangeMessage cacheMessage = JSON.parseObject(body, CacheChangeMessage.class);
                
                // 清除本地缓存
                Cache cache = cacheManager.getCache(cacheMessage.getCacheName());
                if (cache != null) {
                    if (cacheMessage.getKey() != null) {
                        cache.evict(cacheMessage.getKey());
                    } else {
                        cache.clear();
                    }
                }
            }, new ChannelTopic(CACHE_CHANGE_TOPIC));
        }
    }
    
    @Bean
    public CacheChangePublisher cacheChangePublisher(RedisTemplate<String, String> redisTemplate) {
        return new CacheChangePublisher(redisTemplate);
    }
    
    // 缓存变更消息发布器
    public static class CacheChangePublisher {
        
        private static final String CACHE_CHANGE_TOPIC = "cache:changes";
        
        private final RedisTemplate<String, String> redisTemplate;
        
        public CacheChangePublisher(RedisTemplate<String, String> redisTemplate) {
            this.redisTemplate = redisTemplate;
        }
        
        public void publishCacheEvict(String cacheName, Object key) {
            CacheChangeMessage message = new CacheChangeMessage(cacheName, key);
            redisTemplate.convertAndSend(CACHE_CHANGE_TOPIC, JSON.toJSONString(message));
        }
        
        public void publishCacheClear(String cacheName) {
            CacheChangeMessage message = new CacheChangeMessage(cacheName, null);
            redisTemplate.convertAndSend(CACHE_CHANGE_TOPIC, JSON.toJSONString(message));
        }
    }
    
    // 缓存变更消息
    @Data
    @AllArgsConstructor
    public static class CacheChangeMessage {
        private String cacheName;
        private Object key;
    }
}

2.3 优缺点分析

优点:

  1. 集成Spring Cache,使用简单,只需通过注解即可实现缓存功能
  2. 支持多种缓存实现的无缝切换
  3. 二级缓存逻辑集中管理,便于维护
  4. 支持缓存失效时间、容量等细粒度控制

缺点:

  1. 需要自行实现二级缓存管理器,代码相对复杂
  2. 缓存同步需要额外实现,有一定复杂度
  3. 自定义缓存加载策略不够灵活
  4. 对于复杂查询场景支持有限

2.4 适用场景

  • 需要快速集成缓存功能的项目
  • 使用Spring框架且熟悉Spring Cache机制的团队
  • 读多写少的业务场景
  • 对缓存一致性要求不是特别高的场景

三、自定义二级缓存框架

3.1 基本原理

该方案通过自定义缓存框架,精确控制缓存的读写流程、失效策略和同步机制,实现更加贴合业务需求的二级缓存。

这种方式虽然实现复杂度高,但提供了最大的灵活性和控制力。

3.2 实现步骤

3.2.1 定义缓存接口

public interface Cache<K, V> {
    
    V get(K key);
    
    void put(K key, V value);
    
    void remove(K key);
    
    void clear();
    
    long size();
    
    boolean containsKey(K key);
}

public interface CacheLoader<K, V> {
    V load(K key);
}

3.2.2 实现本地缓存

public class LocalCache<K, V> implements Cache<K, V> {
    
    private final com.github.benmanes.caffeine.cache.Cache<K, V> cache;
    
    public LocalCache(long maximumSize, long expireAfterWriteSeconds) {
        this.cache = Caffeine.newBuilder()
                .maximumSize(maximumSize)
                .expireAfterWrite(expireAfterWriteSeconds, TimeUnit.SECONDS)
                .recordStats()
                .build();
    }
    
    @Override
    public V get(K key) {
        return cache.getIfPresent(key);
    }
    
    @Override
    public void put(K key, V value) {
        if (value != null) {
            cache.put(key, value);
        }
    }
    
    @Override
    public void remove(K key) {
        cache.invalidate(key);
    }
    
    @Override
    public void clear() {
        cache.invalidateAll();
    }
    
    @Override
    public long size() {
        return cache.estimatedSize();
    }
    
    @Override
    public boolean containsKey(K key) {
        return cache.getIfPresent(key) != null;
    }
    
    public CacheStats stats() {
        return cache.stats();
    }
}

3.2.3 实现Redis分布式缓存

public class RedisCache<K, V> implements Cache<K, V> {
    
    private final RedisTemplate<String, Object> redisTemplate;
    private final String cachePrefix;
    private final long expireSeconds;
    private final Class<V> valueType;
    
    public RedisCache(RedisTemplate<String, Object> redisTemplate, 
                      String cachePrefix, 
                      long expireSeconds,
                      Class<V> valueType) {
        this.redisTemplate = redisTemplate;
        this.cachePrefix = cachePrefix;
        this.expireSeconds = expireSeconds;
        this.valueType = valueType;
    }
    
    private String getCacheKey(K key) {
        return cachePrefix + ":" + key.toString();
    }
    
    @Override
    public V get(K key) {
        String cacheKey = getCacheKey(key);
        return (V) redisTemplate.opsForValue().get(cacheKey);
    }
    
    @Override
    public void put(K key, V value) {
        if (value != null) {
            String cacheKey = getCacheKey(key);
            redisTemplate.opsForValue().set(cacheKey, value, expireSeconds, TimeUnit.SECONDS);
        }
    }
    
    @Override
    public void remove(K key) {
        String cacheKey = getCacheKey(key);
        redisTemplate.delete(cacheKey);
    }
    
    @Override
    public void clear() {
        Set<String> keys = redisTemplate.keys(cachePrefix + ":*");
        if (keys != null && !keys.isEmpty()) {
            redisTemplate.delete(keys);
        }
    }
    
    @Override
    public long size() {
        Set<String> keys = redisTemplate.keys(cachePrefix + ":*");
        return keys != null ? keys.size() : 0;
    }
    
    @Override
    public boolean containsKey(K key) {
        String cacheKey = getCacheKey(key);
        return Boolean.TRUE.equals(redisTemplate.hasKey(cacheKey));
    }
}

3.2.4 实现二级缓存

public class TwoLevelCache<K, V> implements Cache<K, V> {
    
    private final Cache<K, V> localCache;
    private final Cache<K, V> remoteCache;
    private final CacheLoader<K, V> cacheLoader;
    private final String cacheName;
    private final CacheEventPublisher eventPublisher;
    
    public TwoLevelCache(Cache<K, V> localCache, 
                         Cache<K, V> remoteCache, 
                         CacheLoader<K, V> cacheLoader,
                         String cacheName,
                         CacheEventPublisher eventPublisher) {
        this.localCache = localCache;
        this.remoteCache = remoteCache;
        this.cacheLoader = cacheLoader;
        this.cacheName = cacheName;
        this.eventPublisher = eventPublisher;
    }
    
    @Override
    public V get(K key) {
        // 先查本地缓存
        V value = localCache.get(key);
        if (value != null) {
            return value;
        }
        
        // 本地未命中,查远程缓存
        value = remoteCache.get(key);
        if (value != null) {
            // 回填本地缓存
            localCache.put(key, value);
            return value;
        }
        
        // 远程也未命中,加载数据
        if (cacheLoader != null) {
            value = cacheLoader.load(key);
            if (value != null) {
                // 填充缓存
                put(key, value);
            }
        }
        
        return value;
    }
    
    @Override
    public void put(K key, V value) {
        if (value != null) {
            // 先放入远程缓存,再放入本地缓存
            remoteCache.put(key, value);
            localCache.put(key, value);
        }
    }
    
    @Override
    public void remove(K key) {
        // 先清远程缓存,再清本地缓存
        remoteCache.remove(key);
        localCache.remove(key);
        
        // 发布缓存失效事件
        if (eventPublisher != null) {
            eventPublisher.publishCacheEvictEvent(cacheName, key);
        }
    }
    
    @Override
    public void clear() {
        // 先清远程缓存,再清本地缓存
        remoteCache.clear();
        localCache.clear();
        
        // 发布缓存清空事件
        if (eventPublisher != null) {
            eventPublisher.publishCacheClearEvent(cacheName);
        }
    }
    
    @Override
    public long size() {
        return remoteCache.size();
    }
    
    @Override
    public boolean containsKey(K key) {
        return localCache.containsKey(key) || remoteCache.containsKey(key);
    }
}

3.2.5 缓存事件发布和订阅

@Component
public class CacheEventPublisher {
    
    private final RedisTemplate<String, String> redisTemplate;
    private static final String CACHE_EVICT_TOPIC = "cache:evict";
    private static final String CACHE_CLEAR_TOPIC = "cache:clear";
    
    public CacheEventPublisher(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    public void publishCacheEvictEvent(String cacheName, Object key) {
        Map<String, Object> message = new HashMap<>();
        message.put("cacheName", cacheName);
        message.put("key", key);
        redisTemplate.convertAndSend(CACHE_EVICT_TOPIC, JSON.toJSONString(message));
    }
    
    public void publishCacheClearEvent(String cacheName) {
        Map<String, Object> message = new HashMap<>();
        message.put("cacheName", cacheName);
        redisTemplate.convertAndSend(CACHE_CLEAR_TOPIC, JSON.toJSONString(message));
    }
}

@Component
public class CacheEventListener {
    
    private final Map<String, TwoLevelCache<?, ?>> cacheMap;
    
    public CacheEventListener(RedisMessageListenerContainer listenerContainer, 
                             Map<String, TwoLevelCache<?, ?>> cacheMap) {
        this.cacheMap = cacheMap;
        
        // 监听缓存失效事件
        MessageListener evictListener = (message, pattern) -> {
            String body = new String(message.getBody());
            Map<String, Object> map = JSON.parseObject(body, Map.class);
            String cacheName = (String) map.get("cacheName");
            Object key = map.get("key");
            
            TwoLevelCache<Object, Object> cache = (TwoLevelCache<Object, Object>) cacheMap.get(cacheName);
            if (cache != null) {
                // 只清除本地缓存,远程缓存已经由发布者清除
                ((LocalCache<Object, Object>)cache.getLocalCache()).remove(key);
            }
        };
        
        // 监听缓存清空事件
        MessageListener clearListener = (message, pattern) -> {
            String body = new String(message.getBody());
            Map<String, Object> map = JSON.parseObject(body, Map.class);
            String cacheName = (String) map.get("cacheName");
            
            TwoLevelCache<Object, Object> cache = (TwoLevelCache<Object, Object>) cacheMap.get(cacheName);
            if (cache != null) {
                // 只清除本地缓存,远程缓存已经由发布者清除
                ((LocalCache<Object, Object>)cache.getLocalCache()).clear();
            }
        };
        
        listenerContainer.addMessageListener(evictListener, new ChannelTopic("cache:evict"));
        listenerContainer.addMessageListener(clearListener, new ChannelTopic("cache:clear"));
    }
}

3.2.6 缓存管理器

@Component
public class TwoLevelCacheManager {
    
    private final RedisTemplate<String, Object> redisTemplate;
    private final CacheEventPublisher eventPublisher;
    private final Map<String, TwoLevelCache<?, ?>> cacheMap = new ConcurrentHashMap<>();
    
    public TwoLevelCacheManager(RedisTemplate<String, Object> redisTemplate, 
                              CacheEventPublisher eventPublisher) {
        this.redisTemplate = redisTemplate;
        this.eventPublisher = eventPublisher;
    }
    
    public <K, V> TwoLevelCache<K, V> getCache(String cacheName, 
                                             Class<V> valueType, 
                                             CacheLoader<K, V> cacheLoader) {
        return getCache(cacheName, valueType, cacheLoader, 1000, 300, 3600);
    }
    
    @SuppressWarnings("unchecked")
    public <K, V> TwoLevelCache<K, V> getCache(String cacheName, 
                                             Class<V> valueType, 
                                             CacheLoader<K, V> cacheLoader,
                                             long localMaxSize,
                                             long localExpireSeconds,
                                             long remoteExpireSeconds) {
        return (TwoLevelCache<K, V>) cacheMap.computeIfAbsent(cacheName, name -> {
            LocalCache<K, V> localCache = new LocalCache<>(localMaxSize, localExpireSeconds);
            RedisCache<K, V> remoteCache = new RedisCache<>(redisTemplate, name, remoteExpireSeconds, valueType);
            return new TwoLevelCache<>(localCache, remoteCache, cacheLoader, name, eventPublisher);
        });
    }
    
    public Map<String, TwoLevelCache<?, ?>> getCacheMap() {
        return Collections.unmodifiableMap(cacheMap);
    }
}

3.2.7 使用示例

@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private TwoLevelCacheManager cacheManager;
    
    private TwoLevelCache<Long, User> userCache;
    
    @PostConstruct
    public void init() {
        userCache = cacheManager.getCache("user", User.class, this::loadUser, 1000, 300, 1800);
    }
    
    private User loadUser(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    @Override
    public User getUserById(Long id) {
        return userCache.get(id);
    }
    
    @Override
    public User saveUser(User user) {
        User savedUser = userRepository.save(user);
        userCache.put(user.getId(), savedUser);
        return savedUser;
    }
    
    @Override
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
        userCache.remove(id);
    }
}

3.3 优缺点分析

优点:

  1. 完全自定义,可以根据业务需求灵活定制
  2. 精确控制缓存的加载、更新和失效逻辑
  3. 可以针对不同业务场景设计不同的缓存策略
  4. 缓存监控和统计更加全面

缺点:

  1. 开发工作量大,需要实现所有缓存逻辑
  2. 代码复杂度高,需要考虑多种边界情况
  3. 不能直接利用Spring等框架提供的缓存抽象
  4. 维护成本较高

3.4 适用场景

  • 对缓存性能和行为有精确控制需求的项目
  • 缓存策略复杂,标准框架难以满足的场景
  • 大型项目,有专人负责缓存框架开发和维护
  • 特殊业务需求,如精确的过期策略、按条件批量失效等

四、JetCache框架方案

4.1 基本原理

JetCache是阿里开源的一款Java缓存抽象框架,原生支持二级缓存,并提供丰富的缓存功能,如缓存自动刷新、异步加载、分布式锁等。它在API设计上类似Spring Cache,但功能更加强大和灵活。

4.2 实现步骤

4.2.1 添加依赖

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- JetCache核心 -->
    <dependency>
        <groupId>com.alicp.jetcache</groupId>
        <artifactId>jetcache-starter-redis</artifactId>
        <version>2.7.1</version>
    </dependency>
</dependencies>

4.2.2 配置JetCache

# application.yml
jetcache:
  statIntervalMinutes: 15
  areaInCacheName: false
  hidePackages: com.example
  local:
    default:
      type: caffeine
      limit: 1000
      keyConvertor: fastjson
      expireAfterWriteInMillis: 300000  # 5分钟
  remote:
    default:
      type: redis
      keyConvertor: fastjson
      valueEncoder: java
      valueDecoder: java
      poolConfig:
        minIdle: 5
        maxIdle: 20
        maxTotal: 50
      host: ${redis.host}
      port: ${redis.port}
      expireAfterWriteInMillis: 1800000  # 30分钟

在启动类上启用JetCache:

@SpringBootApplication
@EnableMethodCache(basePackages = "com.example")
@EnableCreateCacheAnnotation
public class Application {
    
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

4.2.3 使用注解方式

@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    @Cached(name = "user:", key = "#id", cacheType = CacheType.BOTH, expire = 1800)
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    
    @Override
    @CacheUpdate(name = "user:", key = "#user.id", value = "#user")
    public User saveUser(User user) {
        return userRepository.save(user);
    }
    
    @Override
    @CacheInvalidate(name = "user:", key = "#id")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

4.2.4 使用API方式

@Service
public class ProductServiceImpl implements ProductService {
    
    @Autowired
    private ProductRepository productRepository;
    
    @CreateCache(name = "product:", cacheType = CacheType.BOTH, expire = 3600, localExpire = 600)
    private Cache<Long, Product> productCache;
    
    @Override
    public Product getProductById(Long id) {
        // 自动加载功能,若缓存未命中,会执行lambda中的逻辑并将结果缓存
        return productCache.computeIfAbsent(id, this::loadProduct);
    }
    
    private Product loadProduct(Long id) {
        return productRepository.findById(id).orElse(null);
    }
    
    @Override
    public Product saveProduct(Product product) {
        Product savedProduct = productRepository.save(product);
        productCache.put(product.getId(), savedProduct);
        return savedProduct;
    }
    
    @Override
    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
        productCache.remove(id);
    }
    
    // 批量操作
    @Override
    public List<Product> getProductsByIds(List<Long> ids) {
        Map<Long, Product> productMap = productCache.getAll(ids);
        List<Long> missedIds = ids.stream()
                .filter(id -> !productMap.containsKey(id))
                .collect(Collectors.toList());
        
        if (!missedIds.isEmpty()) {
            List<Product> missedProducts = productRepository.findAllById(missedIds);
            Map<Long, Product> missedProductMap = missedProducts.stream()
                    .collect(Collectors.toMap(Product::getId, p -> p));
            
            // 更新缓存
            productCache.putAll(missedProductMap);
            
            // 合并结果
            productMap.putAll(missedProductMap);
        }
        
        return ids.stream()
                .map(productMap::get)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
    }
}

4.2.5 高级特性:自动刷新和异步加载

@Service
public class StockServiceImpl implements StockService {
    
    @Autowired
    private StockRepository stockRepository;
    
    // 自动刷新缓存,适合库存等频繁变化的数据
    @CreateCache(name = "stock:", 
                cacheType = CacheType.BOTH, 
                expire = 60,  // 1分钟后过期
                localExpire = 10,  // 本地缓存10秒过期
                refreshPolicy = RefreshPolicy.BACKGROUND,  // 后台刷新
                penetrationProtect = true)  // 防止缓存穿透
    private Cache<Long, Stock> stockCache;
    
    @Override
    public Stock getStockById(Long productId) {
        return stockCache.computeIfAbsent(productId, this::loadStock);
    }
    
    private Stock loadStock(Long productId) {
        return stockRepository.findByProductId(productId).orElse(new Stock(productId, 0));
    }
    
    @Override
    public void updateStock(Long productId, int newQuantity) {
        stockRepository.updateQuantity(productId, newQuantity);
        stockCache.remove(productId);  // 直接失效缓存,后台自动刷新会加载新值
    }
}

4.2.6 缓存统计与监控

@RestController
@RequestMapping("/cache")
public class CacheStatsController {
    
    @Autowired
    private CacheManager cacheManager;
    
    @GetMapping("/stats")
    public Map<String, CacheStats> getCacheStats() {
        Collection<Cache> caches = cacheManager.getCache(null);
        Map<String, CacheStats> statsMap = new HashMap<>();
        
        for (Cache cache : caches) {
            statsMap.put(cache.config().getName(), cache.getStatistics());
        }
        
        return statsMap;
    }
}

4.3 优缺点分析

优点:

  1. 原生支持二级缓存,使用简单
  2. 提供注解和API两种使用方式,灵活性强
  3. 内置多种高级特性,如自动刷新、异步加载、分布式锁等
  4. 完善的缓存统计和监控支持
  5. 社区活跃,文档完善

缺点:

  1. 增加项目依赖,引入第三方框架
  2. 配置相对复杂
  3. 学习成本相对较高

4.4 适用场景

  • 需要开箱即用的二级缓存解决方案
  • 对缓存有丰富需求的项目,如自动刷新、异步加载等
  • 微服务架构,需要统一的缓存抽象

五、总结

选择合适的二级缓存方案需要考虑项目规模、团队技术栈、性能需求、功能需求等多方面因素。

无论选择哪种方案,合理的缓存策略、完善的监控体系和优秀的运维实践都是构建高效缓存系统的关键。

在实际应用中,缓存并非越多越好,应当根据业务特点和系统架构,在性能、复杂度和一致性之间找到平衡点。

黑马Redis学习——实战篇(2) 黑马Redis课程学习实战篇(2) 阅读详情

相关推荐

Spring Boot整合MyBatis:从基础配置到高级应用

MyBatis作为Java生态中广泛使用的ORM框架,通过与Spring Boot的深度整合,可以显著提升数据库操作效率。其核心原理基于SQL映射与动态代理机制,开发者通过接口定义+XML配置的方式实现数据库访问。在技术价值层面,MyBatis提供了灵活的SQL控制能力,特别适合需要精细优化SQL性能的场景。结合Spring Boot的自动配置特性,可以快速搭建包含连接池管理、事务控制的企业级应用。典型应用场景包括电商系统订单处理、用户权限管理等需要复杂SQL操作的业务模块。本文重点演示了如何配置Hikar

weixin_34112181的博客 375

二级缓存(Spring Boot)

开启缓存:@EnableCaching

qq_41296669的博客 4129

mybatis的一级缓存和二级缓存

一、什么是缓存 缓存是存在于内存中的临时数据。 使用缓存减少和数据库的交互次数,提高执行效率。 1、适用于缓存 经常查询并且不经常改变的; 数据的正确与否对最终结果影响不大的; 2、不适用于缓存 经常改变的数据; 数据的正确与否对最终结果影响很大的; 例如:商品的库存,银行的汇率,股市的牌价; 二、mybatis一级缓存 1、一级缓存简介 一级缓存作用域是sqlsession级别的,同一个sqlsession中执行相同的sql查询(相同的sql和参数),第一次会去查询数据库并写到缓存中,第

学Java,找哪吒 7万+

基于JetCache整合实现一级、二级缓存方案(方案实现)

在高并发系统中,为了减少数据库压力,就有了像Redis这种的内存缓存。通过内存缓存能够提高查询速度,但是查询并发量非常的大的场景,频繁的查询Redis,会有明显的网络IO消耗,针对这种查询非常频繁的数据(热点key),我们可以考虑本地进程级缓存,如:Caffeine。当有符合条件的数据时,可以直接查询本地缓存,而不用通过网络到Redis中去获取,这样就形成了两级缓存。本文通过JetCache缓存框架整合Caffeine、Redis缓存,进而实现扩展Hibernate、Mybatis、Spring Cache

qq_25409421的博客 2918

置顶必读(1) |《滚雪球学 Spring Boot 4.x》专栏目录导航篇(持续更新中)!

🏆 本文收录于 《滚雪球学 Spring Boot 4.x》 专栏。 本专栏面向 有一点 Java 基础,但没有系统学过 Spring Boot 的读者,采用“滚雪球式学习法”:先跑通、再理解、再重构、再上线,最终带你从第一个 Hello API 一路完成一个可部署、可监控、可扩展的后端项目。

**My Coding Family** 8万+

手把手教你用Simulink搭建BPSK调制解调系统(附完整参数设置与波形分析)

本文详细指导如何使用Simulink搭建BPSK调制解调系统,涵盖从理论到实践的全流程,包括参数设置、模块连接和波形分析。重点解析调制解调中的关键参数和常见问题,如带通滤波器设计、载波同步等,帮助读者快速掌握BPSK系统的实现与调试技巧。

weixin_27741699的博客 427

SpringBoot二级缓存3种高并发落地方案

作为开发,咱们都知道技术没有 “最好”,只有 “最合适”。我见过有些同事,为了用 “高大上” 的技术,在小项目里硬上分布式锁、消息队列,最后导致项目复杂度飙升,运维成本增加,反而影响了上线效率。二级缓存也是一样,不是所有项目都需要用。如果你的项目 QPS 很低,数据库压力不大,那单靠 Redis 甚至本地缓存就够了,没必要强行上二级缓存。只有当你遇到了 “本地缓存数据不一致”“Redis 网络开销大”“缓存击穿” 这些实际问题时,再考虑用二级缓存来解决。

2501_93873871的博客 671

SpringBoot使用mybatis-plus的自动代码生成器

一.SpringBoot使用mybatis-plus+自动代码生成 使用mybatis-plus可以自动帮我们生成通用的 controller,service,dao,mapper 二.加入依赖 <!-- MP 核心库 --> <dependency> <groupId>com.baomidou</groupId> <artif...

农民娃儿的博客 2267

Spring Boot 3与MyBatis-Plus高效持久层开发指南

持久层框架是Java企业级应用开发的核心组件,直接影响系统性能与稳定性。MyBatis作为半ORM框架,通过XML/注解方式将SQL与代码解耦,而MyBatis-Plus在其基础上提供了增强的CRUD操作、条件构造器等开箱即用功能。结合Spring Boot 3的自动配置、内嵌容器等特性,开发者可以快速构建高性能数据访问层。该技术组合特别适合需要平衡开发效率与SQL控制权的场景,如电商系统、ERP等中大型应用。通过分页插件、性能分析等工具,还能有效应对高并发查询与批量处理需求。

weixin_34396103的博客 393

HFSS简要教程--无线能量传输线圈仿真

关于无限能量传输线圈仿真简要教程

asdmoon18的博客 2551

7、初级视觉皮层(V1)的研究综述

本文综述了初级视觉皮层(V1)的基本功能特性、计算理解、细胞相互作用及理论模型。V1不仅执行方向和空间频率的选择性滤波,还通过相位选择性和上下文调制参与高级视觉处理。研究从信息编码角度解释了V1感受野的形成,并介绍了基于自然图像统计的建模方法。横向与反馈连接揭示了V1在全局视觉整合中的作用,尤其是上下文对细胞响应的快速调节。李的动态模型提出V1可生成视觉显著性图,支持前注意分割和注意力引导。未来研究聚焦于V1在注意力、意识和硬件实现中的潜在应用,推动视觉神经科学与人工智能的交叉发展。

7z8x2c4v6b9的博客 146

MyBatis @Select/@Update 注解实战:5个常见陷阱与Spring Boot 3.x集成优化

本文深入探讨MyBatis @Select/@Update注解在Spring Boot 3.x项目中的实战应用,揭示5个常见陷阱并提供优化方案。涵盖动态SQL注入防范、N+1查询优化、事务失效处理、批量操作性能提升及结果集映射技巧,帮助开发者高效集成MyBatis与Spring Boot 3.x。

weixin_30855099的博客 390

S/4HANA Private Cloud 与 On-Premise 的 Key User Custom Fields 运输与升级避坑指南

本文探讨了SAP S/4HANA Cloud Private Edition和On-Premise系统中Key User Custom Fields的管理要点。文章指出,Custom Fields涉及元数据生成、对象一致性、传输治理等完整链路,操作不当会导致字段丢失或升级失败。关键建议包括:使用ATO Fiori App管理扩展项与传输绑定,配置正确的job user权限,避免在多系统并行开发同一字段。特别强调升级时需执行CFD_REGENERATE_IN_ONPREMISE报表,并通过标准传输机制推进变更

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 197

从入门到精通:Spring Boot 整合 MyBatis 全攻略

本文从 MyBatis 的核心概念、架构原理入手,详细讲解了 Spring Boot 整合 MyBatis 的两种主流方式(XML 与注解),深入剖析了动态 SQL、缓存机制、分页方案、性能优化、多数据源配置等进阶内容,最后介绍了 MyBatis-Plus 这个强大的增强工具。简单项目:Spring Boot + MyBatis(注解方式)+ PageHelper复杂项目:Spring Boot + MyBatis(XML 方式)+ MyBatis-Plus(仅使用增强功能)极速开发。

xiaoyu❅的博客 874

Centos 7 Linux 离线安装单机 Kafka:下载、安装、配置、使用

本文详细介绍了在 CentOS 7 系统上离线安装单机版 Apache Kafka 的完整流程,包括环境准备(JDK 安装)、Kafka 安装包上传与解压、关键配置修改(如监听地址)、ZooKeeper 与 Kafka 服务的启动,以及 Topic 的创建、消息的生产和消费等基础操作。适用于无网络环境下的 Kafka 快速部署与学习,为后续开发或测试提供本地消息队列支持。

寒水馨 · 轻量级技术文档 · hanshuixin.org 1320

【学习系列】SAP RAP 2:创建第一个RAP应用

本文介绍了从零开始创建基于SAP RAP(ABAP RESTful Application Programming Model)的Fiori应用的完整流程。首先说明了学习RAP需要结合官方文档和教程,并提供了相关资源链接。文章详细讲解了开发环境的准备要求,包括系统版本、开发工具和基本知识。重点演示了如何通过8个步骤创建支持CRUD操作和草稿功能的RAP应用:1)创建数据库表;2)定义CDS视图实体;3)创建投影视图;4)定义行为;5)创建行为投影;6)定义服务;7)绑定服务;8)添加UI注解。

DeveloperMrMeng的博客 1510

Java 性能 11 - MyBatis 缓存优化(二级缓存配置)

本文深入解析MyBatis二级缓存的配置与优化策略,通过对比测试验证其性能提升效果。主要内容包括: 缓存层级:详解MyBatis一级缓存(SqlSession级别)和二级缓存(Mapper命名空间级别)的作用域与适用场景。 工作原理:通过流程图展示二级缓存的查询路径,说明其跨会话共享特性和缓存更新机制。 配置详解: XML配置方式(全局设置与Mapper级配置) 注解配置方式(Spring Boot环境) 关键参数说明(回收策略、刷新间隔等) 性能测试:在100并发用户场景下,对比启用二级缓存前后的查询性能

千淘万漉虽辛苦,吹尽狂沙始到金 2万+

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Java大厂面试全流程:Spring Boot与Kafka实战解析

Java作为企业级应用开发的主流语言,其技术生态涵盖从基础语法到分布式架构的完整体系。理解Java核心原理如JVM机制、并发编程模型,以及主流框架如Spring Boot的自动配置原理,是构建高性能应用的基础。在微服务架构中,消息队列如Kafka通过分区和副本机制实现高吞吐量消息处理,而Spring Cloud组件则提供服务发现和负载均衡能力。这些技术通过解耦服务、提高系统弹性,支撑了电商、金融等高频交易场景。本文以Spring Boot微服务与Kafka集成实战为例,深入解析大厂面试中的高频考点,包括自动

dengjuanshou7445的博客 343

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Java技术面试:Spring Boot、微服务与AI融合实战解析

Java作为企业级开发的核心语言,其技术生态持续演进,Spring Boot已成为现代Java开发的标配框架。通过自动配置机制和起步依赖,Spring Boot显著提升了开发效率,其底层原理涉及条件注解、配置属性绑定等关键技术。在分布式架构领域,微服务通过服务拆分和分布式事务解决复杂系统问题,而AI技术的引入为传统Java开发带来智能日志分析、文档生成等创新场景。本文结合大厂面试实战,深入探讨Spring Boot性能优化、微服务架构设计以及AI与Java生态融合的工程实践,为开发者提供从原理到落地的完整视

weixin_30607659的博客 408

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Staffjoy微服务架构深度解析:Spring Boot与Kubernetes云原生实践

Staffjoy是一个基于Spring Boot和Kubernetes技术栈的微服务教学案例项目,为技术决策者和架构师提供了完整的云原生架构参考实现。该项目采用前后端分离的微服务架构,涵盖账户管理、公司管理、消息通知等多个业务领域,通过容器化和Kubernetes部署实现高可用、可扩展的生产级解决方案。 ## 技术背景与架构挑战分析 ### 微服务架构的复杂性挑战 现代企业级应用面临的核心挑

gitblog_00997的博客 1089

Spring Boot电商微服务架构实战与高频面试解析

微服务架构通过服务拆分实现系统解耦与独立部署,Spring Boot凭借自动配置和Starter生态成为微服务开发的事实标准。其核心原理是基于约定优于配置的理念,通过条件化装配机制动态加载组件,显著提升开发效率。在电商等高并发场景中,这种架构展现出独特价值:商品服务可采用Elasticsearch实现高性能搜索,订单服务通过分布式事务保证数据一致性。本文以订单中心、商品中心等典型模块为例,深入解析Spring Boot在Redis缓存定制、服务边界划分等实战要点,并分享大促期间JVM调优参数和秒杀场景的Lu

weixin_30600197的博客 458

spring

在应用开发中用的非常多, @Component注解是一个通用注解,可以用在于任何类上。包括普通java类,业务逻辑组件,持久化对象等等。通过@Component注解spring自动创建该类的实例注入SpringIOC容器中。@Bean是用于配置类中声明一个Bean的,它通常是用于配置类的方法上面,表示把这个方法的返回对象注册到Spring IOC容器中。通过@Bean自定义Bean的创建和初始化过程,包括指定Bean的名称、作用域、依赖关系等。1.用途不同@Component用于标识普通的类。

黑冰[̲̅V̲̅I̲̅P̅] 820

Java智能订单风险检测系统:Spring Boot与AI集成实战

风险检测是电商平台保障交易安全的核心技术,其原理是通过算法模型对用户行为数据进行分析评估。在技术价值上,实时风险检测能有效识别欺诈交易、恶意刷单等异常行为,保护平台和用户利益。应用场景广泛覆盖电商下单、支付风控、反欺诈系统等领域。本文基于Spring Boot微服务架构,结合Spring AI统一接口,详细解析智能订单风险检测系统的设计与实现,涵盖Redis缓存优化、Resilience4j熔断降级等关键技术,为Java开发者提供完整的AI集成解决方案。

weixin_34234721的博客 600
上一篇: SpringBoot的5种签到打卡实现方案
下一篇: SpringBoot中3种优雅停机的实现方式
程序员职业指南
博客等级 码龄4年 2140粉丝 960原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值