Redis：常见配置

￡神魔★判官ぃ 2024-03-23 16:49 42阅读 0赞

##### 配置文件 #####

spring:
      freemarker:
        checkTemplateLocation: false
      # redis配置
      redis:
        # Redis数据库索引（默认为0）
        database: 4
        # Redis服务器地址
        host: tcsys.icu
        # Redis服务器连接端口
        port: 11007
        # Redis服务器连接密码（默认为空）
        password: gcfc-dev-redis
        # 连接超时时间（毫秒）
        timeout: 1000ms

##### 配置类 #####

import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.cache.RedisCacheWriter;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.RedisPassword;
    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.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.time.Duration;
    
    /**
     * ClassName: RedisConfig 
     * Description: redis连接配置类 
     *
     */
    @Configuration
    public class BaseRedisConfig {
        
    
        @Value("${spring.redis.host}")
        private String host;
    
        @Value("${spring.redis.password}")
        private String password;
    
        @Value("${spring.redis.port}")
        private int port;
    
        private final int timeout = 3000;
    
        private final int maxIdle = 8;
    
        private final int maxActive = 8;
    
        private final int minIdle = 0;
    
        private final long maxWait = -1;
    
        @Bean
        public GenericObjectPoolConfig getPoolConfig() {
        
            // 配置redis连接池
            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
            // 最大连接数
            poolConfig.setMaxTotal(maxIdle);
            // 允许最大空闲的连接数
            poolConfig.setMaxIdle(maxActive);
            // 允许最少空闲的连接数
            poolConfig.setMinIdle(minIdle);
            // 最大等待时间
            poolConfig.setMaxWait(Duration.ofMillis(maxWait));
            return poolConfig;
        }
    
        @Bean(name = "redisTemplate1")
        @Primary
        public RedisTemplate<String, Object> getRedisTemplate1() {
        
            return redisTemplate(1);
        }
    
        @Bean(name = "redisTemplate2")
        public RedisTemplate<String, Object> getRedisTemplate2() {
        
            return redisTemplate(2);
        }
    
        @Bean(name = "redisTemplate3")
        public RedisTemplate<String, Object> getRedisTemplate3() {
        
            return redisTemplate(3);
        }
    
        private RedisTemplate<String, Object> redisTemplate(int database) {
        
            // 构建工厂对象
            RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
            config.setHostName(host);
            config.setPort(port);
            config.setPassword(RedisPassword.of(password));
            LettucePoolingClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                    .commandTimeout(Duration.ofSeconds(timeout))
                    .poolConfig(getPoolConfig())
                    .build();
            LettuceConnectionFactory factory = new LettuceConnectionFactory(config, clientConfig);
            // 设置使用的redis数据库
            factory.setDatabase(database);
            // 重新初始化工厂
            factory.afterPropertiesSet();
    
            RedisSerializer<Object> serializer = redisSerializer();
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(factory);
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(serializer);
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(serializer);
            redisTemplate.afterPropertiesSet();
            return redisTemplate;
        }
    
        @Bean
        public RedisSerializer<Object> redisSerializer() {
        
    
            //创建JSON序列化器
            Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            //必须设置，否则无法将JSON转化为对象，会转化成Map类型
            objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
            serializer.setObjectMapper(objectMapper);
            return serializer;
        }
    
        @Bean
        public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        
            RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
            //设置Redis缓存有效期为1天
            RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                    .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer())).entryTtl(Duration.ofDays(1));
            return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
        }
    
        @Bean
        public RedisService redisService() {
        
            return new RedisServiceImpl();
        }
    }