redis 的 java 客户端

Jedis 客户端
1）引入依赖：

<?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">
    <parent>
        <artifactId>redis_code</artifactId>
        <groupId>tech.chen</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>redis-client-jedis</artifactId>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.7.0</version>
        </dependency>
        <!--common-pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

2）建立连接：

private Jedis jedis;
    @BeforeEach
    void setUp() {
        jedis = new Jedis("192.168.200.130",6379);
        jedis.auth("123321");
        jedis.select(0);
    }

3）测试：

@Test
void string() {
    String set = jedis.set("name", "czk");
    System.out.println("set = " + set);//set = OK
    String name = jedis.get("name");
    System.out.println("name = " + name);//name = czk
}

@Test
void hash() {
    long hset = jedis.hset("login:user:1", "name", "阿陈");
    System.out.println("hset = " + hset);//hset = 1
    String name = jedis.hget("login:user:1", "name");
    System.out.println("name = " + name);//name = 阿陈
}

4）释放资源

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

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

/**
 * @Date 2022/8/1 19:17
 * @Author c-z-k
 */
public class JedisPoolTest {
    private static JedisPool jedisPool;
    @BeforeEach
    void setUp() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxWaitMillis(1000);
        config.setMinIdle(0);
        config.setMaxIdle(8);
        config.setMaxTotal(8);
        jedisPool = new JedisPool(config,"192.168.200.130",6379,1000,"123321");
    }
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }

    @Test
    void string() {
        String set = getJedis().set("name", "小猪");
        System.out.println("set = " + set);
        String name = getJedis().get("name");
        System.out.println("name = " + name);
    }

    @Test
    void hash() {
        long hset = getJedis().hset("login:user:2", "name", "小猪");
        System.out.println("hset = " + hset);//hset = 1
        String name = getJedis().hget("login:user:2", "name");
        System.out.println("name = " + name);//name = 小猪
    }
}

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 实现SpringDataRedis 中提供了 RedisTemplate
工具类，其中封装了各种对 Redis 的操作。并且将不同数据类型的操作 API 封装到了不同的类型中：

SpringBoot 已经提供了对 SpringDataRedis 的支持，使用非常简单。
首先，新建一个 maven 项目，然后按照下面步骤执行：
1）引入依赖

<?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.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>tech.chen</groupId>
    <artifactId>spring-client-spring-data-redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-client-spring-data-redis</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--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>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--Jackson依赖 ,springmvc中自带依赖，这里由于没有，故引用-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2）配置 Redis

spring:
  redis:
    host: 192.168.200.130
    port: 6379
    password: 123321
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 1000ms

3）注入 RedisTemplate

@SpringBootTest
class RedisStringTests {
    @Autowired
    private RedisTemplate redisTemplate;
}

4）编写测试

@SpringBootTest
class SpringClientSpringDataRedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void string() {
        // 写入一条String数据
        redisTemplate.opsForValue().set("name", "阿陈");
        // 获取string数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);//name = 阿陈
    }
}

自定义序列化
redis 序列化器 有以下几种：常用的是 StringRedisSerializer 和 Jackson2JsonRedisSerializer 。
RedisTemplate 可以接收任意 Object 作为值写入 Redis：

只不过写入前会把 Object 序列化为字节形式，默认是采用 JDK 序列化，得到的结果是这样的：
缺点：

• 可读性差
• 内存占用较大

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

@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和hashKey的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // 设置Value和hashValue的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        // 返回
        return template;
    }
}

这里采用了 JSON 序列化来代替默认的 JDK 序列化方式，一般我们使用 redis 的时候，redis 的 key 都是 String 类型的，故在对 key 使用序列化器时，都采用 RedisSerializer.string() 的方式。再次测试 ，结果如图：

如果我们 是存 java 对象，那 redis 会怎样显示？

@Test
void stringObjTest() {
    User user = new User();
    user.setName("阿陈");
    user.setAge(21);
    // 写入一条String数据
    redisTemplate.opsForValue().set("login:user:101", user);
    // 获取string数据
    User user1 = (User) redisTemplate.opsForValue().get("login:user:101");
    System.out.println("user1 = " + user1);//user1 = tech.chen.springclientspringdataredis.entity.User@516592b1
}

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

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

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

这种用法比较普遍，因此 SpringDataRedis 就提供了 RedisTemplate 的子类：StringRedisTemplate ，它的 key 和 value 的序列化方式默认就是 String 方式。

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

/**
 * @Date 2022/8/2 20:55
 * @Author c-z-k
 */
@SpringBootTest
public class StringRedisTemplateTest {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final ObjectMapper objectMapper = new ObjectMapper();
    @Test
    void stringTest() {
        // 写入一条String数据
        stringRedisTemplate.opsForValue().set("name", "阿陈");
        // 获取string数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);//name = 阿陈
    }
    @Test
    void stringObjTest() {
        User user = new User();
        user.setName("阿陈");
        user.setAge(21);
        // 写入一条String数据
        String userJson = null;
        try {
            userJson = objectMapper.writeValueAsString(user);
            stringRedisTemplate.opsForValue().set("login:user:101", userJson);
            // 获取string数据
            String result = stringRedisTemplate.opsForValue().get("login:user:101");
            User user1 = objectMapper.readValue(result, User.class);
            System.out.println("user1 = " + user1);//user1 = tech.chen.springclientspringdataredis.entity.User@3878be7b
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}