NoSQL之Redis——Java客户端和SpringRedisData

java小豪
84 阅读5分钟

这是我参与「掘金日新计划 · 2 月更文挑战」的第 十 九 天

认识Redis

Redis诞生于2009年全称是Remote Dictionary Server 远程词典服务器，是一个基于内存的键值型NoSQL数据库。

特征：

  • 键值（key-value）型，value支持多种不同数据结构，功能丰富
  • 单线程，每个命令具备原子性
  • 低延迟，速度快（基于内存、IO多路复用、良好的编码）。
  • 支持数据持久化
  • 支持主从集群、分片集群
  • 支持多语言客户端

Redis的Java客户端

在Redis官网中提供了各种语言的客户端，地址：redis.io/docs/client…

image-20221024211342067

其中Java客户端也包含很多：

image-20221024211538301

标记为♥的就是推荐使用的java客户端，包括：

  • Jedis和Lettuce：这两个主要是提供了Redis命令对应的API，方便我们操作Redis，而SpringDataRedis又对这两种做了抽象和封装，因此我们后期会直接以SpringDataRedis来学习。
  • Redisson：是在Redis基础上实现了分布式的可伸缩的java数据结构，例如Map、Queue等，而且支持跨进程的同步机制：Lock、Semaphore等待，比较适合用来实现特殊的功能需求。

3.1、Jedis客户端

Jedis的官网地址： github.com/redis/jedis

3.1.1、快速入门

引入依赖：
<!--jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.0</version>
</dependency>
<!--单元测试-->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.7.0</version>
    <scope>test</scope>
</dependency>
建立连接

新建一个单元测试类，内容如下：

private Jedis jedis;
​
@BeforeEach
void setUp() {
    // 1.建立连接
    jedis = new Jedis("192.168.200.130", 6379);
    // 2.设置密码
    jedis.auth("ZJch1328.");
    // 3.选择库
    jedis.select(0);
}
测试：
@Test
void testString() {
  // 存入数据
  String result = jedis.set("name", "张三");
  System.out.println("result = " + result);
  // 获取数据
  String name = jedis.get("name");
  System.out.println("name = " + name);
}
​
@Test
void testHash() {
  // 插入Hash数据
  jedis.hset("user:1", "name", "Jack");
  jedis.hset("user:1", "age", "21");
​
  // 获取
  Map<String, String> map = jedis.hgetAll("user:1");
  System.out.println(map);
}
释放资源
@AfterEach
void tearDown() {
  if (jedis != null) {
    jedis.close();
  }
}

连接池

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

package com.chen.jedis.util;
​
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
​
/**
 * @author java小豪
 * @version 1.0.0
 * @description Jedis连接池工具类
 */
public class JedisConnectionFactory {
    private static final JedisPool jedisPool;
​
    // 静态代码块
    static {
        // 配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        // 最大连接数
        poolConfig.setMaxTotal(8);
        // 最大空闲连接
        poolConfig.setMaxIdle(8);
        // 最小空闲连接
        poolConfig.setMinIdle(0);
        // 最大等待时间
        poolConfig.setMaxWaitMillis(10000);
​
        // 创建连接吃对象
        jedisPool = new JedisPool(poolConfig, "192.168.200.130", 6379, 1000, "ZJch1328.");
    }
​
    public static Jedis getJedis() {
        return jedisPool.getResource();
    }
}
​
// 测试
​
private Jedis jedis;
​
@BeforeEach
void setUp() {
  // 1.建立连接
  //        jedis = new Jedis("192.168.200.130", 6379);
  jedis = JedisConnectionFactory.getJedis();
  // 2.设置密码
  //        jedis.auth("ZJch1328.");
  // 3.选择库
  jedis.select(0);
}

SpringDataRedis

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址：spring.io/projects/sp…

  • 提供了对不同Redis客户端的整合（Lettuce和Jedis）
  • 提供了RedisTemplate统一API来操作Redis
  • 支持Redis的发布订阅模型
  • 支持Redis哨兵和Redis集群
  • 支持基于Lettuce的响应式编程
  • 支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
  • 支持基于Redis的JDKCollection实现

SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：

image-20221024221131388

快速入门

SpringBoot已经提供了对SpringDataRedis的支持，使用非常简单。

首先，新建一个maven项目，然后按照下面步骤执行：

引入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.chen</groupId>
    <artifactId>redis-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>redis-demo</name>
    <description>redis-demo</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--common-pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.11.1</version>
        </dependency>
​
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
​
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
​
</project>
配置Redis
spring:
  redis:
    host: 192.168.200.130
    port: 6379
    password: ZJch1328.
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 1000
注入RedisTemplate并测试
package com.chen;
​
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;
​
@SpringBootTest
class RedisDemoApplicationTests {
​
    @Autowired
    private RedisTemplate redisTemplate;
​
    @Test
    void testString() {
        // 写入一条String数据
        redisTemplate.opsForValue().set("name", "豪哥");
        // 获取String数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
​
}

自定义序列化

RedisTemplate可以接收任意Object作为值写入Redis：

只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的：

image-20221024223728514

缺点：

  • 可读性差
  • 内存占用较大

我们可以自定义RedisTemplate的序列化方式，代码如下：

package com.chen.redis.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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
​
/**
 * @author java小豪
 * @version 1.0.0
 * @description Redis序列化配置类
 */
@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);
        // 返回
        return template;
    }
}

这里采用了JSON序列化来代替默认的JDK序列化方式。最终结果如图：

image-20221024231404836

整体可读性有了很大提升，并且能将Java对象自动的序列化为JSON字符串，并且查询时能自动把JSON反序列化为Java对象。不过，其中记录了序列化时对应的class名称，目的是为了查询时实现自动反序列化。这会带来额外的内存开销。

StringRedisTemplate

为了节省内存空间，我们可以不使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

image-20221024231458635

因为存入和读取时的序列化及反序列化都是我们自己实现的，SpringDataRedis就不会将class信息写入Redis了。

这种用法比较普遍，因此SpringDataRedis就提供了RedisTemplate的子类：StringRedisTemplate，它的key和value的序列化方式默认就是String方式。

省去了我们自定义RedisTemplate的序列化方式的步骤，而是直接使用：

package com.chen;
​
import com.chen.redis.pojo.User;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
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.StringRedisTemplate;
​
@SpringBootTest
class RedisStringTests {
​
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
​
    @Test
    void testString() {
        // 写入一条String数据
        stringRedisTemplate.opsForValue().set("name", "豪哥");
        // 获取String数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
​
    private static final ObjectMapper mapper = new ObjectMapper();
​
    @Test
    void testSaveUser() throws JsonProcessingException {
        User user = new User("豪哥", 22);
        // 手动序列化
        String json = mapper.writeValueAsString(user);
        // 写入数据
        stringRedisTemplate.opsForValue().set("user:20", json);
        // 获取数据
        String jsonUser = stringRedisTemplate.opsForValue().get("user:20");
        // 反序列化
        User user1 = mapper.readValue(jsonUser, User.class);
        System.out.println("user = " + user1);
    }
​
}

此时我们再来看一看存储的数据：

image-20221025135240343

最后小总结：

RedisTemplate的两种序列化实践方案：

  • 方案一：

    • 自定义RedisTemplate
    • 修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer

  • 方案二：

    • 使用StringRedisTemplate
    • 写入Redis时，手动把对象序列化为JSON
    • 读取Redis时，手动把读取到的JSON反序列化为对象
avatar
文章
阅读
粉丝