Redis 的 Java 客户端

原创

ruochen

发布于 2022-08-04 13:19:22

3.7K0

发布于 2022-08-04 13:19:22

文章被收录于专栏：若尘的技术专栏若尘的技术专栏

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 连接池

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

引入依赖 pom.xml

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

配置 application.yml

spring:
  redis:
    host: ip
    port: 6379
    password: pwd
    jedis:
      pool:
        # 最大连接
        max-active: 8
        # 最大空闲连接
        max-idle: 8
        # 最小空闲连接
        min-idle: 0
        # 等待时长
        max-wait: 1000ms

测试（String）

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
编写 RedisTemplate 配置类

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