redis的java客户端的使用（Jedis、SpringDataRedis、SpringBoot整合redis、redisTemplate序列化及stringRedisTemplate序列化）

Jedis的使用

Jedis使用的基本步骤：
① 引入依赖创建Jedis对象，
② 建立连接
③ 使用Jedis，方法名与Redis命令一致
④ 释放资源

1. 引入依赖

<!--Jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version>
</dependency>

1. 建立连接

// 测试链接
void SetUp(){
   
    // 1.建立链接
    jedis = new Jedis("192.168.197.129",6379);
    // 2.密码认证
    jedis.auth("123321");
    // 3.选择库
    jedis.select(0);
}

1. 插入string类型的数据

 void testString(){
   
    String res = jedis.set("name", "byf");
    System.out.println("res"+res);

    String name = jedis.get("name");
    System.out.println("name="+name);
}

1. 释放连接

 // 释放资源
void tearDown(){
   
    if(jedis!=null){
   
        jedis.close();
    }
}

1. 完整代码：

package com.robin.test;

import redis.clients.jedis.Jedis;

public class JedisDemo1 {
   

    private Jedis jedis;

    // 测试链接
    void SetUp(){
   
        // 1.建立链接
        jedis = new Jedis("192.168.197.129",6379);
        // 2.密码认证
        jedis.auth("123321");
        // 3.选择库
        jedis.select(0);
    }

    // 测试String
    void testString(){
   
        String res = jedis.set("name", "byf");
        System.out.println("res"+res);

        String name = jedis.get("name");
        System.out.println("name="+name);

    }

    // 释放资源
    void tearDown(){
   
        if(jedis!=null){
   
            jedis.close();
        }
    }

    public static void main(String[] args) {
   
        JedisDemo1 demo1 = new JedisDemo1();
        demo1.SetUp();
        demo1.testString();
        demo1.tearDown();
    }

}

Jedis连接池

PS：Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此推荐使用Jedis连接池代替Jedis的直连方式。

package com.robin.test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


/**
 * 使用JedisPool连接池
 */
public class JedisDemo2 {
   

    private static final JedisPool jedisPool;

    static {
   
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 配置连接池参数
        jedisPoolConfig.setMaxTotal(8); // 最大链接数
        jedisPoolConfig.setMaxIdle(8); //最大空闲连接数
        jedisPoolConfig.setMinIdle(8); // 最小空闲连接数

        jedisPool = new JedisPool(jedisPoolConfig,"192.168.197.129",6379);
    }

    // 获取jedis对象
    public static Jedis getJedis(){
   
        return jedisPool.getResource();
    }
}

SpringBoot整合Jedis

快速入门

SpringDataRedis的使用步骤：
① 引入spring-boot-starter-data-redis依赖
② 在application.yml配置Redis信息
③ 注入RedisTemplate

1. 引入依赖

<!-- redis-stater -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--common-pool redis连接池-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.11.1</version>
</dependency>

1. 配置yaml相关redis配置信息

spring:
  data:
    redis:
      host: 192.168.197.129 # redis服务IP
      port: 6379 # 端口
      password: 123321 # redis auth 认证密码
      lettuce:
        pool:
          max-active: 8  # 最大连接数
          max-idle: 8  # 最大空闲连接数
          max-wait: 100ms  # 最长等待时间

1. 注入RedisTemplate测试使用

@SpringBootTest
class RedisDemoApplicationTests {
   

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    @Test
    void testString() {
   
        redisTemplate.opsForValue().set("day","2023-11-28");
        String day = (String)redisTemplate.opsForValue().get("day");
        System.out.println(day);
    }

}

RedisTemplate的两种序列化实践方案

redisTemplate

1. 默认情况
   RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化。（字节形式可读性差，且占用内存较大）
   

2. 自定义redisTemlate的序列化方式

@Configuration
public class RedisConfig {
   

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){
   

        // 创建RedisTemplate 对象
        RedisTemplate<String,Object> template = new RedisTemplate<>();
        // 设置连接工厂
        template.setConnectionFactory(connectionFactory);
        // 创建json序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 设置key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // 设置value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        // 返回 RedisTemplate
        return  template;
    }
}

PS：key设为string的序列化，value设为json序列化

@Test
void testSaveUser(){
   
    redisTemplate.opsForValue().set("user:100",new User("zhangsan",21));
    User o = (User)redisTemplate.opsForValue().get("user:100");
    System.out.println(o);
}

为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。" @class:“com.robin.redisdemo.pojo.user” "

stringRedisTemplate

统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

(Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。)

@SpringBootTest
class StringRedisTemplateTests {
   

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void testString() {
   
        stringRedisTemplate.opsForValue().set("day","2023-11-28");
        String day = (String)stringRedisTemplate.opsForValue().get("day");
        System.out.println(day);
    }


    private static final ObjectMapper mapper= new ObjectMapper();

    @Test
    void testSaveUser() throws JsonProcessingException {
   
        // 创建对象
        User user = new User("zhangsan2", 21);
        // 手动序列化
        String json = mapper.writeValueAsString(user);
        // 写入数据
        stringRedisTemplate.opsForValue().set("user:200",json);
        // 手动反序列化
        User user1 = mapper.readValue(json, User.class);
        String res = stringRedisTemplate.opsForValue().get("user:200");
        System.out.println(res);
    }

}