Redis 的 Java 客户端
客户端对比
Jedis
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>4.2.0</version>
</dependency>
package com.ruochen.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("ip", 6379);
// 2. 设置密码
jedis.auth("pwd");
// 3. 选择库
jedis.select(0);
}
@Test
void testString() {
// 存入数据
String result = jedis.set("name", "ruochen");
System.out.println("result => " + result);
// 获取数据
String name = jedis.get("name");
System.out.println("name => " + name);
}
@Test
void testHash() {
// 插入 hash 数据
jedis.hset("user:1", "name", "ruochen");
jedis.hset("user:1", "age", "22");
// 获取数据
Map<String, String> map = jedis.hgetAll("user:1");
System.out.println(map);
}
@AfterEach
void tearDown() {
// 关闭连接
if (jedis != null) {
jedis.close();
}
}
}
Jedis 连接池
package com.ruochen.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);
// 最大空闲连接
poolConfig.setMaxIdle(8);
// 最小空闲连接
poolConfig.setMinIdle(0);
// 等待时长
poolConfig.setMaxWaitMillis(1000);
// 创建连接池
jedisPool = new JedisPool(poolConfig,
"ip", 6379, 1000, "pwd");
}
public static Jedis getJedis() {
return jedisPool.getResource();
}
}
jedis = JedisConnectionFactory.getJedis();
SpringDataRedis
<!--redis 依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--连接池依赖-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
spring:
redis:
host: ip
port: 6379
password: pwd
jedis:
pool:
# 最大连接
max-active: 8
# 最大空闲连接
max-idle: 8
# 最小空闲连接
min-idle: 0
# 等待时长
max-wait: 1000ms
package com.ruochen;
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 SpringdataRedisDemoApplicationTests {
@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 序列化为字节形式（默认采用 JDK 序列化），会得到如下结果
- 那么，如果我们不想得到这样的结果，我们就要改变 RedisTemplate 的序列化方式。若 key value 都为 String 类型，一般使用
StringRedisSerializer，若为 Java 对象，一般使用 GenericJackson2JsonRedisSerializer
package com.ruochen.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;
@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.setHashKeySerializer(jsonRedisSerializer);
// 返回
return template;
}
}
- 由于项目目前没有引入 srping-mvc，我们需要手动引入一下 Jackson 依赖
<!--Jackson 依赖-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
package com.ruochen;
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 SpringdataRedisDemoApplicationTests {
@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);
}
}
- 接下来，我们测试一下 RedisTemplate 能否将 Java 对象进行序列化。先写一个实体类
User
package com.ruochen.redis.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
private String name;
private Integer age;
}
@Test
void testSaveUser() {
// 写入数据
redisTemplate.opsForValue().set("user:222", new User("ruochen", 22));
// 获取数据
User user = (User) redisTemplate.opsForValue().get("user:222");
System.out.println("user => " + user);
}
- 我们可以注意到，在写入 json 数据的同时写入了一条 Class 属性，对应类的字节码名称，正式因为有这条属性，在反序列化时才能读取到类的字节码名称，从而将 json 反序列化为对用的 User
- 虽然上述的 JSON 序列化方式已经可以解决我们的问题，但由此引发了另外一个问题，为了在反序列化时知道对象的类型，将类的class写入json中势必会带来额外的内存开销。因此，为了节省空间，我们统一使用 String 序列化器，当存储 Java 对象时，就得手动进行序列化和反序列化
- Spring 已经默认提供了一个 StringRedisTemplate 类，它的 key 和 value 的序列化方式默认就是 String 方式
package com.ruochen;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruochen.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;
@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:333", json);
// 获取数据
String jsonUser = stringRedisTemplate.opsForValue().get("user:333");
// 手动反序列化
User u = mapper.readValue(jsonUser, User.class);
System.out.println("user => " + u);
}
}
- 最后，我们再来测试一下 RedisTemplate 操作 Hash 类型
package com.ruochen;
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 RedisHashTests {
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
void testHash() {
stringRedisTemplate.opsForHash().put("user:444", "name", "ruochen");
stringRedisTemplate.opsForHash().put("user:444", "age", "22");
Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:444");
System.out.println("entries => " + entries);
}
}
