springboot redis

package com.example.demo.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.*;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.List;

import static io.lettuce.core.ReadFrom.SLAVE_PREFERRED;

/**
 * @Description :
 * @Date 2018/12/31 18:14
 * @Author lishuo
 **/
@Configuration
public class RedisConfig {


    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration("hostname", 6379);
        return new JedisConnectionFactory(config);
    }


    /**
     * 基于netty实现的ConnectionFactory
     * 产生的LettuceConnection实例共享相同的非事务，非阻塞的本地的线程安全连接
     * 如果每次要专门用同一个连接那么将  shareNativeConnection 设置为 false.这样的话也可以连接池LettucePool
     * @return
     */
    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory() {

        return new LettuceConnectionFactory(new RedisStandaloneConfiguration("server", 6379));
    }

    /**
     * 如果有主从则可以分别配置
     * @return
     */
    @Bean
    public LettuceConnectionFactory redisConnectionFactory2() {
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder().build();
        RedisStandaloneConfiguration serverConfig = new RedisStandaloneConfiguration("server", 6379);
        return new LettuceConnectionFactory(serverConfig, clientConfig);
    }

    /**
     * Jedis  配置哨兵
     */
    @Bean
    public RedisConnectionFactory jedisConnectionFactory() {
        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
                .master("mymaster")
                .sentinel("127.0.0.1", 26379)
                .sentinel("127.0.0.1", 26380);
        return new JedisConnectionFactory(sentinelConfig);
    }

    /**
     * Lettuce  配置哨兵
     */
    @Bean
    public RedisConnectionFactory lettuceConnectionFactory2() {
        RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
                .master("mymaster")
                .sentinel("127.0.0.1", 26379)
                .sentinel("127.0.0.1", 26380);
        return new LettuceConnectionFactory(sentinelConfig);
    }

    /**
     * 有时，需要与其中一个Sentinels直接交互。使用RedisConnectionFactory.getSentinelConnection()
     * 或RedisConnection.getSentinelCommands()允许您访问配置的第一个活动Sentinel。
     *
     * 也可以通过配置文件配置
     * spring.redis.sentinel.master: name of the master node.
     * spring.redis.sentinel.nodes: Comma delimited list of host:port pairs.
     *
     * RedisConnection负责处理二进制信息  byteArray
     * RedisTemplate负责序列化和连接管理  是线程安全的
     *
     * 大多数情况下使用的是Java的序列化，也可以使用其提供的序列化机制。
     *
     * 也可以不用序列化，设置为null。
     *
     * 将enableDefaultSerializer 设置为false，那么RedisTemplate将使用原生的byte arrays
     */


    /**
     * 也提供了StringRedisConnection，StringRedisTemplate 底层都是用了StringRedisSerializer
     */
    @Autowired
    private StringRedisTemplate redisTemplate;


    /**
     * StringRedisTemplate 被使用的时候还可以接受一个回调
     * 回调接受参数为StringRedisConnection 实例
     */
    public void useCallback() {
        redisTemplate.execute(new RedisCallback<Object>() {
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                Long size = connection.dbSize();
                // Can cast to StringRedisConnection if using a StringRedisTemplate
                ((StringRedisConnection)connection).set("key", "value");
                return null;
            }
        });
    }


    /**
     * 开启集群
     * 也可以配置
     * spring.redis.cluster.nodes：逗号分隔的主机：端口对列表。
     * spring.redis.cluster.max-redirects：允许的群集重定向数
     */
    @Component
    @ConfigurationProperties(prefix = "spring.redis.cluster")
    public class ClusterConfigurationProperties {

        /*
         * spring.redis.cluster.nodes[0] = 127.0.0.1:7379
         * spring.redis.cluster.nodes[1] = 127.0.0.1:7380
         * ...
         */
        List<String> nodes;

        /**
         * Get initial collection of known cluster nodes in format {@code host:port}.
         *
         * @return
         */
        public List<String> getNodes() {
            return nodes;
        }

        public void setNodes(List<String> nodes) {
            this.nodes = nodes;
        }
    }

    @Configuration
    public class AppConfig {

        /**
         * Type safe representation of application.properties
         */
        @Autowired ClusterConfigurationProperties clusterProperties;

        public @Bean RedisConnectionFactory connectionFactory() {

            return new JedisConnectionFactory(
                    new RedisClusterConfiguration(clusterProperties.getNodes()));
        }
    }



}