redis学习开发（一）- 安装/启动/连接/java整合

一，Linux安装redis，启用redis服务

https://www.cnblogs.com/hunanzp/p/12304622.html

二，使用工具连接redis

在这个连接，下载工具：AnotherRedisDesktopManager 发行版 - Gitee.com

三，java代码配置使用redis

三种客户端比较
Jedis : 学习成本低，以 Redis 命令作为方法名称，但是其线程不安全

lettuce：基于 Netty 实现，支持同步、异步、响应式编程（SpringBoot），并且线程安全。支持 Redis 的哨兵模式、集群模式和管道模式。

Redisson: 基于 Redis 实现的分布式、可伸缩的 Java 数据结构集合。
 

当前工程是spring工程使用redis情况：

1，选择lettuce。

2，redis模式，选择的是单机模式。

3，初始化redisTemplate，选择人工初始化Bean

引入包：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.5.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.11.1</version>
        </dependency>
        <!-- 我们初始化的时候用到了json工具类 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.11.1</version>
        </dependency>

特别注意：我的spring 版本是4.0.0的，启动后，报了下面的异常

org/springframework/core/NativeDetector

搜索后，需要升级spring的版本，选择了5.3.6

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.6</version>
        </dependency>

再启动，又是一个异常：LettuceConnectionFactory空指针问题

这个是在将redisConnectionFactory创建的实例，set到template对象里面前，需要调用.afterPropertiesSet()方法;

LettuceConnectionFactory connectionFactory = getConnectionFactory(urlList, password);
connectionFactory.afterPropertiesSet();
redisTemplate.setConnectionFactory(connectionFactory);

再启动，好了。出来了。完整配置Bean代码：

@Configuration
@Component
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    private String password;
    private String nodes;
    @Value("${spring.redis.database}")
    private int database;
    @Value("${spring.redis.timeout}")
    private int timeOut;
    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;
    private int maxIdle;
    private int minIdle;
    @Value("${spring.redis.jedis.pool.max-wait}")
    private int maxWait;
    private int maxRedirects;

    private RedisConnectionFactory redisConnectionFactory() {
        Map<String, Object> source = new HashMap<>();
        RedisClusterConfiguration redisClusterConfiguration;
        RedisStandaloneConfiguration redisStandaloneConfiguration;
        LettuceConnectionFactory lettuceConnectionFactory;
        //连接池配置
        GenericObjectPoolConfig genericObjectPoolConfig =  new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMinIdle(minIdle);

        //redis客户端配置
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder
                builder =  LettucePoolingClientConfiguration.builder().
                commandTimeout(Duration.ofSeconds(timeOut));
        builder.poolConfig(genericObjectPoolConfig);
        LettuceClientConfiguration lettuceClientConfiguration = builder.build();

        //集群模式
        if(nodes !=null){
            source.put("spring.redis.cluster.nodes", nodes);
            source.put("spring.redis.cluster.max-redirects", maxRedirects);
            redisClusterConfiguration = new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source));
            if(!StringUtils.isEmpty(password)){
                redisClusterConfiguration.setPassword(password);
            }
            //根据配置和客户端配置创建连接
            lettuceConnectionFactory = new
                    LettuceConnectionFactory(redisClusterConfiguration,lettuceClientConfiguration);
            lettuceConnectionFactory .afterPropertiesSet();

        }else{
            //单机模式
            redisStandaloneConfiguration = new RedisStandaloneConfiguration(host,port);
            redisStandaloneConfiguration.setDatabase(database);
            if(!StringUtils.isEmpty(password)){
                redisStandaloneConfiguration.setPassword(password);
            }
            //根据配置和客户端配置创建连接工厂
            lettuceConnectionFactory = new
                    LettuceConnectionFactory(redisStandaloneConfiguration,lettuceClientConfiguration);
            lettuceConnectionFactory .afterPropertiesSet();
        }
        return lettuceConnectionFactory;
    }

    @Bean
    @Qualifier("redisTemplate")
    public RedisTemplate<String, Object> redisTemplate(){
        // 创建 RedisTemplate 对象
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory());
        // 创建 JSON 序列化工具
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 设置 key 的序列化 （用 String 类型的序列化）
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        // 设置 value 的序列化 （用 jack 类型的序列化）
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(genericJackson2JsonRedisSerializer);

        return redisTemplate;
    }
}