基于 Netty 实现的，支持同步、异步和响应式编程方式，并且是线程安全的。支持 Redis 的哨兵模式、集群模式、管道模式

基于 Redis 实现的分布式、可伸缩的 Java 数据结构的集合。包含 Map、Queue、Lock、Semaphore、AtomicLong等强大的功能

Jedis

Jedis 基本使用步骤

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

测试 Jedis 相关方法

如果

@BeforeEach

<!-- junit-jupiter-api -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.8.2</version>
<scope>test</scope>
</dependency>

（这里以 String 和 Hash 两种类型为例）

package com.lcha.test;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;

import java.util.Map;

public class JedisTest {

private Jedis jedis;

@BeforeEach
void setUp(){
//1.建立连接
jedis = new Jedis("xxxxxxxxxx",6379);
//2.设置密码
jedis.auth("xxxxxxxxx");
//3.选择库
jedis.select(0);
}

@Test
void testStr(){
//4.存入数据
String result = jedis.set("name", "胡歌");
System.out.println("result = " + result);
//5.获取数据
String name = jedis.get("name");
System.out.println("name = " + name);
}

@Test
void testHash(){
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(){
//6.释放连接
if(jedis != null){
jedis.close();
}
}
}

Jedis连接池

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

首先创建一个 Jedis 连接池工具类

package com.lcha.jedis.util;

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

public class JedisConnectionFactory {
private static final JedisPool jedisPool;

static {
//配置连接池
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(8);  //最大连接数：8
poolConfig.setMaxIdle(8);   //最大空闲连接
poolConfig.setMinIdle(0);
poolConfig.setMaxWaitMillis(1000);
//创建连接池对象
jedisPool = new JedisPool(poolConfig,"xxxx",6379,
1000,"xxxx");
}

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

更改之前 Jedis 的连接方式，采用连接池连接的方式

package com.lcha.test;

import com.lcha.jedis.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;

import java.util.Map;

public class JedisTest {

private Jedis jedis;

@BeforeEach
void setUp(){
//1.建立连接
//jedis = new Jedis("xxxx",6379);
jedis = JedisConnectionFactory.getJedis();
//2.设置密码
jedis.auth("xxxx");
//3.选择库
jedis.select(0);
}

@Test
void testStr(){
//4.存入数据
String result = jedis.set("name", "胡歌");
System.out.println("result = " + result);
//5.获取数据
String name = jedis.get("name");
System.out.println("name = " + name);
}

@Test
void testHash(){
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();
}
}
}

注意：当使用连接池连接时，代码最后的

if(jedis != null){jedis.close();}

源码如下：

public void close() {
if (this.dataSource != null) {
Pool<Jedis> pool = this.dataSource;
this.dataSource = null;
if (this.isBroken()) {
pool.returnBrokenResource(this);
} else {
pool.returnResource(this); //注意这里！！！！
}
} else {
this.connection.close();
}

}

SpringDataRedis

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

官网地址：https://spring.io/projects/spring-data-redis

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

RedisTemplate 工具类

使用步骤

1. 引入 spring-boot-starter-data-redis 依赖

   <!-- 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. 在 application.yml 文件中配置 Redis 信息

   spring:
   redis:
   host: xxxx
   port: 6379
   password: xxxx
   lettuce:
   pool:
   max-active: 8
   max-idle: 8
   min-idle: 0
   max-wait: 100ms

3. 注入 RedisTemplate 并使用

package com.lcha;

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序列化，得到的结果是这样的：

缺点：

1. 可读性差
2. 内存占用较大

解决方法：改变序列化器

自定义 RedisTemplate 序列化方式

package com.lcha.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;
import org.springframework.data.redis.serializer.StringRedisSerializer;

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

重新运行刚才的代码，结果如下图所示：

存储对象数据时也是一样的

1. 创建一个对象类

   package com.lcha.redis.pojo;
   
   import lombok.AllArgsConstructor;
   import lombok.Data;
   import lombok.NoArgsConstructor;
   
   @Data
   @NoArgsConstructor
   @AllArgsConstructor
   public class User {
   private String name;
   private Integer age;
   }

2. 编写测试方法

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

4. 打印结果

   

JSON方式依然存在的缺陷

尽管 JSON 的序列化方式可以满足我们的需求，但是依然存在一些问题。

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

如何解决

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

1. 直接使用 StringRedisTemplate 即可

   package com.lcha;
   
   import com.fasterxml.jackson.core.JsonProcessingException;
   import com.fasterxml.jackson.databind.ObjectMapper;
   import com.lcha.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;
   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("虎哥",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);
   }
   
   }

2. 结果如下

   

对 Hash 类型的操作

1. 编写方法

   @Test
   void testHash(){
   stringRedisTemplate.opsForHash().put("user:300", "name", "张三");
   stringRedisTemplate.opsForHash().put("user:300", "age", "18");
   
   Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:300");
   System.out.println("entries = " + entries);
   
   }

2. 结果如下