[021-003].第3节：Redis的Java客户端

我的后端学习大纲

我的Redis学习大纲

---

面试：请介绍下操作Redis的客户端方式都有哪些？

• 1.在Redis官网中提供了各种语言的客户端，地址是：https://redis.io/clients
  
• 2.如下是java中操作Redis的常用客户端：
  

---

1.Java操作Redis的客户端 -> Jedis操作Redis

1.1.Jedis直连方式操作Redis

a.更改redis配置：

• 1.首先要保证Redis的配置文件设置正确；先设置配置文件及关闭虚拟机的防火墙,以便顺利操作Redis：
  
  

b.编码实现Jedis的使用：

• 1.新建maven项目，pom文件中引入依

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.jianqun</groupId>
    <artifactId>jedis-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

• 2.创建Jedis对象，建立连接：

	// 建立连接
	jedis = new Jedis("192.168.2.21", 6379);
	// 设置密码
	jedis.auth("123321");
	//选择库
	jedis.select(0);

• 3.新建JedisTest类，在类中实现建立连接，存储数据：

private Jedis jedis;
// @BeforeEach是单元测里的方法，是先建立七来Jedis连接对象
@BeforeEach
public void setUp() {
	// 建立连接
	jedis = new Jedis("192.168.2.21", 6379);
	// 设置密码
	jedis.auth("123321");
	//选择库
	jedis.select(0);
}

// 测试操作Redis
//测试String类型的数据结构
@Test
void testString() {
	// 插入数据，方法名称就是redis命令名称，非常简单    
	String result = jedis.set("name", "张三");    
	System.out.println("result = " + result); 
	// 获取数据
	String name = jedis.get("name");
	System.out.println("name = " + name);
}

//测试Hash数据结构
@Test
void testHash() {
	// 插入数据，方法名称就是redis命令名称，非常简单    
	jedis.hset("user:1", "name","张三");  
	jedis.hset("user:1", "age","12");     
	//获取数据
	Map<String,string> map = jedis.hgetAll("user:1");
	System.out.println("map= " + map);
}

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

• 4.释放资源

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

• 5.项目结构：
  

---

2.Java操作Redis的客户端 -> 使用Jedis连接池方式操作Redis

2.1.说明:

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

2.2.具体实现方式

• 1.创建Jedis连接池的工具类：

package com.jianqun.util;

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

/**
 * Redis连接池
 */
public class JedisConnectionFactory {
    private static final JedisPool jedisPool;

    static {
        // 配置连接池
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大连接
        jedisPoolConfig.setMaxTotal(8);
        // 最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        // 最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        // 设置最长等待时间， ms
        jedisPoolConfig.setMaxWaitMillis(200);
        // 创建连接池对象
        jedisPool = new JedisPool(jedisPoolConfig, "192.168.148.3", 6379,1000, "190915");
    }

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

• 2.使用连接池创建连接，进行测试：

package com.jianqun.test2;

import com.jianqun.util.JedisConnectionFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;

/**
 * Redis连接池进行连接
 */
public class chiJedisTest {
    private Jedis jedis;

    @BeforeEach
    void setUp() {
        jedis = JedisConnectionFactory.getJedis();
    }

    @Test
    void test(){
        //存入数据
        String result = jedis.set("name", "虎哥");
        System.out.println("存储成功与否:" + result);

        //获取数据
        String name = jedis.get("name");
        System.out.println("获取的name值是:" + name);
    }

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

---

3.Java操作Redis的客户端 -> SpringDataRedis

3.1.SpringDataRedis的简介：

• 1.SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址：
  • 提供了对不同Redis客户端的整合（Lettuce和Jedis）
  • 提供了RedisTemplate统一API来操作Redis
  • 支持Redis的发布订阅模型
  • 支持Redis哨兵和Redis集群
  • 支持基于Lettuce的响应式编程
  • 支持基于JDK、JSON、字符串、Spring对象的数据序列化(就是把对象转换成字符串或者说字节)及反序列化（把字节转换成对象）
  • 支持基于Redis的JDKCollection实现
• 2.SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：
  

---

3.2.SpringDataRedis的使用

a.SpringDataRedis使用的实现步骤

• 1.创建SpringBoot项目,pom.xml文件中引入spring-boot-starter-data-redis依赖

<?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.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.atguigu</groupId>
    <artifactId>redis_springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>redis_springboot</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        
        <!-- spring2.X集成redis所需common-pool2-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

• 3.application.properities或者application.yml编写配置文件进行配置：

#Redis服务器地址
spring.redis.host=192.168.2.21
#Redis服务器连接端口
spring.redis.port=6379
#Redis连接密码
spring.redis.password=123321
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0

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

• 4.编写测试代码，执行测试：

@SpringBootTest
	public class RedisTest {
	 @Autowired
	 private RedisTemplate redisTemplate;
	 
	 @Test
	 void testString() { 
	 	// 插入一条string类型数据
		 redisTemplate.opsForValue().set("name", "李四");
		 // 读取一条string类型数据
		 Object name = redisTemplate.opsForValue().get("name");
		 System.out.println("name = " + name);    
	 }
}

• 5.总结：使用SpringDataRedis的步骤：
  

---

4.Java操作Redis的客户端->RedisTemplate的RedisSerializer

4.1.有一个编码的问题：

• 1.虽然在IDE中的控制台上可以输出这个值，但是当我去命令行窗口去查找这个key的值的时候，发现查不到，然后就显示全部的key *，发现有红框显示的哪个key，其实这个就是刚刚插入的哪个数据：
  

4.2.原因解析及解决

• 1,SpringDataRedis的序列化方式：RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的；这种默认的序列化方式可读性差，内存占用较大；
  
• 2.为了解决这种问题，我们就可以自己来定义RedisTemplate的序列化方式的配置类，自定义配置类的序列化实现方式如下：
  • 1.创建RedisTemplate对象
  • 2.设置连接工厂
  • 3.创建JSON序列化工具
  • 4.设置key的序列化
  • 5.设置value的序列化
  • 6.返回

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
	// 创建Template
     RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
     // 设置连接工厂
     redisTemplate.setConnectionFactory(redisConnectionFactory);
     // 创建JSON序列化工具
     GenericJackson2JsonRedisSerializer jsonRedisSerializer =  new GenericJackson2JsonRedisSerializer();
    // 设置key和 hashKey采用 string序列化
	redisTemplate.setKeySerializer(RedisSerializer.string());     
	redisTemplate.setHashKeySerializer(RedisSerializer.string());
    // 设置value和 hashValue采用 JSON序列化
    redisTemplate.setValueSerializer(jsonRedisSerializer);
    redisTemplate.setHashValueSerializer(jsonRedisSerializer);
    return redisTemplate;
 }

• 3重新编写单元测试，查看是否可以：

package com.jianqun;

import com.jianqun.redis.pojo.User;
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<String,Object> redisTemplate;

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

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

5.Java操作Redis的客户端->-StringRedisTemplate

5.1.解决上述内存占用的问题：

• 1.为了节省内存空间，我们并不会使用JSON序列化器来处理value;
• 2.而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化
  
• 2.Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程：

package com.jianqun;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jianqun.redis.pojo.User;
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.StringRedisTemplate;

import java.util.Map;

@SpringBootTest
class RedisStringTests {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void testString() {
        // 写入一条String数据
        stringRedisTemplate.opsForValue().set("verify:phone:13600527634", "124143");
        // 获取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("虎哥", 21);
        // 手动序列化
        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);
    }

    @Test
    void testHash() {
        stringRedisTemplate.opsForHash().put("user:400", "name", "虎哥");
        stringRedisTemplate.opsForHash().put("user:400", "age", "21");

        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:400");
        System.out.println("entries = " + entries);
    }

    @Test
    void name() {
    }
}

5.2.总结：RedisTemplate的两种序列化实践方案：

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