瑞吉实战22–Redis(Jedis&SpringDataRedis)

实验内容

关于redis相关api可以查看菜鸟教程的相关章节
jedis的操作非常接近原生的cmd操作，所以相关参数可以直接对照redis的api说明！
实验仅罗列常用api，非完整测试，可根据实际需要去查询即可。

一、开发环境配置

源码存放于个人github中，4575252/JedisTest: 应用jedis api进行常用api测试 (github.com)

创建java的maven工程，采用org.apache.maven.archetypes:maven-archetype-quickstart 骨架，仅带有junit~

其中相关maven坐标如下：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.8.0</version>
</dependency>

<!-- 方便做集合比对 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.3</version>
</dependency>


<!-- 应用@Log注解，方便做日志输出 -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version>
</dependency>

junit测试框架

这里应用junit的框架，在测试前后管理redis的连接请求和释放

package org.example;

import lombok.extern.java.Log;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils;
import org.apache.commons.collections4.SetUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;

import javax.swing.*;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static org.junit.Assert.*;

/***
 * @description: 测试Jedis操作api，应用于String、Hash、List、Set、ZSet的五种常见应用
 * @return:
 * @author: eric 4575252@gmail.com
 * @date: 2022-09-28, 周三, 9:23
 */
@Log
public class AppTest {
    private Jedis jedis;

    @Before
    public void setUp() throws Exception {
        jedis = new Jedis("192.168.20.147", 6379);
        jedis.auth("123456");
    }

    @After
    public void tearDown() throws Exception {
        //3 关闭连接
        jedis.close();
        jedis = null;
    }

}

二、测试string的日常操作

    /**
     * @description: 测试jedis操作string对象的常见操作，主要有存取、删除、过期设置
     * @return: void
     * @author: eric 4575252@gmail.com
     * @date: 2022-09-28, 周三, 9:16
     */
    @Test
    public void testRedisStringAPI() {
        // 数据准备
        jedis.flushDB();
        
        //1、set&get
        jedis.set("username", "zhangsan");
        assertEquals(jedis.get("username"),"zhangsan");

        //2、set超时验证
        /* 第三个参数nxxx，nx为不存在才set，xx为存在才set
         * 第四个参数expx，ex为秒，px为毫秒
         */
        jedis.set("timeout", "yes", "nx", "ex", 1);
        for (int i = 0; i < 10; i++) {
            //瞬时取10次，现有cpu设置应该能在1秒内跑完
            assertEquals(jedis.get("timeout"),"yes");
        }
        try {
            Thread.sleep(1000);     //休眠一秒
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        assertNull(jedis.get("timeout"));   //过期应为null

        //3、删除字段后验证是否
        jedis.del("username");
        assertNull(jedis.get("username"));
    }

三、测试hash类型数据的日常操作

    /**
     * @description: 测试jedis操作string对象的常见操作，主要有存取、删除、过期设置
     * @return: void
     * @author: eric 4575252@gmail.com
     * @date: 2022-09-28, 周三, 9:16
     */
    @Test
    public void testRedisStringAPI() {
        //1、set&get
        jedis.set("username", "zhangsan");
        assertEquals(jedis.get("username"),"zhangsan");

        //2、set超时验证
        /* 第三个参数nxxx，nx为不存在才set，xx为存在才set
         * 第四个参数expx，ex为秒，px为毫秒
         */
        jedis.set("timeout", "yes", "nx", "ex", 1);
        for (int i = 0; i < 10; i++) {
            //瞬时取10次，现有cpu设置应该能在1秒内跑完
            assertEquals(jedis.get("timeout"),"yes");
        }
        try {
            Thread.sleep(1000);     //休眠一秒
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        assertNull(jedis.get("timeout"));   //过期应为null

        //3、删除字段后验证是否
        jedis.del("username");
        assertNull(jedis.get("username"));
    }

四、测试list类型数据的日常操作

    @Test
    public void testRedisListAPI() {
        // 数据准备
        jedis.flushDB();
        jedis.rpush("names", "唐僧");
        jedis.rpush("names", "悟空");
        jedis.rpush("names", "八戒");
        jedis.rpush("names", "悟净");

        // 1、测试list的数据顺序是否一致
        assertTrue(ListUtils.isEqualList(jedis.lrange("names", 0, -1), Stream.of("唐僧", "悟空", "八戒", "悟净").collect(Collectors.toList())));

        // 2、测试list长度
        assertTrue(jedis.llen("names") == 4l);

        // 数据准备
        jedis.flushDB();
        jedis.lpush("scores", "99");    //lpush是从左侧、头部压入
        jedis.lpush("scores", "100");
        jedis.lpush("scores", "55");

        // 3、排序校验
        assertTrue(ListUtils.isEqualList(jedis.sort("scores"), Stream.of("55", "99", "100").collect(Collectors.toList())));

        // 4、校验移除动作，移除头部一个元素
        jedis.lpop("scores");
        assertTrue(ListUtils.isEqualList(jedis.lrange("scores",0,-1), Stream.of("100", "99").collect(Collectors.toList())));

        // 5、修改列表中单个值
        jedis.lset("scores", 0, "66");
        assertTrue(ListUtils.isEqualList(jedis.lrange("scores",0,-1), Stream.of("66", "99").collect(Collectors.toList())));


        // 6、获取列表指定下标的值
        System.out.println(jedis.lindex("scores", 1));
        assertEquals(jedis.lindex("scores", 0), "66");


        // 删除列表指定下标的值
        System.out.println(jedis.lrange("scores",0,-1));
        System.out.println(jedis.lrem("scores", 2, "99"));  //count为0则全部删除匹配的值，大于0从左往右比对，小于零从右往左，绝对值就是删除的数量。
        System.out.println(jedis.lrange("scores",0,-1));
    }

五、补充SpringDataRedis操作

源码存放于个人github中： 4575252/SpringDataRedisTest: 基于SpringDataRedis下的redisTemplate操作5种常见数据类型 (github.com)

在springboot工程中，采用springdataRedis组件，应用redisTemplate模板操作redis是非常容易的，以下是过程：

1、maven坐标


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


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

2、application.yml配置信息

spring:
    application:
        name: springdataredis_demo
    #Redis相关配置 1234
    redis:
        host: 192.168.20.147
        port: 6379
        password: 123456
        database: 0 #操作的是0号数据库
        jedis:
            #Redis连接池配置
            pool:
                max-active: 8 #最大连接数
                max-wait: 1ms #连接池最大阻塞等待时间
                max-idle: 4 #连接池中的最大空闲连接
                min-idle: 0 #连接池中的最小空闲连接

3、redisConfig配置类

这里替换了key序列化器，方便redis客户端查看key信息，而不是显示uicode，如 \xac\xed\x00

package com.iyyxx.springdataredistest.config;

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.StringRedisSerializer;

/**
 * @className: RedisConfig
 * @description: TODO 类描述
 * @author: eric 4575252@gmail.com
 * @date: 2022/9/28/0028 12:03:32
 **/
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<Object, Object>
    redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        //默认的Key序列化器为：JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}

4、测试类

对string、hash、list、set、zset五种数据类型，和通用操作方法共6中常见操作做了演示！

package com.iyyxx.springdataredistest;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
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.connection.DataType;
import org.springframework.data.redis.core.*;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@SpringBootTest
class SpringDataRedisTestApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @BeforeEach
    void setUp() {
        redisTemplate.getConnectionFactory().getConnection().flushDb();
    }

    @AfterEach
    void tearDown() {
//        redisTemplate.getConnectionFactory().getConnection().flushDb();
    }

    /**
     * 操作String类型数据
     */
    @Test
    public void testString() {
        //存值
        redisTemplate.opsForValue().set("city123", "beijing");
        //取值
        String value = (String) redisTemplate.opsForValue().get("city123");
        System.out.println(value);


        //存值，同时设置过期时间
        redisTemplate.opsForValue().set("key1", "value1", 10l, TimeUnit.SECONDS);
        //存值，如果存在则不执行任何操作
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("city1234", "nanjing");
        System.out.println(aBoolean);
    }

    /**
     * 操作Hash类型数据
     */
    @Test
    public void testHash() {
        HashOperations hashOperations = redisTemplate.opsForHash();
        //存值
        hashOperations.put("002", "name", "xiaoming");
        hashOperations.put("002", "age", "20");
        hashOperations.put("002", "address", "bj");
        //取值
        String age = (String) hashOperations.get("002", "age");
        System.out.println(age);
        //获得hash结构中的所有字段
        Set keys = hashOperations.keys("002");
        for (Object key : keys) {
            System.out.println(key);
        }
        //获得hash结构中的所有值
        List values = hashOperations.values("002");
        for (Object value : values) {
            System.out.println(value);
        }
    }

    /**
     * 操作List类型的数据
     */
    @Test
    public void testList() {
        ListOperations listOperations = redisTemplate.opsForList();
        //存值
        listOperations.leftPush("mylist", "a");
        listOperations.leftPushAll("mylist", "b", "c", "d");
        //取值
        List<String> mylist = listOperations.range("mylist", 0, -1);
        for (String value : mylist) {
            System.out.println(value);
        }
        //获得列表长度 llen
        Long size = listOperations.size("mylist");
        int lSize = size.intValue();
        for (int i = 0; i < lSize; i++) {
            //出队列
            String element = (String) listOperations.rightPop("mylist");
            System.out.println(element);
        }
    }

    /**
     * 操作Set类型的数据
     */
    @Test
    public void testSet() {
        SetOperations setOperations = redisTemplate.opsForSet();

        //存值
        setOperations.add("myset", "a", "b", "c", "a");

        //取值
        Set<String> myset = setOperations.members("myset");
        for (String o : myset) {
            System.out.println(o);
        }

        //删除成员
        setOperations.remove("myset", "a", "b");

        //取值
        myset = setOperations.members("myset");
        for (String o : myset) {
            System.out.println(o);
        }
    }

    /**
     * 操作ZSet类型的数据
     */
    @Test
    public void testZset() {
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        //存值
        zSetOperations.add("myZset", "a", 10.0);
        zSetOperations.add("myZset", "b", 11.0);
        zSetOperations.add("myZset", "c", 12.0);
        zSetOperations.add("myZset", "a", 13.0);
        //取值
        Set<String> myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }

        //修改分数
        zSetOperations.incrementScore("myZset", "b", 20.0);
        //取值
        myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }
        //删除成员
        zSetOperations.remove("myZset", "a", "b");
        //取值
        myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }
    }

    /**
     * 通用操作，针对不同的数据类型都可以操作
     */
    @Test
    public void testCommon() {
        //获取Redis中所有的key
        Set<String> keys = redisTemplate.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }
        //判断某个key是否存在
        Boolean itcast = redisTemplate.hasKey("city1234");
        System.out.println(itcast);
        //删除指定key
        redisTemplate.delete("myZset");
        //获取指定key对应的value的数据类型
        DataType dataType = redisTemplate.type("myset");
        System.out.println(dataType.name());
    }
}

分享技术，品味人生

瑞吉实战22-Redis开发