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個同學，到現在只剩下我一個，覺得時間過得好快，就像昨天發生的一樣，淡淡的憂傷。這里也祝兄弟在新的城市開辟新的天地！