SpringBoot2.x集成Redis (StringTemplate與redisTemplate的用法)

1. Redis介紹
Redis數據庫是一個完全開源免費的高性能Key-Value數據庫。它支持存儲的value類型有五種，包括string(字符串)、list(鏈表)、set(集合)、zset(sorted set –有序集合)和hash（哈希類型）

Redis非常快，每秒可執行大約110000次的設置(SET)操作，每秒大約可執行81000次的讀取/獲取(GET)操作。

2. 開發工具
IDEA、Maven、SpringBoot2.0.4、Jdk1.8、Redis3.2.100、PostMan

3. 配置
3.1 說明
spring 封裝了兩種不同的對象來進行對redis的各種操作，分別是StringTemplate與redisTemplate。

兩者的關系是StringRedisTemplate繼承RedisTemplate。
兩者的數據是不共通的；也就是說StringRedisTemplate只能管理StringRedisTemplate里面的數據，RedisTemplate只能管理RedisTemplate中的數據。
SDR默認采用的序列化策略有兩種，一種是String的序列化策略，一種是JDK的序列化策略。
StringRedisTemplate默認采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。
RedisTemplate默認采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。
其實通俗的來講：

當你的redis數據庫里面本來存的是字符串數據或者你要存取的數據就是字符串類型數據的時候，那么你就使用StringRedisTemplate即可。

但是如果你的數據是復雜的對象類型，而取出的時候又不想做任何的數據轉換，直接從Redis里面取出一個對象，那么使用RedisTemplate是
更好的選擇。

3.2 StringRedisTemple

Maven配置

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

yml配置文件

server:
  port: 8080

spring:
  application:
    name: spirng-boot-redis
  redis:
    host: 127.0.0.1
    timeout: 3000
    password: 123456
    port: 6379
    database: 0
    jedis:
      pool:
        max-active: 8 # 連接池最大連接數（使用負值表示沒有限制）
        max-idle: 8   # 連接池中的最大空閑連接
        max-wait: -1  # 連接池最大阻塞等待時間（使用負值表示沒有限制)
        min-idle: 0   # 連接池中的最小空閑連接

Service業務實現

創建StringRedisService

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

/**
 * redis業務*/
@Service
public class StringRedisService {
    private static final Logger logger = LoggerFactory.getLogger(StringRedisService.class);
    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    public  void setString(String key, String value){
        logger.info("--------------------->[Redis set start]");
        stringRedisTemplate.opsForValue().set(key,value);
    }

    public String getString(String key){
        logger.info("--------------------->[Redis get start]");
        return  stringRedisTemplate.opsForValue().get(key);
    }
}

測試

測試代碼：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class StringRedisServiceTest {

    @Autowired
    StringRedisService stringRedisService;

    @Test
    public void set() {
        stringRedisService.setString("name","張三");
    }

    @Test
    public void get(){
        System.out.println(stringRedisService.getString("name"));
    }
}

3.3 RedisTemple

當我們的數據是復雜的對象類型，那么可以采用RedisTemple

手動配置

首先我們需要手動創建Redis的配置類，來自定義序列化

@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport {
    private static final Logger logger = LoggerFactory.getLogger(RedisConfiguration.class);


    /**
     * redis模板，存儲關鍵字是字符串，值jackson2JsonRedisSerializer是序列化后的值
     * @param
     * @return org.springframework.data.redis.core.RedisTemplate*/
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        //使用Jackson2JsonRedisSerializer來序列化和反序列化redis的value值（默認使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        //使用StringRedisSerializer來序列化和反序列化redis的key值
        RedisSerializer redisSerializer = new StringRedisSerializer();
        //key
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);
        //value
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

定義User實體類

注意：這里必須實現序列化接口

import java.io.Serializable;

public class User implements Serializable {

    private static final long serialVersionUID = -8289770787953160443L;

    private String userName;
    private Integer age;

    public User(String userName, Integer age) {
        this.userName = userName;
        this.age = age;
    }

    public User() {
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}

Service方法
RedisTemplate中定義了對5種數據結構操作：

　　redisTemplate.opsForValue() ：操作字符串
　　redisTemplate.opsForHash() ：操作hash
　　redisTemplate.opsForList() ：操作list
　　redisTemplate.opsForSet() ：操作set
　　redisTemplate.opsForZSet() ：操作有序set

創建RedisService類

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

/**
 * redisTemple 的Service類
 */
@Service
public class RedisService {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    public void setObj(String key,User value) {
        redisTemplate.opsForValue().set(key,value);
    }

    public User getObj(String key) {
        return (User)redisTemplate.opsForValue().get(key);
    }
}

測試類

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisServiceTest {

    @Autowired
    private RedisService redisService;

    @Test
    public void setObj() {
        redisService.setObj("user",new User("小明",22));
        User user = redisService.getObj("user");
        System.out.println(user.toString());
    }

    @Test
    public void getObj() {
        User user = redisService.getObj("user");
        System.out.println(user.toString());
    }
}

至此，基礎配置已完成。redis還可以解決很多關系型數據庫所不能解決的問題，可以實現緩存，可以實現持久化、可以做分布式鎖等等。