在Java中操作Redis

依赖引入

我们在这里使用的是Spring框架中操作Redis的依赖包，他高度封装了操作Redis的API，使得我们的操作更加简便

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

RedisTemplate工具类

我们在这里操作Redis的客户端是Another，我们要在java中对redis里面的数据进行操作，要借助于RedisTemplate这个工具类。

RedisTemplate是 Spring Data Redis 提供的核心工具类，用于简化与 Redis 数据库的交互。它的作用类似于操作关系型数据库的JdbcTemplate，但专门为 Redis 设计，封装了底层复杂操作，让开发者更高效、安全地与 Redis 交互。

RedisTemplate 的核心作用

1. 连接管理

• 自动管理连接池 ：从 RedisConnectionFactory 获取连接，无需手动创建或释放连接。

• 避免资源泄漏：确保每次操作后正确归还连接到连接池。

2. 数据序列化

• Java 对象 ↔ Redis 数据格式 ：将 Java 对象（如 String、List、自定义对象等）序列化为 Redis 支持的二进制格式（或字符串），反之亦然。

• 可定制序列化器 ：默认使用 JDK 序列化（二进制），但可自定义为 JSON、字符串等格式（如 StringRedisSerializer、Jackson2JsonRedisSerializer）。

3. 执行 Redis 命令

• 封装所有 Redis 操作 ：提供 opsForValue()、opsForHash()、opsForList() 等方法，对应 Redis 的 String、Hash、List 等数据结构。

• 支持事务 ：通过 execute(SessionCallback) 支持事务操作（如 multi/exec）。

4. 异常处理

• 统一异常体系 ：将 Redis 底层异常（如 Jedis/Lettuce 抛出的异常）转换为 Spring 的 DataAccessException，便于统一处理。

如果这里不使用RedisTemplate而是直接使用Redis客户端入Jedis的话，我们就要手动的去连接Redis数据库，且要手动的释放资源

Redis的配置类

import lombok.extern.slf4j.Slf4j;
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;


@Configuration
@Slf4j
public class RedisConfiguration {


    /**
     * @return
     * 返回的是redis的模板对象RedisTemplate
     * RedisCommandFactory是redis的连接工厂
     * @Bean 注解：
     * 这个注解标识该方法是一个 Bean 定义，
     * Spring 会将返回的对象（这里是 RedisTemplate）注册为 Spring 容器中的一个 Bean，
     * 其他地方可以通过注入该 Bean 来使用它。
     *注意要使用Bean注解就要给这个类加入Configuration标签
     *
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("开始创建redis模板对象");
        RedisTemplate Template = new RedisTemplate();
        //设置redis的连接工厂对象
        Template.setConnectionFactory(redisConnectionFactory);
        //设置redis key的序列化器
        Template.setKeySerializer(new StringRedisSerializer());
        return Template;
    }
}

首先显示实力化一个RedisTemplate的对象，用于操作Redis，然后给RedisTemplate设置连接工厂，他负责管理连接的创建，释放，池化等，还有他会设置我们在配置文件里面设置的信息如端口密码等，然后是设置序列化器，这里我们设置Redis的key的序列化器，由于他当设置值在redis里面的时候默认是二进制数据，是不可读的，所以我们要设置key的序列化器来让我们可以读。

配置文件的信息

spring:
  application:
    name: Redis
  data:
    #Redis相关配置
    redis:
      host: localhost
      port: 6379
      #password: 123456
      database: 1 #操作的是1号数据库(redis存在0-15号数据库（默认），在命令中使用select来切换)

database设置的是数据库，redis默认是有16个数据库的，我们这里设置操作1号数据库。如果没有密码的话就不设置密码

字符串类型的数据操作

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

import java.util.concurrent.TimeUnit;

@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作字符串类型
     */
    @Test
    public void test() {
        ValueOperations valueOperations = redisTemplate.opsForValue();

        valueOperations.set("string1","sss");//set指令
        String object = (String) valueOperations.get("string1");//获取value
        System.out.println(object);

        //setex操作，这里是调用的set的重载方法
        valueOperations.set("string2","sss",10,TimeUnit.SECONDS);
        //setnx,会返回一个布尔值用于是否设置成功
        Boolean a = valueOperations.setIfAbsent("string3", "sss");
        System.out.println(a);
        Boolean b = valueOperations.setIfAbsent("string3", "sss");
        System.out.println(b);

    }
}

我们这里操作五种类型都要先基于RedisTemplate来操作，我们要操作字符串类型的数据就要通过这个模板里面的redisTemplate.opsForValue拿到valueOperations对象，他提供的是操作String类型数据的方法

运行结果

然后再打开客户端来查看

可以看见我们刚刚设置的三个数据已经到redis数据库里面了，可以发现我们只能读懂key而不能读懂他的value因为我们刚刚设置序列化只给key设置了，这里不建议给value序列化

Hash类型操作

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.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.List;
import java.util.Set;


@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作Hash类型
     */
    @Test
    public void test() {
        //hset hget hdel hkeys hvals这些名字在java操作的时候是有不一样的
        HashOperations hashOperations = redisTemplate.opsForHash();

        //hset，第一个是key第二个是filed，第三是value，这里的名字就是put了
        hashOperations.put("100","name","tom");
        hashOperations.put("100","age","20");

        //hget，通过key和filed得到value
        Object object = hashOperations.get("100","name");

        //hkeys封装到set集合里面
        Set keys = hashOperations.keys("100");
        //hvals封装到list集合里面
        List values = hashOperations.values("100");
        System.out.println(values);
        //hdel
        hashOperations.delete("100","age");

    }
}

运行结果

列表数据类型操作

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.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.List;
import java.util.Set;


@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作列表类型
     */
    @Test
    public void test() {
        //lpush lrange rpop llen
        ListOperations listOperations = redisTemplate.opsForList();

        //向list里面一次性推多个数据,推入多个数据的时候是先推入前面的，是有顺序的即第一个推入的是a
        listOperations.leftPushAll("mylist","a","b","c");
        //向list里面推一个数据
        listOperations.leftPush("mylist","x");

        //获取指定位置的数据
        List list = listOperations.range("mylist", 0, -1);
        System.out.println(list);

        //删除末尾的数据
        listOperations.rightPop("mylist");

        //获取list长度
        Long size = listOperations.size("mylist");
        System.out.println(size);

    }
}

无序集合操作

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.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;

import java.util.List;
import java.util.Set;


@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作无序集合类型
     */
    @Test
    public void test() {
        //sadd smembers scard sinter sunion srem
        SetOperations setOperations = redisTemplate.opsForSet();

        //add可插入多个元素，这里创建了两个集合
        setOperations.add("set1","a","b","c");
        setOperations.add("set2","x","y","z");

        //查看对应集合里面的所有元素
        Set members = setOperations.members("set1");
        System.out.println(members);

        //获取对应集合的大小
        Long size = setOperations.size("set1");
        System.out.println(size);

        //计算集合交集
        Set insert  = setOperations.intersect("set1","set2");
        System.out.println(insert);

        //计算集合并集
        Set uniomn = setOperations.union("set1","set2");
        System.out.println(uniomn);

        //删除集合里面的元素
        setOperations.remove("set1","a");

    }
}

有序集合类型操作

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

import java.util.List;
import java.util.Set;


@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作有序集合类型
     */
    @Test
    public void test() {
        //zadd zrange zincrby zrem
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        //添加元素且指定分数，最后一个是放的分数
        zSetOperations.add("zset1","a",10);

        //获取指定范围位置的长度
        Set zset = zSetOperations.range("zset1", 0, -1);
        System.out.println(zset);

        //给zset1里面的a加上delta这个增量
        zSetOperations.incrementScore("zset1","a",10);

        //删除里面的指定元素，是一个可变参数，即可以删除多个
        zSetOperations.remove("zset1","a");

    }
}

通用操作

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;


@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作有序集合类型
     */
    @Test
    public void test() {
        //keys exists type del  这里就不用再拿到某个类型对象了，直接调用redisTemplate对象里面的方法
        //获取里面所有的key
        Set keys = redisTemplate.keys("*");
        System.out.println(keys);

        //exists 这里判断redis里面是否存在这个key
        Boolean hasKey = redisTemplate.hasKey("set1");

        //判断某个key的指定类型

        for (Object key : keys) {
            //拿到key的类型对象
            DataType type  =redisTemplate.type(key);
            //通过类型对象获取key
            System.out.println(type.name());
        }
        //删除某个key
        redisTemplate.delete("mylist");

    }
}

最后

本人的第十二篇博客，以此来记录我的后端java学习。如文章中有什么问题请指出，非常感谢！！！