🚗Redis学习·第三站~
🚩起始站：【Redis】概述&环境搭建(一)
🚩本文已收录至专栏：数据库学习之旅
👍希望您能有所收获

在上一篇中我们学习了Redis常见命令的使用，显然，我们不可能一直通过指令去使用Redis。本篇我们一起学习如何使用Redis提供的Java客户端操作Redis。

一.概述

在Redis官网中提供了各种语言的客户端：地址
在这里插入图片描述

其中Java客户端也包含了很多：
在这里插入图片描述

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

Jedis:以Redis命令作为方法名称(get,set…)，学习成本低，简单实用。但是Jedis实例是线程不安全的，多线程环境下需要基于连接池来使用
Lettuce：Lettuce是基于Netty实现的，支持同步、异步和响应式编程方式，并且是线程安全的。支持Redis的哨兵模式、集群模式和管道模式
SpringDataRedis:上述两个主要是提供了Redis命令对应的API，方便我们操作Redis，而SpringDataRedis又对这两种做了抽象和封装，使得我们操作更加方便快捷。
Redisson：是在Redis基础上实现了分布式的可伸缩的java数据结构，例如Map、Queue等，而且支持跨进程的同步机制：Lock、Semaphore等待，比较适合用来实现特殊的功能需求。

二.Jedis客户端

Jedis的官网地址

Jedis使用的基本步骤：

引入依赖
创建Jedis对象，建立连接
使用Jedis，方法名与Redis命令一致
释放资源

(1) 快速入门

使用Jedis需要先导入它的依赖，我们可以先创建一个Maven工程，然后引入如下依赖：

<!--jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version>
</dependency>
<!--单元测试-->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.7.0</version>
    <scope>test</scope>
</dependency>

新建一个单元测试类，尝试与redis建立连接：

private Jedis jedis;

// 每次在执行其他测试方法前自动建立连接
@BeforeEach
void setUp() {
    // 1.建立连接
    jedis = new Jedis("192.168.150.101", 6379);
    // 2.设置密码
    jedis.auth("123321");
    // 3.选择库
    jedis.select(0);
}

编写测试方法：

@Test
void testString() {
    // 存入数据，方法名称就是redis命令名称，非常简单
    String result = jedis.set("name", "zhangsan");
    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);
}

通过上述测试代码我们可以看到使用Jedis客户端操作Redis和我们使用命令操作基本一致。

在这里插入图片描述

释放资源

// 每次在执行其他测试方法后自动关闭连接
@AfterEach
void tearDown() {
    if (jedis != null) {
        jedis.close();
    }
}

(2) 使用连接池

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

有关池化思想，并不仅仅是这里会使用，很多地方都有，比如说我们的数据库连接池，比如我们tomcat中的线程池，这些都是池化思想的体现。

package com.jedis.util;

import redis.clients.jedis.*;

public class JedisConnectionFactory {

    private static JedisPool jedisPool;

    static {
        // 配置连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        // 最大连接     
        jedisPoolConfig.setMaxTotal(8);     
        // 最大空闲连接        
        jedisPoolConfig.setMaxIdle(8);        
        // 最小空闲连接       
        jedisPoolConfig.setMinIdle(0);        
        // 设置最长等待时间， ms      
        jedisPoolConfig.setMaxWaitMillis(200);
        // 创建连接池对象，参数：连接池配置、服务端ip、服务端端口、超时时间、密码
        jedisPool = new JedisPool(poolConfig, "192.168.150.101", 6379, 1000, "123321");
    }

    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}

代码说明：

1） JedisConnectionFacotry：工厂设计模式是实际开发中非常常用的一种设计模式，我们可以使用工厂，去降低代的耦合，比如Spring中的Bean的创建，就用到了工厂设计模式
2）静态代码块(static)：随着类的加载而加载，确保只能执行一次，我们在加载当前工厂类的时候，就可以执行static的操作完成对连接池的初始化
3）最后提供返回连接池中连接的方法.

(3) 改造原始代码

我们可以不自己new，而是通过JedisConnectionFacotry来获取jedis连接。

    @BeforeEach
    void setUp(){
        //建立连接
        // jedis = new Jedis("127.0.0.1",6379);
        jedis = JedisConnectionFacotry.getJedis();
         //选择库
        jedis.select(0);
    }

	@Test
	void testString() {
 	   // 存入数据，方法名称就是redis命令名称，非常简单
 	   String result = jedis.set("name", "zhangsan");
  	  System.out.println("result = " + result);
  	  // 获取数据
 	   String name = jedis.get("name");
  	  System.out.println("name = " + name);
	}

   @AfterEach
    void tearDown() {
        if (jedis != null) {
            jedis.close();
        }
    }

代码说明:

1.在我们完成了使用工厂设计模式来完成代码的编写之后，我们在获得连接时，就可以通过工厂来获得，而不用直接去new对象，降低耦合，并且使用的还是连接池对象。

2.当我们使用了连接池后，当我们关闭连接其实并不是关闭，而是将Jedis还回连接池的。

三.SpringDataRedis客户端

(1) 概述

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址

其有如下特点：

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

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

在这里插入图片描述

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

使用步骤：

引入spring-boot-starter-data-redis依赖
在application.yml配置Redis信息
在使用类中注入RedisTemplate

(2) 快速入门

首先，新建一个SpringBoot工程，在Maven中引入如下依赖：

 <!--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>
</dependency>

2.在yml文件中配置Redis连接相关信息

spring:
  redis:
    host: 192.168.150.101
    port: 6379
    password: 123321
    lettuce:
      pool:
        max-active: 8  #最大连接
        max-idle: 8   #最大空闲连接
        min-idle: 0   #最小空闲连接
        max-wait: 100ms #连接等待时间

因为有了SpringBoot的自动装配，我们可以在使用的地方直接注入RedisTemplate：

@SpringBootTest
class RedisStringTests {

    @Resource
    private RedisTemplate redisTemplate;
}

新建测试类，编写测试方法

@SpringBootTest
class RedisStringTests {

    @Resource
    private RedisTemplate redisTemplate;

    @Test
    void testString() {
        // 写入一条String数据
        redisTemplate.opsForValue().set("name", "zhangsan");
        // 获取string数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
}

运行我们可以看到redisTemplate已经成功设置并获取到了数值
在这里插入图片描述

但是通过resp工具查看，发现值的格式似乎有点问题，这是为什么呢？

(3) 对象序列化

RedisTemplate可以接收任意Object作为值写入Redis：
在这里插入图片描述

只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，
在这里插入图片描述

因此我们得到的结果是这样的：

缺点：

可读性差
内存占用较大

(3.1) 自定义序列化方式

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

导入Jackson依赖，使用springmvc时可不必我们引入

        <!--Jackson依赖-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

自定义序列化器

@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;
    }
}

再次测试

@SpringBootTest
class RedisStringTests {

    @Resource
    private RedisTemplate<String,Object> redisTemplate;
    
    @Test
    void testString() {
        // 写入一条String数据
        redisTemplate.opsForValue().set("name", "zhangsan");
        // 获取string数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }
}

这次我们可以看到格式正常显示了。

在这里插入图片描述

但当我们存入对象是可能会碰到一些其他问题,例如:

@SpringBootTest
class RedisDemoApplicationTests {

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;


    @Test
    void testSaveUser() {
        // 写入数据
        redisTemplate.opsForValue().set("user:1", new User("zhangsan", 21));
        // 获取数据
        User o = (User) redisTemplate.opsForValue().get("user:1");
        System.out.println("o = " + o);
    }
}

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

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

(3.2) 使用StringRedisTemplate

为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。

为了减少内存的消耗，我们可以采用手动序列化的方式，换句话说，就是不借助默认的序列化器，而是我们自己来控制序列化的动作，同时，我们只采用String的序列化器，这样，在存储value时，我们就不需要在内存中就不用多存储数据，从而节约我们的内存空间

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

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

由于这种用法比较普遍，因此SpringDataRedis就提供了RedisTemplate的子类：StringRedisTemplate，它的key和value的序列化方式默认就是String方式。
在这里插入图片描述

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

@Resource
private StringRedisTemplate stringRedisTemplate;
// JSON序列化工具
private static final ObjectMapper mapper = new ObjectMapper();

@Test
void testSaveUser() throws JsonProcessingException {
    // 创建对象
    User user = new User("zhangsan", 21);
    // 使用序列化工具手动序列化，也可以用gson,fastjson等等
    String json = mapper.writeValueAsString(user);
    // 写入数据
    stringRedisTemplate.opsForValue().set("user:200", json);

    // 获取数据
    String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
    // 手动反序列化
    User user1 = mapper.readValue(jsonUser, User.class);
    System.out.println("user1 = " + user1);
}

此时我们再来看一看存储的数据，小伙伴们就会发现那个class数据已经不在了，节约了我们的空间~
在这里插入图片描述

(3.3) 小结

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

方案一：
- 自定义RedisTemplate
- 修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer
方案二：
- 使用StringRedisTemplate
- 写入Redis时，手动把对象序列化为JSON
- 读取Redis时，手动把读取到的JSON反序列化为对象