Java操作redis

目录

一：Jedis

二：使用Spring Data Redis

Redis 的 Java 客户端很多，官方推荐的有三种：

1.Jedis

2.Lettuce

3.Redisson

同时，Spring 对 Redis 客户端进行了整合，提供了 Spring Data Redis，在Spring Boot项目中还提供了对应的Starter，即 spring-boot-starter-data-redis。

一：Jedis

使用jedis操作redis有以下的优点和缺点

使用Jedis操作Redis的优点有：

1. 简单易用：Jedis是一个简单而直观的Java库，易于使用和理解。
2. 性能高：Jedis使用基于套接字的连接，并通过连接池来管理连接，因此在处理高并发请求时表现出色。
3. 多功能：Jedis支持Redis的所有数据类型和命令，可以用于各种不同的应用场景。
4. 可扩展性好：Jedis可以与其他框架和工具集成，如Spring和Hibernate等，以支持更复杂的应用需求。
5. 社区支持：Jedis是一个流行的Redis Java客户端，有一个活跃的社区，提供了许多示例代码和解决方案。

使用Jedis操作Redis的缺点包括：

1. 需要手动管理连接池：由于Jedis使用连接池来管理与Redis的连接，因此需要手动管理连接池的大小和连接的获取和释放。
2. 不支持异步操作：Jedis不支持异步操作，所有操作都是同步的，可能会阻塞线程。
3. 执行命令的方式有限：Jedis只支持将命令以字符串的形式传递给Redis，不支持类似构建器模式的方式来构建和执行命令。
4. 对象序列化的开销：Jedis将Java对象序列化为字节数组存储到Redis中，因此会产生额外的开销。

具体操作如下： 

1.导入Maven坐标

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

2.常用方法

注意：在jedis中每个方法名就其实就是在redis客户端操作的命令名称，并且在每次访问Redis数据库的时候，都需要创建一个Jedis对象。每个Jedis对象似于JDBC中Connection对象。

 3.案例分析：

1.例如在Java中用jedis操作redis的String数据类型

/**
 * @author: dlwlrma
 * @data 2024年06月14日 16:18
 * @Description: TODO:用java操作redis 使用jedis操作String数据类型
 */
public class jedis {

    /**
     *
     * @author dlwlrma
     * @date 2024/6/14 16:31
     * TODO: 使用jedis操作String类型数
     */
    @Test
    public void testJedis(){
        //1.建立连接 输入在linux上的redis的ip地址，端口号为固定端口号：6379
        Jedis jedis = new Jedis("192.168.81.129", 6379);

        //2.使用jedis对象调用方法向redis中存储字符串数据
        String set = jedis.set("NBA", "斯蒂芬库里");
        System.out.println("set = " + set);

        //3.获取数据
        String nba = jedis.get("NBA");
        System.out.println("nba = " + nba);

        //4.释放资源
        jedis.close();

    }
}

2.在Java中用jedis操作redis的hash数据类型

import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.Map;

/**
 * @author: dlwlrma
 * @data 2024年06月14日 16:18
 * @Description: TODO:用java操作redis 使用jedis
 */
public class jedis {

    /**
     *
     * @author dlwlrma
     * @date 2024/6/14 16:31
     * TODO: 使用jedis操作hash类型数据
     */
    @Test
    public void testHash(){
        //1.建立连接 输入在linux上的redis的ip地址，端口号为固定端口号：6379
        Jedis jedis = new Jedis("192.168.81.129", 6379);

        //2.使用jedis操作hash类型数据
        Long hset = jedis.hset("第一号", "鼠标", "3");
        Long hset2 = jedis.hset("第二号", "水杯", "5");
        //返回的是操作的个数
        System.out.println("hset = " + hset);

        //3.获取存入的hash数据
        Map<String, String> map = jedis.hgetAll("第一号");
        //遍历map集合
        map.forEach((filed,value)->{
            System.out.println(filed+"---------"+value);
        });

        Map<String, String> map2 = jedis.hgetAll("第二号");
        //遍历map集合
        map2.forEach((filed1,value1)->{
            System.out.println(filed1+"---------"+value1);
        });

        //4.释放资源
        jedis.close();
    }

}

二：使用Spring Data Redis

官网网址：Spring Data Redis

1.导入相应的maven坐标

<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-redis</artifactId>
	<version>2.4.8</version>
</dependency>

2.Spring Data Redis中提供了一个高度封装的类：RedisTemplate，针对类似 Jedis 客户端中大量api进行了归类封装,将同一类型操作封装为operation接口，具体分类如下：

• ValueOperations：简单K-V操作(String类型)

• SetOperations：set类型数据操作

• ZSetOperations：zset类型数据操作

• HashOperations：针对hash类型的数据操作

• ListOperations：针对list类型的数据操作

3.案例分析：

注意：在进行代码测试的时候，在springboot项目中要编写一个redis的配置类，是为了防止在redis客户端访问时出现一下情况：

配置类如下：（注意:一定要放在和APP,即springboot启动类同一级目录上，即建立一个config的包，存放一些项目的配置类） 

import org.springframework.cache.annotation.CachingConfigurerSupport;
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;

/**
 *
 * @author dlwlrma
 * @date 2024/6/14 16:45
 * @param
 * @return null
 * TODO:这是表明为redis的配置类，解决的是redis底层默认的以JdkSerializationRedisSerializer的序列化操作转换为以StringRedisSerializer的序列化
 *      可以在redis的客户端可以看到存入的中文数据
 */
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    /*
        1.RedisConnectionFactory 是获取RedisConnection对象的，RedisConnection相当于jdbc中的连接对象Connection表示和
            Redis进行连接
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        //创建Redis模板对象
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        //默认的Key序列化器为：JdkSerializationRedisSerializer
        //StringRedisSerializer支持字符串类型的转化，而且默认使用UTF-8编码
        //下面代码的意思是使用StringRedisSerializer序列化器替换默认的Key序列化器JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
		
		redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());

        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }

}

在springboot的资源下，去配置redis

 配置application.yml

spring:
  #Redis相关配置
  redis:
    host: 192.168.81.129 #注意:这是我在linux系统下的ip地址
    port: 6379
    database: 0 #操作的是0号数据库

3.1使用spring data redis操作的方式进行String类型数据的操作

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 SpringDataRedisTest {

    //自动注入
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 操作String类型的数据
     */
    @Test
    public void test01String(){
        /**
         *
         * @author dlwlrma
         * @date 2024/6/14 16:01
         * TODO ：需求：
         *            1.存入数据和取出数据
         *            2.存值并设置过期时间
         *            3.如果存在值则不执行任何操作
         *
         */
        //根据redisTemplate模板类获取操作String类型的ops接口对象
        ValueOperations ops = redisTemplate.opsForValue();
        //1.存入String类型的数据
        ops.set("username","zhangsan");
        Object username = ops.get("username");
        System.out.println("username = " + username);

        //2.存值并设置过期时间
        //使用valueOperations调用方法设置过期时间
        //TimeUnit.MINUTES 为枚举类型，意味着是秒的单位
        //若key一样则会覆盖value的值（key唯一）
        ops.set("地点","上海",10, TimeUnit.MINUTES);
        Object object = ops.get("地点");
        System.out.println("object = " + object);

        //3.如果存在值则不执行任何操作
        //setIfAbsent 表示如果值不存在则存储，如果存在则不存储
        Boolean absent = ops.setIfAbsent("age", "18");
        System.out.println("absent = " + absent);
        //setIfPresent: 表示如果存在则执行代码将数据覆盖之前的value值，如果不存在则不执行代码
        Boolean present = ops.setIfPresent("age","男");
        System.out.println("present = " + present);

    }
    /**
     * 操作hash类型的数据
     */

3.2使用spring data redis操作的方式进行hash类型数据的操作

/**
     * 操作hash类型的数据
     */
    @Test
    public void test02Hash(){
        /**
         *
         * @author dlwlrma
         * @date 2024/6/15 15:47
         * TODO:需求：1.存储几个哈希类型的数据
         *           2.获取哈希类型的数据
         *           3.根据键获取哈希类型中的所有字段
         *           4.获得hash结构中的所有值
         */

        //获取执行hash操作的接口对象
        HashOperations hashOperations = redisTemplate.opsForHash();
        //1.存储几个哈希类型的数据
        hashOperations.put("大学","数计学院","1个");
        hashOperations.put("大学","艺术学院","1个");
        hashOperations.put("大学","法学学院","1个");

        //2.获取哈希类型的数据
        Object o = hashOperations.get("大学", "数计学院");
        System.out.println("o = " + o);
        Object o1 = hashOperations.get("大学", "艺术学院");
        System.out.println("o1 = " + o1);

        //3.根据键获取哈希类型中的所有字段
        Set keys = hashOperations.keys("大学");
        //返回值类型为set集合类，因此用增强for遍历集合
        for (Object key : keys) {
            System.out.println("key = " + key);
        }

        //4.获得hash结构中的所有值
        List list = hashOperations.values("大学");
        for (Object object : list) {
            System.out.println("object = " + object);
        }

    }

3.3使用spring data redis操作的方式进行list类型数据的操作

/**
     * 操作List类型的数据
     */
    @Test
    public void testList(){
        /**
         *
         * @author dlwlrma
         * @date 2024/6/15 15:59
         * TODO:需求: 1.向列表中添加数据
         *           2.查询列表中所有数据
         */
        //获取执行list操作的接口对象
        ListOperations listOperations = redisTemplate.opsForList();

        //1.向列表中添加数据(添加多个数据)
        Long pushAll = listOperations.leftPushAll("字母","A","B","C","d","e","f");

        //2.查询列表中所有数据
        List range = listOperations.range("字母", 0, -1);
        //返回结果为list集合类，用增强for循环
        for (Object object : range) {
            System.out.println("object = " + object);
        }

    }

 3.4使用spring data redis操作的方式进行set类型数据的操作

/**
     * 操作Set类型的数据
     */
    @Test
    public void testSet(){
        /**
         *
         * @author dlwlrma
         * @date 2024/6/15 16:18
         * TODO： 1.向set集合中添加数据
         *       2.获取指定set集合的所有的元素
         *       3.删除指定set集合的数据
         */

        //获取取执行set操作的接口对象
        SetOperations setOperations = redisTemplate.opsForSet();

//        //1.向set集合中添加数据
//        setOperations.add("年龄","18","20");

        //2.获取指定set集合的所有的元素
        //该方法类似于在redis客户端操作获取所有元素的命令： smembers 键
        Set members = setOperations.members("年龄");
        //返回的set集合，用增强for循环
        for (Object member : members) {
            System.out.println("member = " + member);
        }

        //3.删除指定set集合的数据
        Long l = setOperations.remove("年龄", "18","60");
        System.out.println("l = " + l);

    }

 3.5使用spring data redis操作的方式进行zset类型数据的操作 

 /**
     * 操作ZSet类型的数据
     */
    @Test
    public void testZset(){
        /**
         *
         * @author dlwlrma
         * @date 2024/6/15 16:39
         * TODO： 1.向zset中添加数据
         *       2.从zset中取出数据
         *       3.对某个值的分数进行加20
         *       4.删除数据
         */

        //获取执行zset的接口对象
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        //1.向zset中添加数据
        zSetOperations.add("myzset","杜伊",10);
        zSetOperations.add("myzset","张三",25);
        zSetOperations.add("myzset","李四",5);
        zSetOperations.add("myzset","王五",30);

        //2.从zset中取出数据
        Set<String> myzset = zSetOperations.range("myzset", 0, -1);
        //根据分数值从小到大开始排序
        for (String object : myzset) {
            System.out.println("object = " + object);
        }

        //3.对某个值的分数进行加50
        //incrementScor() 中的三个参数表示： 键 字段值 加的分数
        Double score = zSetOperations.incrementScore("myzset","李四",50);
        System.out.println("score = " + score);


        //4.删除数据
        Long l = zSetOperations.remove("myzset", "杜伊", "王五");
        System.out.println("l = " + l);

        //5.取值
        Set<ZSetOperations.TypedTuple> set = zSetOperations.rangeWithScores("myzset",0,-1);
        for (ZSetOperations.TypedTuple typedTuple : set) {
            Object value = typedTuple.getValue();
            Double score1 = typedTuple.getScore();
            System.out.println(value +"------------"+score1);
        }

    }

  3.6使用spring data redis操作的方式进行通用类型数据的操作 

/**
     * 通用操作，针对不同的数据类型都可以操作
     */
    @Test
    public void testCommon(){
        /**
         *
         * @author dlwlrma
         * @date 2024/6/15 17:04
         * TODO： 需求：1.获取Redis中所有的key
         *            2.判断某个key是否存在
         *            3.删除指定key
         *            4.获取指定key对应的value的数据类型
         */
        //1.获取Redis中所有的key
        //*表示通配符
        Set<String> keys = redisTemplate.keys("*");
        for (String key : keys) {
            System.out.println("key = " + key);
        }

        //2.判断某个key是否存在
        Boolean b = redisTemplate.hasKey("字母");
        System.out.println("b = " + b);

        //3.删除指定key
        Boolean b1 = redisTemplate.delete("第二号");
        System.out.println("b1 = " + b1);

        //4.获取指定key对应的value的数据类型
        DataType type = redisTemplate.type("age");
        System.out.println(type.name());
    }

总结：

Jedis是一个Java的Redis客户端，而Spring Data Redis是一个针对Redis的数据访问和集成框架。

Jedis的优点：
1. 简单易用：Jedis提供了直接与Redis进行交互的方法和API，使用起来非常简单和直观。
2. 功能全面：Jedis支持Redis的所有功能和命令，可以满足大多数开发需求。
3. 性能高效：Jedis使用线程池和连接池来管理与Redis的连接，可以实现高并发的数据访问。

Jedis的缺点：
1. 功能相对有限：Jedis只提供了与Redis交互的基本方法和API，对于高级的数据操作和查询可能需要自己编写复杂的代码。
2. 手动管理连接：Jedis需要手动管理与Redis的连接，包括连接的获取、释放和异常处理，增加了开发的复杂性。

Spring Data Redis的优点：
1. 简化开发：Spring Data Redis提供了丰富的功能和API，可以通过简洁的代码实现复杂的数据操作和查询，大大简化了开发工作。
2. 集成方便：Spring Data Redis与Spring框架紧密集成，可以方便地与其他Spring组件（如Spring Boot）一起使用。
3. 自动管理连接：Spring Data Redis可以自动管理与Redis的连接，包括连接的获取、释放和异常处理，减少了开发的复杂性。

Spring Data Redis的缺点：
1. 学习曲线较陡：Spring Data Redis提供了丰富的功能和注解，但相对于Jedis而言，学习和理解其使用方法可能需要一些时间和精力。
2. 性能相对较低：由于Spring Data Redis提供了更高级的功能和抽象，可能会带来一些性能损失，尤其在高并发场景下。

综上所述，Jedis适合对Redis的基本功能进行简单操作的场景，而Spring Data Redis适合需要更高级功能和更方便集成的场景。选择哪个取决于具体的开发需求和项目情况。