第180集Redis支撑高并发流量

package com.example.redis.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import io.lettuce.core.resource.ClientResources;
import io.lettuce.core.resource.DefaultClientResources;

import java.time.Duration;

/**
 * Redis高并发配置类
 * 提供高性能的Redis连接池和模板配置
 */
@Configuration
public class RedisHighConcurrencyConfig {

    @Value("${redis.host:localhost}")
    private String redisHost;

    @Value("${redis.port:6379}")
    private int redisPort;

    @Value("${redis.password:}")
    private String redisPassword;

    @Value("${redis.database:0}")
    private int redisDatabase;

    @Value("${redis.pool.max-total:200}")
    private int maxTotal;

    @Value("${redis.pool.max-idle:50}")
    private int maxIdle;

    @Value("${redis.pool.min-idle:10}")
    private int minIdle;

    @Value("${redis.pool.max-wait-millis:3000}")
    private long maxWaitMillis;

    @Value("${redis.pool.test-on-borrow:true}")
    private boolean testOnBorrow;

    @Value("${redis.pool.test-on-return:false}")
    private boolean testOnReturn;

    @Value("${redis.pool.test-while-idle:true}")
    private boolean testWhileIdle;

    @Value("${redis.timeout:2000}")
    private int timeout;

    /**
     * 创建Redis连接工厂
     * 使用Lettuce连接池提供高性能连接
     */
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        // Redis服务器配置
        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
        redisConfig.setHostName(redisHost);
        redisConfig.setPort(redisPort);
        redisConfig.setPassword(redisPassword);
        redisConfig.setDatabase(redisDatabase);

        // 连接池配置
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxTotal(maxTotal);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxWaitMillis(maxWaitMillis);
        poolConfig.setTestOnBorrow(testOnBorrow);
        poolConfig.setTestOnReturn(testOnReturn);
        poolConfig.setTestWhileIdle(testWhileIdle);
        poolConfig.setTimeBetweenEvictionRunsMillis(30000);
        poolConfig.setMinEvictableIdleTimeMillis(60000);
        poolConfig.setNumTestsPerEvictionRun(3);
        poolConfig.setBlockWhenExhausted(true);

        // Lettuce客户端配置
        LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .poolConfig(poolConfig)
                .commandTimeout(Duration.ofMillis(timeout))
                .shutdownTimeout(Duration.ofMillis(100))
                .build();

        // 创建连接工厂
        return new LettuceConnectionFactory(redisConfig, clientConfig);
    }

    /**
     * 创建Redis模板
     * 配置序列化器提供高性能序列化
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 设置序列化器
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();

        // Key序列化
        template.setKeySerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);

        // Value序列化
        template.setValueSerializer(jsonSerializer);
        template.setHashValueSerializer(jsonSerializer);

        // 设置默认序列化器
        template.setDefaultSerializer(jsonSerializer);

        // 启用事务支持
        template.setEnableTransactionSupport(true);

        template.afterPropertiesSet();
        return template;
    }

    /**
     * 创建Redis字符串模板
     * 专门用于字符串操作的高性能模板
     */
    @Bean
    public RedisTemplate<String, String> stringRedisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, String> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 使用字符串序列化器
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);
        template.setValueSerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);
        template.setHashValueSerializer(stringSerializer);

        template.afterPropertiesSet();
        return template;
    }

    /**
     * 创建客户端资源
     * 优化客户端性能
     */
    @Bean(destroyMethod = "shutdown")
    public ClientResources clientResources() {
        return DefaultClientResources.builder()
                .ioThreadPoolSize(4)
                .computationThreadPoolSize(4)
                .build();
    }
}

package com.example.redis.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Redis高并发服务类
 * 提供高性能的Redis操作服务
 */
@Service
public class RedisHighConcurrencyService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // 分布式锁
    private final ReentrantLock lock = new ReentrantLock();

    /**
     * 设置缓存
     * 支持过期时间设置
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置缓存并指定过期时间
     */
    public boolean set(String key, Object value, long time, TimeUnit timeUnit) {
        try {
            redisTemplate.opsForValue().set(key, value, time, timeUnit);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置缓存并指定过期时间（秒）
     */
    public boolean set(String key, Object value, long time) {
        return set(key, value, time, TimeUnit.SECONDS);
    }

    /**
     * 获取缓存
     */
    public Object get(String key) {
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取缓存并指定类型
     */
    @SuppressWarnings("unchecked")
    public <T> T get(String key, Class<T> clazz) {
        try {
            Object value = redisTemplate.opsForValue().get(key);
            if (value != null && clazz.isInstance(value)) {
                return (T) value;
            }
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 删除缓存
     */
    public boolean delete(String key) {
        try {
            return Boolean.TRUE.equals(redisTemplate.delete(key));
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 批量删除缓存
     */
    public boolean delete(Collection<String> keys) {
        try {
            if (CollectionUtils.isEmpty(keys)) {
                return false;
            }
            Long deleted = redisTemplate.delete(keys);
            return deleted != null && deleted > 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 判断缓存是否存在
     */
    public boolean hasKey(String key) {
        try {
            return Boolean.TRUE.equals(redisTemplate.hasKey(key));
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置过期时间
     */
    public boolean expire(String key, long time, TimeUnit timeUnit) {
        try {
            return Boolean.TRUE.equals(redisTemplate.expire(key, time, timeUnit));
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置过期时间（秒）
     */
    public boolean expire(String key, long time) {
        return expire(key, time, TimeUnit.SECONDS);
    }

    /**
     * 获取过期时间
     */
    public long getExpire(String key) {
        try {
            Long expire = redisTemplate.getExpire(key);
            return expire != null ? expire : -1;
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }

    /**
     * 递增
     */
    public long increment(String key) {
        try {
            Long value = redisTemplate.opsForValue().increment(key);
            return value != null ? value : 0;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 递增指定值
     */
    public long increment(String key, long delta) {
        try {
            Long value = redisTemplate.opsForValue().increment(key, delta);
            return value != null ? value : 0;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 递减
     */
    public long decrement(String key) {
        try {
            Long value = redisTemplate.opsForValue().decrement(key);
            return value != null ? value : 0;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 递减指定值
     */
    public long decrement(String key, long delta) {
        try {
            Long value = redisTemplate.opsForValue().decrement(key, delta);
            return value != null ? value : 0;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取所有匹配的key
     */
    public Set<String> keys(String pattern) {
        try {
            return redisTemplate.keys(pattern);
        } catch (Exception e) {
            e.printStackTrace();
            return new HashSet<>();
        }
    }

    /**
     * 批量获取
     */
    public List<Object> multiGet(Collection<String> keys) {
        try {
            if (CollectionUtils.isEmpty(keys)) {
                return new ArrayList<>();
            }
            return redisTemplate.opsForValue().multiGet(keys);
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 批量设置
     */
    public boolean multiSet(Map<String, Object> map) {
        try {
            if (map == null || map.isEmpty()) {
                return false;
            }
            redisTemplate.opsForValue().multiSet(map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 分布式锁
     */
    public boolean lock(String key, String value, long time, TimeUnit timeUnit) {
        try {
            Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, time, timeUnit);
            return Boolean.TRUE.equals(result);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 释放分布式锁
     */
    public boolean unlock(String key, String value) {
        try {
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            Object result = redisTemplate.execute((org.springframework.data.redis.core.RedisCallback<Object>) connection -> 
                connection.eval(script.getBytes(), org.springframework.data.redis.connection.ReturnType.INTEGER, 1, key.getBytes(), value.getBytes()));
            return result != null && (Long) result > 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取Redis信息
     */
    public Map<String, Object> getRedisInfo() {
        Map<String, Object> info = new HashMap<>();
        try {
            Properties properties = redisTemplate.getConnectionFactory().getConnection().info();
            for (String key : properties.stringPropertyNames()) {
                info.put(key, properties.getProperty(key));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return info;
    }

    /**
     * 获取Redis统计信息
     */
    public Map<String, Object> getRedisStats() {
        Map<String, Object> stats = new HashMap<>();
        try {
            Properties info = redisTemplate.getConnectionFactory().getConnection().info();
            
            // 连接数统计
            stats.put("connected_clients", info.getProperty("connected_clients"));
            stats.put("total_connections_received", info.getProperty("total_connections_received"));
            stats.put("rejected_connections", info.getProperty("rejected_connections"));
            
            // 命令统计
            stats.put("total_commands_processed", info.getProperty("total_commands_processed"));
            stats.put("instantaneous_ops_per_sec", info.getProperty("instantaneous_ops_per_sec"));
            
            // 内存统计
            stats.put("used_memory", info.getProperty("used_memory"));
            stats.put("used_memory_human", info.getProperty("used_memory_human"));
            stats.put("used_memory_peak", info.getProperty("used_memory_peak"));
            stats.put("used_memory_peak_human", info.getProperty("used_memory_peak_human"));
            
            // 持久化统计
            stats.put("rdb_last_save_time", info.getProperty("rdb_last_save_time"));
            stats.put("rdb_changes_since_last_save", info.getProperty("rdb_changes_since_last_save"));
            stats.put("aof_enabled", info.getProperty("aof_enabled"));
            
            // 复制统计
            stats.put("role", info.getProperty("role"));
            stats.put("master_repl_offset", info.getProperty("master_repl_offset"));
            stats.put("slave_repl_offset", info.getProperty("slave_repl_offset"));
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        return stats;
    }
}

package com.example.redis.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Redis缓存策略服务类
 * 实现多种缓存策略以支撑高并发流量
 */
@Service
public class RedisCacheStrategyService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private final ReentrantLock lock = new ReentrantLock();

    /**
     * Cache-Aside策略
     * 应用程序负责管理缓存
     */
    public Object cacheAside(String key, CacheLoader loader, long expireTime, TimeUnit timeUnit) {
        try {
            // 1. 先从缓存获取
            Object value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                return value;
            }

            // 2. 缓存未命中，从数据源加载
            value = loader.load();
            if (value != null) {
                // 3. 将数据写入缓存
                redisTemplate.opsForValue().set(key, value, expireTime, timeUnit);
            }
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return loader.load();
        }
    }

    /**
     * Write-Through策略
     * 同时写入缓存和数据库
     */
    public boolean writeThrough(String key, Object value, CacheWriter writer, long expireTime, TimeUnit timeUnit) {
        try {
            // 1. 写入数据库
            boolean dbResult = writer.write(value);
            if (dbResult) {
                // 2. 写入缓存
                redisTemplate.opsForValue().set(key, value, expireTime, timeUnit);
                return true;
            }
            return false;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * Write-Behind策略
     * 先写入缓存，异步写入数据库
     */
    public boolean writeBehind(String key, Object value, CacheWriter writer, long expireTime, TimeUnit timeUnit) {
        try {
            // 1. 先写入缓存
            redisTemplate.opsForValue().set(key, value, expireTime, timeUnit);
            
            // 2. 异步写入数据库
            new Thread(() -> {
                try {
                    writer.write(value);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
            
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * Refresh-Ahead策略
     * 提前刷新即将过期的缓存
     */
    public Object refreshAhead(String key, CacheLoader loader, long expireTime, TimeUnit timeUnit, long refreshTime) {
        try {
            // 1. 获取缓存
            Object value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                // 2. 检查是否需要刷新
                long ttl = redisTemplate.getExpire(key, timeUnit);
                if (ttl <= refreshTime) {
                    // 3. 异步刷新缓存
                    new Thread(() -> {
                        try {
                            Object newValue = loader.load();
                            if (newValue != null) {
                                redisTemplate.opsForValue().set(key, newValue, expireTime, timeUnit);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }).start();
                }
                return value;
            }

            // 4. 缓存未命中，加载数据
            value = loader.load();
            if (value != null) {
                redisTemplate.opsForValue().set(key, value, expireTime, timeUnit);
            }
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return loader.load();
        }
    }

    /**
     * 多级缓存策略
     * L1: 本地缓存, L2: Redis缓存
     */
    public Object multiLevelCache(String key, CacheLoader loader, long expireTime, TimeUnit timeUnit) {
        try {
            // 1. 尝试从L1缓存获取
            Object value = getFromL1Cache(key);
            if (value != null) {
                return value;
            }

            // 2. 尝试从L2缓存获取
            value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                // 3. 写入L1缓存
                setToL1Cache(key, value);
                return value;
            }

            // 4. 从数据源加载
            value = loader.load();
            if (value != null) {
                // 5. 写入L2缓存
                redisTemplate.opsForValue().set(key, value, expireTime, timeUnit);
                // 6. 写入L1缓存
                setToL1Cache(key, value);
            }
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return loader.load();
        }
    }

    /**
     * 缓存预热
     */
    public void cacheWarmup(Map<String, CacheLoader> keyLoaders, long expireTime, TimeUnit timeUnit) {
        try {
            for (Map.Entry<String, CacheLoader> entry : keyLoaders.entrySet()) {
                String key = entry.getKey();
                CacheLoader loader = entry.getValue();
                
                // 异步预热
                new Thread(() -> {
                    try {
                        Object value = loader.load();
                        if (value != null) {
                            redisTemplate.opsForValue().set(key, value, expireTime, timeUnit);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 缓存雪崩防护
     * 使用随机过期时间防止缓存同时失效
     */
    public Object cacheAvalancheProtection(String key, CacheLoader loader, long baseExpireTime, TimeUnit timeUnit) {
        try {
            // 1. 获取缓存
            Object value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                return value;
            }

            // 2. 使用分布式锁防止缓存击穿
            String lockKey = "lock:" + key;
            String lockValue = UUID.randomUUID().toString();
            
            if (lock(lockKey, lockValue, 10, TimeUnit.SECONDS)) {
                try {
                    // 3. 双重检查
                    value = redisTemplate.opsForValue().get(key);
                    if (value != null) {
                        return value;
                    }

                    // 4. 加载数据
                    value = loader.load();
                    if (value != null) {
                        // 5. 设置随机过期时间
                        long randomExpireTime = baseExpireTime + (long) (Math.random() * baseExpireTime * 0.1);
                        redisTemplate.opsForValue().set(key, value, randomExpireTime, timeUnit);
                    }
                    return value;
                } finally {
                    unlock(lockKey, lockValue);
                }
            } else {
                // 6. 获取锁失败，等待一段时间后重试
                Thread.sleep(100);
                return redisTemplate.opsForValue().get(key);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return loader.load();
        }
    }

    /**
     * 缓存穿透防护
     * 使用布隆过滤器防止无效请求
     */
    public Object cachePenetrationProtection(String key, CacheLoader loader, long expireTime, TimeUnit timeUnit) {
        try {
            // 1. 检查布隆过滤器
            if (!bloomFilterContains(key)) {
                return null;
            }

            // 2. 获取缓存
            Object value = redisTemplate.opsForValue().get(key);
            if (value != null) {
                return value;
            }

            // 3. 加载数据
            value = loader.load();
            if (value != null) {
                redisTemplate.opsForValue().set(key, value, expireTime, timeUnit);
            } else {
                // 4. 设置空值缓存防止穿透
                redisTemplate.opsForValue().set(key, "", 60, TimeUnit.SECONDS);
            }
            return value;
        } catch (Exception e) {
            e.printStackTrace();
            return loader.load();
        }
    }

    /**
     * 获取L1缓存
     */
    private Object getFromL1Cache(String key) {
        // 这里可以实现本地缓存逻辑
        // 例如使用Caffeine或Guava Cache
        return null;
    }

    /**
     * 设置L1缓存
     */
    private void setToL1Cache(String key, Object value) {
        // 这里可以实现本地缓存逻辑
        // 例如使用Caffeine或Guava Cache
    }

    /**
     * 分布式锁
     */
    private boolean lock(String key, String value, long time, TimeUnit timeUnit) {
        try {
            Boolean result = redisTemplate.opsForValue().setIfAbsent(key, value, time, timeUnit);
            return Boolean.TRUE.equals(result);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 释放分布式锁
     */
    private boolean unlock(String key, String value) {
        try {
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            Object result = redisTemplate.execute((org.springframework.data.redis.core.RedisCallback<Object>) connection -> 
                connection.eval(script.getBytes(), org.springframework.data.redis.connection.ReturnType.INTEGER, 1, key.getBytes(), value.getBytes()));
            return result != null && (Long) result > 0;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 布隆过滤器检查
     */
    private boolean bloomFilterContains(String key) {
        // 这里可以实现布隆过滤器逻辑
        // 例如使用Redis的布隆过滤器模块
        return true;
    }

    /**
     * 缓存加载器接口
     */
    @FunctionalInterface
    public interface CacheLoader {
        Object load();
    }

    /**
     * 缓存写入器接口
     */
    @FunctionalInterface
    public interface CacheWriter {
        boolean write(Object value);
    }
}