根据配置RedisProperties自动获取RedisConnectionFactory

#单点配置

spring.redis.host=192.168.1.1

spring.redis.port=6379

#哨兵配置

#spring.redis.sentinel.master=common

#spring.redis.sentinel.nodes=192.168.1.84:26379,192.168.1.85:26379

#spring.redis.password=123456

#集群配置

#spring.redis.cluster.nodes=192.168.1.24:6389,192.168.1.24:6479,192.168.1.24:6579

#spring.redis.password=123456

1.增加依赖

     <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-redis</artifactId>

            <version>1.5.2.RELEASE</version>

        </dependency>

1. org.springframework.boot.autoconfigure.data.redis.RedisProperties 会根据配置自动加载为一个bean

@ConfigurationProperties(prefix = "spring.redis")

2.RedisConfig

import com.google.common.base.Strings;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.autoconfigure.data.redis.RedisProperties;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.connection.RedisClusterConfiguration;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.RedisNode;

import org.springframework.data.redis.connection.RedisSentinelConfiguration;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.StringRedisTemplate;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import org.springframework.util.Assert;

import org.springframework.util.StringUtils;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Set;

import java.util.stream.Collectors;

import lombok.extern.slf4j.Slf4j;

import redis.clients.jedis.HostAndPort;

import redis.clients.jedis.JedisCluster;

import redis.clients.jedis.JedisPoolConfig;

/**

 * Redis配置类

 */

@Slf4j

@Configuration

public class RedisConfig {

    @Bean(name = "JedisConnectionFactory")

    public JedisConnectionFactory createJedisConnectionFactory(RedisProperties properties,

            JedisPoolConfig poolConfig) {

        JedisConnectionFactory factory;

        RedisSentinelConfiguration sentinelConfig = getSentinelConfiguration(properties);

        RedisClusterConfiguration clusterConfiguration = getClusterConfiguration(properties);

        if (sentinelConfig != null) {

            factory = new JedisConnectionFactory(sentinelConfig, poolConfig);

        } else if (clusterConfiguration != null) {

            factory = new JedisConnectionFactory(clusterConfiguration, poolConfig);

        } else {

            factory = new JedisConnectionFactory(poolConfig);

            factory.setHostName(properties.getHost());

            factory.setPort(properties.getPort());

            factory.setDatabase(properties.getDatabase());

        }

        if (!Strings.isNullOrEmpty(properties.getPassword())) {

            factory.setPassword(properties.getPassword());

        }

        return factory;

    }

    @Bean(name = "RedisConnectionFactory")

    @Autowired

    public RedisConnectionFactory createRedisConnectionFactory(

            @Qualifier("JedisConnectionFactory") JedisConnectionFactory

                    factory) {

        return factory;

    }

    private static List<RedisNode> createSentinels(RedisProperties.Sentinel sentinel) {

        List<RedisNode> nodes = new ArrayList<>();

        for (String node : StringUtils.commaDelimitedListToStringArray(sentinel.getNodes())) {

            String[] parts = StringUtils.split(node, ":");

            Assert.state(parts.length == 2, "redis哨兵地址配置不合法！");

            nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1])));

        }

        return nodes;

    }

    private static RedisSentinelConfiguration getSentinelConfiguration(RedisProperties properties) {

        RedisProperties.Sentinel sentinel = properties.getSentinel();

        if (sentinel != null) {

            RedisSentinelConfiguration config = new RedisSentinelConfiguration();

            config.master(sentinel.getMaster());

            config.setSentinels(createSentinels(sentinel));

            return config;

        }

        return null;

    }

    private static RedisClusterConfiguration getClusterConfiguration(RedisProperties properties) {

        RedisProperties.Cluster cluster = properties.getCluster();

        if (cluster != null) {

            RedisClusterConfiguration config = new RedisClusterConfiguration(cluster.getNodes());

            if (cluster.getMaxRedirects() != null) {

                config.setMaxRedirects(cluster.getMaxRedirects());

            }

            return config;

        }

        return null;

    }

    @Bean

    @Autowired

    public RedisTemplate<String, Object> redisTemplate(@Qualifier("RedisConnectionFactory") RedisConnectionFactory

            connectionFactory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();

        template.setConnectionFactory(connectionFactory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）

        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();

        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        serializer.setObjectMapper(mapper);

        template.setValueSerializer(serializer);

        //使用StringRedisSerializer来序列化和反序列化redis的key值

        template.setKeySerializer(new StringRedisSerializer());

        template.afterPropertiesSet();

        return template;

    }

    @Bean

    public StringRedisTemplate stringRedisTemplate(

            @Qualifier("RedisConnectionFactory") RedisConnectionFactory factory) {

        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();

        stringRedisTemplate.setConnectionFactory(factory);

        return stringRedisTemplate;

    }

    /**

     * jedisCluster

     */

    @Bean

    @Autowired

    public JedisCluster jedisCluster(@Qualifier("jedis.pool.config") JedisPoolConfig config,

            @Value("${spring.redis.cluster.nodes}") String hostAndPort,

            @Value("${spring.redis.password}") String password) {

        /**

         * 1 先检查redis集群是否已经配置

         */

        if (StringUtils.isEmpty(hostAndPort)) {

            throw new RuntimeException("Redis 集群初始化异常。请检查配置redis.host.address配置项");

        }

        /**

         * 2 根据配置构建hostAndPorts

         */

        Set<HostAndPort> hostAndPorts = Arrays.asList(hostAndPort.split(",")).stream().map(s -> {

            String[] split = s.split(":");

            return new HostAndPort(split[0], Integer.valueOf(split[1]));

        }).collect(Collectors.toSet());

        return new JedisCluster(hostAndPorts, 1000, 1000, 1, password, config);

    }

    @Bean(name = "jedis.pool.config")

    public JedisPoolConfig jedisPoolConfig(@Value("${jedis.pool.config.maxTotal:100}") int maxTotal,

            @Value("${jedis.pool.config.maxWaitMillis:5000}") int maxWaitMillis,

            @Value("${jedis.pool.config.maxIdle:10}") int maxIdle) {

        JedisPoolConfig config = new JedisPoolConfig();

        config.setMaxTotal(maxTotal);

        config.setMaxIdle(maxIdle);

        config.setMaxWaitMillis(maxWaitMillis);

        return config;

    }

}

3.使用方式

   @Autowired

    private RedisTemplate<String,Object> redisTemplate;

    // 操作String类型

    redisTemplate.opsForValue().set("key","v1");

4.其他类型的获取

// hash结构

redisTemplate.opsForHash();

//set 结构

redisTemplate.opsForSet();

// sortedset

redisTemplate.opsForZSet();

//list

redisTemplate.opsForList();

5. key类的操作

public boolean existsKey(String key) {

        return redisTemplate.hasKey(key);

}

/**

     * 删除key

     *

     * @param key

*/

 public void deleteKey(String key) {

        redisTemplate.delete(key);

}

/**

     * 设置key的生命周期

     *

     * @param key

     * @param time

     * @param timeUnit

*/

public void expireKey(String key, long time, TimeUnit timeUnit)

        redisTemplate.expire(key, time, timeUnit);

}

巴特西

根据配置RedisProperties自动获取RedisConnectionFactory

最新文章

热门文章