title: SpringBoot Redis快速集成使用
tags: redis,springboot,redisTemplate

Redis數(shù)據(jù)類型

原生能力參考runoob教程

SpringBoot 集成

pom.xml

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

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

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.51</version>
</dependency>

application.yaml 文件

spring:
  redis:
    host: localhost
    port: 6379
    database: 0

RedisConfig.java

通過比較Jackson和FastJson后選擇使用FastJson做value的序列化

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericToStringSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用 GenericFastJsonRedisSerializer 替換默認(rèn)序列化
        GenericFastJsonRedisSerializer genericFastJsonRedisSerializer = new GenericFastJsonRedisSerializer();

        // 設(shè)置key和value的序列化規(guī)則
        redisTemplate.setKeySerializer(new GenericToStringSerializer<>(Object.class));
        redisTemplate.setValueSerializer(genericFastJsonRedisSerializer);
        // 設(shè)置hashKey和hashValue的序列化規(guī)則
        redisTemplate.setHashKeySerializer(new GenericToStringSerializer<>(Object.class));
        redisTemplate.setHashValueSerializer(genericFastJsonRedisSerializer);

        // 設(shè)置支持事物
        redisTemplate.setEnableTransactionSupport(true);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

測(cè)試代碼

RedisTests.java

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.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.*;

import static junit.framework.TestCase.assertEquals;

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class RedisTests {

    /**
     * 所有操作都可以通過redisTemplate來完成
     */
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * String類型佑颇，value可以是String,Integer,Float顶掉，
     */
    @Resource(name = "redisTemplate")
    private ValueOperations<String, String> valueOperations;

    /**
     * List類型，從左或右推入挑胸、取出元素
     * 可以做先進(jìn)先出（隊(duì)列）痒筒、先進(jìn)后出操作
     */
    @Resource(name = "redisTemplate")
    private ListOperations<String, String> listOperations;

    /**
     * 存儲(chǔ)不重復(fù)的元素
     */
    @Resource(name = "redisTemplate")
    private SetOperations<String, String> setOperations;

    /**
     * 存儲(chǔ)鍵值對(duì)
     */
    @Resource(name = "redisTemplate")
    private HashOperations<String, String, String> hashOperations;

    /**
     * 有序集合，可以用于排序篩選操作
     */
    @Resource(name = "redisTemplate")
    private ZSetOperations<String, String> zSetOperations;

    @Test
    public void contextLoads() {
    }

    @Test
    public void testString() {
        String key = "string_key";
        String value = "string_value";
        // 添加
        valueOperations.set(key, value);
        
        // 查找
        assertEquals(value, valueOperations.get(key));

        // 刪除
        valueOperations.getOperations().delete(key);

        // 批量添加
        Map<String, String> map = new HashMap<>();
        map.put(key, value);
        valueOperations.multiSet(map);

        // 批量查詢
         valueOperations.multiGet(Arrays.asList(key));

        // 批量刪除
        valueOperations.getOperations().delete(Arrays.asList(key));
    }

    @Test
    public void testList() {
        String key = "list_key";
        String value = "list_value";
        // 從左側(cè)添加一個(gè)元素
        listOperations.leftPush(key, value);
        // 獲取指定索引位置的元素
        assertEquals(value, listOperations.index(key, 0));
        // 從右側(cè)取出一個(gè)元素
        assertEquals(value, listOperations.rightPop(key));

        // 批量插入
        listOperations.leftPushAll(key, value, value, value);
        listOperations.leftPushAll(key, Arrays.asList(value, value, value));

        // 刪除所有值為value的元素
        listOperations.remove(key, 0, value);

    }

    @Test
    public void testSet() {
        String key = "set_key";
        String value = "set_value";
        // 添加元素茬贵，可批量添加
        setOperations.add(key, value);
        // 查詢?cè)厥欠翊嬖?        assertEquals(Boolean.TRUE, setOperations.isMember(key, value));
        // 批量查詢
        Set<String> members = setOperations.members(key);
        assertEquals(true, members.contains(value));
        // 刪除元素簿透，可批量刪除
        setOperations.remove(key, value);
    }

    @Test
    public void testHash() {
        String key = "hash_key";
        String hash_key = "hash_hash_key";
        String hash_value = "hash_hash_value";
        // 添加，修改
        hashOperations.put(key, hash_key, hash_value);
        // 查找
        assertEquals(hash_value, hashOperations.get(key, hash_key));
        // 刪除解藻，批量刪除
        hashOperations.delete(hash_key, hash_key);

        // 批量添加
        HashMap<String, String> map = new HashMap<>();
        map.put(hash_key, hash_value);
        hashOperations.putAll(key, map);

        // 批量查找
        hashOperations.multiGet(key, Arrays.asList(hash_key));
    }

    @Test
    public void testZSet() {
        String key = "set_key";
        String value = "set_value";

        // 添加元素
        zSetOperations.add(key, value, 1.0);
        // 刪除元素
        zSetOperations.remove(key, value);
    }

}