SpringBoot之使用Lettuce集成Redis

一、Lettuce

Redis这里就不多说,服务端的启动之前的博客里面也有提到，这里略过。Lettuce和Jedis都是连接Redis Server的客户端程序，Jedis在实现上是直连redis server，多线程环境下非线程安全，除非使用连接池，为每个Jedis实例线程间并发访问，且线程安全，满足多线程环境下的并发访问，同时它是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。

二、maven依赖

还是按照原来的步骤，先是导入依赖，然后配置属性，最后实例，其实使用springboot都是差不多的步骤。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

三、属性配置

这里使用的是lettuce，如果使用Jedis，把下面的lettuce改成Jedis就好。

spring.redis.host=127.0.0.1

spring.redis.password= 

spring.redis.port= 6379

spring.redis.timeout=1000

spring.redis.database=0

spring.redis.lettuce.pool.min-idle=0

spring.redis.lettuce.pool.max-idle=8

spring.redis.lettuce.pool.max-wait=-1ms

spring.redis.lettuce.pool.max-active=8

四、实例

这里还是在之前demo的基础上进行修改.默认情况下的模板只能支持StringRedisTemplate<String,String>，只能存字符串。这时需要自定义模板，当自定义模板后又想存储String字符串时，可以使用RedisTemplate的方式，他们俩并不冲突。在RedisCacheAutoConfiguration中自定义了一个RedisTemplate。

package com.example.config;

import java.io.Serializable;

import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisCacheAutoConfiguration {
    @Bean
    public RedisTemplate<String, Serializable> redisCacheTemplate(LettuceConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Serializable> template = new RedisTemplate<>();
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

在User类中增加了构造函数。

package com.example.model;

import java.io.Serializable;

public class User implements Serializable{
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return  "User [id=" + Id + ", name=" + Name + ", age=" + Age + "]";

    }

    public User(String id, String name, int age, UserSexEnum sex) {
        super();
        Id = id;
        Name = name;
        Age = age;
        Sex = sex;
    }

    public User() {
        super();
        // TODO Auto-generated constructor stub
    }

    public String getId() {
        return Id;
    }
    public void setId(String id) {
        Id = id;
    }
    public String getName() {
        return Name;
    }
    public void setName(String name) {
        Name = name;
    }
    public int getAge() {
        return Age;
    }
    public void setAge(int age) {
        Age = age;
    }
    private String Id;
    private String Name;
    private int Age;
    private UserSexEnum Sex;
    public UserSexEnum getSex() {
        return Sex;
    }

    public void setSex(UserSexEnum sex) {
        Sex = sex;
    }

}

修改之前demo中的UserController,在里面注入StringRedisTemplate和RedisTemplate用来测试。增加的主要代码是39-46行处。

package com.example.demo;

import java.io.Serializable;
import java.util.List;

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.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.example.model.User;
import com.example.model.UserSexEnum;
import com.example.read.mapper.ReadUserMapper;
import com.example.write.mapper.WriteUserMapper;

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private WriteUserMapper userMapperWrite;

    @Autowired
    private ReadUserMapper userMapperRead;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate<String, Serializable> redisCacheTemplate;

    @RequestMapping(value = "/alluser.do",method = RequestMethod.GET)
    public String getallusers(Model model) {
       List<User> users=userMapperRead.getAll();
       model.addAttribute("users", users);
       stringRedisTemplate.opsForValue().set("keytest", "cuiyw");
       final String keytest = stringRedisTemplate.opsForValue().get("keytest");
       model.addAttribute("keytest", keytest);
       String key = "1857XXXX040";
       redisCacheTemplate.opsForValue().set(key, new User(key, "cuiyw", 18, UserSexEnum.MAN));
       // TODO 对应 String（字符串）
       final User user = (User) redisCacheTemplate.opsForValue().get(key);
       model.addAttribute("user", user);
       return "userlist";
    }
    @RequestMapping(value = "/insert.do",method = RequestMethod.GET)
    public String adduser(Model model) {
       User user=new User();
       user.setName("cuiyw");
       user.setAge(27);
       userMapperWrite.insert(user);
       List<User> users=userMapperWrite.getAll();
       model.addAttribute("users", users);
       return "userlist";
    }
}

打开url:http://localhost:8080/user/alluser.do,可以看到从redis获取的String类型的key和User对象。

五、错误

这里在打开url时报了一个redis连接超时的错误io.lettuce.core.RedisCommandTimeoutException: Command timed out，我开始以为是设置的timeout太小导致的，可我设置到10000时还是报错，后来又回顾了下之前redis server启动的方法，启动时增加redis.windows.conf,使用redis-server.exe redis.windows.conf启动后居然可以了，可能是我之前双击启动有问题导致的。

这里只是实现Redis的简单使用，在实际项目中还要有集群以及结合cache来一起使用的场景，后续再慢慢补充。

周末兄弟离开深圳，现在只剩我一个，想想三哥们一起从漯河分开,一个为了爱情去了重庆，我们两个一起来的深圳，在从之前5个同学，到现在只剩下我一个，觉得时间过得好快，就像昨天发生的一样，淡淡的忧伤。这里也祝兄弟在新的城市开辟新的天地！