springboot 操作redis

1. 创建springboot项目

2. 编辑配置 application.yml 文件

server:
  port: 8080

spring:
  redis:
    database: 2
    host: 127.0.0.1
    port: 6379
    password: ''
    jedis:
      pool:
        # 连接池最大连接数(使用负值表示没有限制)
        max-active: 20
        max-wait: -1
        #连接池中的最大空闲连接
        max-idle: 10
        #连接池中的最小空闲连接
        min-idle: 0
    # 连接超时时间(毫秒)
    timeout: 3000

3. 编写 redisConfig 配置,修改redis的默认序列化,默认复杂的结构存到redis会显示乱码;

package com.adley.studyspringdata.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


/**
 * @description: redis配置类
 * @author: Wzq
 * @create: 2019-10-28 17:32
 */

@Configuration
public class redisConfig {

    @Autowired
    private RedisTemplate redisTemplate;

    @Bean
    public RedisTemplate<String, Object> stringSerializerRedisTemplate() {
        RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);
        redisTemplate.setValueSerializer(stringSerializer);
        redisTemplate.setHashKeySerializer(stringSerializer);
        redisTemplate.setHashValueSerializer(stringSerializer);
        return redisTemplate;
    }
}

4. 编写单元测试 TestRedis.java

五种数据结构:

  • 字符串 string

  • 列表 list

  • 哈希 hash

  • 集合 set

  • 有序集合,带score zset

  • 发布订阅

  • 事务

package com.adley.studyspringdata;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;

import java.util.*;
import java.util.concurrent.TimeUnit;

@SpringBootTest
public class TestRedis {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void testString(){
        /**
         * set / get
         */
        redisTemplate.opsForValue().set("k11", "v11");
        Object k11 = redisTemplate.opsForValue().get("k11");
        System.out.println(k11);

        /**
         * expire
         */
        redisTemplate.opsForValue().set("k22", "v22", 30, TimeUnit.SECONDS);

        /**
         * 原子递增、递减
         * incr/decr
         * incrby/decrby 步长
         */
        redisTemplate.opsForValue().set("counter", "10000");
        redisTemplate.opsForValue().increment("counter");
        redisTemplate.opsForValue().increment("counter");
        redisTemplate.opsForValue().decrement("counter");

        System.out.println(redisTemplate.opsForValue().get("counter"));

        redisTemplate.opsForValue().increment("counter", 20);
        redisTemplate.opsForValue().increment("counter", 20);
        redisTemplate.opsForValue().decrement("counter", 30);
        System.out.println(redisTemplate.opsForValue().get("counter"));

        /**
         * 设置key过期时间
         * expire
         */
        redisTemplate.expire("counter", 30, TimeUnit.SECONDS);

        /**
         * 查看是否过期
         * 查看过期时间 单位s
         */
        try {
            Thread.currentThread().sleep(3000);
            Long counter_Expire = redisTemplate.opsForValue().getOperations().getExpire("counter");
            System.out.println(counter_Expire);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        /**
         * 判断key是否存在
         * hasKey
         */
        Boolean r_k11 = redisTemplate.hasKey("k11");
        System.out.println(r_k11); // true
        Boolean r_k12 = redisTemplate.hasKey("k12");
        System.out.println(r_k12);

        /**
         * 删除key
         */
        redisTemplate.delete("k11");
        Boolean r2_k11 = redisTemplate.hasKey("k11");
        System.out.println(r2_k11); // false
    }

    @Test
    void testList() {
        /**
         * list/array
         * lpush/rpush 区分从头插入还是从尾插入
          */
        redisTemplate.opsForList().rightPush("k33", "v33");
        redisTemplate.opsForList().rightPush("k33", "v34");
        redisTemplate.opsForList().rightPush("k33", "v34");
        redisTemplate.opsForList().rightPush("k33", "v36");

        List k33 = redisTemplate.opsForList().range("k33", 0, -1);
        System.out.println(k33);

        /**
         * 查看长度
         * llen
         */
        Long len_k33 = redisTemplate.opsForList().size("k33");
        System.out.println(len_k33);
    }

    @Test
    void testHash() {
        /**
         * hash/dict
         */
        HashMap<String, Object> map = new HashMap<>();
        map.put("aaa", "1");
        map.put("bbb", "bbbb");
        map.put("ccc", "true");

        redisTemplate.opsForHash().putAll("my_hash", map);

        /**
         * 获取变量中的值
         */
        var val = redisTemplate.opsForHash().get("my_hash", "bbb");
        System.out.println(val);

        /**
         * 获取变量中的键值对
         */
        Map map2 = redisTemplate.opsForHash().entries("my_hash");
        System.out.println(map2); // {aaa=1, ccc=true, bbb=bbbb}

        /**
         * 获取指定变量中的值列表
         */
        List list = redisTemplate.opsForHash().values("my_hash");
        System.out.println(list);

        /**
         * put
         */
        redisTemplate.opsForHash().put("my_hash", "zdy", "fjsdhfjksdhfjk");

        /**
         * size
         */
        Long size = redisTemplate.opsForHash().size("my_hash");
        System.out.println(size);

        /**
         * 查询key的set集合
         */
        Set set = redisTemplate.opsForHash().keys("my_hash");
        System.out.println(set); // [aaa, ccc, bbb, zdy]

        /**
         * 以集合的方式获取变量中的值
         */
        List<Object> list1 = new ArrayList<>();
        list1.add("aaa");
        list1.add("zdy");
        List list2 = redisTemplate.opsForHash().multiGet("my_hash", list1);
        System.out.println(list2);

        /**
         * delete 删除
         */
        redisTemplate.opsForHash().delete("my_hash", "bbb");
    }

    @Test
    void testSet() {
        /**
         * Set是string类型的无序集合。集合成员是唯一的,这就意味着集合中不能出现重复的数据
         */

        /**
         * add 添加去重
         */
        redisTemplate.opsForSet().add("my_set", "aaaaa");
        redisTemplate.opsForSet().add("my_set", "bbbbb");
        redisTemplate.opsForSet().add("my_set", "ccccc");
        redisTemplate.opsForSet().add("my_set", "bbbbb");
        redisTemplate.opsForSet().add("my_set", "ccccc");
        redisTemplate.opsForSet().add("my_set", "aaaaa");

        /**
         * members
         */
        Set my_set = redisTemplate.opsForSet().members("my_set");
        System.out.println(my_set); // [ccccc, bbbbb, aaaaa]
    }

    @Test
    void testZset() {
        /**
         * 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
         * 不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
         * 有序集合的成员是唯一的,但分数(score)却可以重复。
         */

        /**
         * zadd 添加成员 带score
         */
        ZSetOperations zset = redisTemplate.opsForZSet();
        zset.add("my_zset", "aaaa", 100);
        zset.add("my_zset", "bbbb", 67);
        zset.add("my_zset", "bbbb", 78);
        zset.add("my_zset", "cccc", 89);

        /**
         * range 获取变量指定区间的元素 排序 升序
         */
        Set set = redisTemplate.opsForZSet().range("my_zset", 0, -1);
        System.out.println(set); // [bbbb, cccc, aaaa]

        /**
         * 查询score中的值区间 [85 - 95] 之间
         */
        Set my_zset = redisTemplate.opsForZSet().rangeByScore("my_zset", 85, 95, 0, -1);
        System.out.println(my_zset);

        /**
         * count 获取score区间值的个数
         */
        Long count = redisTemplate.opsForZSet().count("my_zset", 90, 100);
        System.out.println(count); // 2

        /**
         * 查询score
         */
        Double score = redisTemplate.opsForZSet().score("my_zset", "ddd");
        System.out.println(score); // 85.0
    }
}

@Test
void testSubscribe() {
    /**
     * sub/pub 发布订阅模式
     */
    redisTemplate.convertAndSend("mychat", "This is my send msg");
    redisTemplate.convertAndSend("topic", "This is my send msg");
}

@Test
void testTransaction() {
    /**
     * 事务
     * 事务是一个单独的隔离操作:事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中,不会被其他客户端发送来的命令请求所打断。
     * 事务是一个原子操作:事务中的命令要么全部被执行,要么全部都不执行。
     * 一个事务从开始到执行会经历以下三个阶段:
     *      开始事务。
     *      命令入队。 ueued
     *      执行事务。
     */
    SessionCallback sessionCallback = new SessionCallback<>() {
        @Override
        public Object execute(RedisOperations redisOperations) throws DataAccessException {
            redisOperations.multi();

            redisTemplate.opsForValue().set("k10001", "v10001");
            String k10001 = (String) redisTemplate.opsForValue().get("k10001");
            System.out.println(k10001); // null
            SetOperations set = redisTemplate.opsForSet();
            set.add("programing_language", "javascript");
            set.add("programing_language", "java");
            set.add("programing_language", "golang");
            set.add("programing_language", "python");
            set.add("programing_language", "typescript");
            set.add("programing_language", "swift");
            set.add("programing_language", "kotlin");
            set.add("programing_language", "dart");
            set.add("programing_language", "rust");
            Set programing_language = redisTemplate.opsForSet().members("programing_language");
            System.out.println(programing_language); // []

            return redisOperations.exec();
        }
    };

    redisTemplate.execute(sessionCallback);

    System.out.println("*".repeat(100));

    String k10001 = (String) redisTemplate.opsForValue().get("k10001");
    System.out.println(k10001);

    Set programing_language = redisTemplate.opsForSet().members("programing_language");
    System.out.println(programing_language);
}


©️2020 CSDN 皮肤主题: 成长之路 设计师:Amelia_0503 返回首页