Redis的Java客户端

个人博客：dogbin.vip

目前我了解到的有以下4种。

• Spring-Data-Redis：https://spring.io/projects/spring-data-redis

• Jedis：https://github.com/redis/jedis/wiki

• Lettuce：https://lettuce.io/，这里不做介绍，太高级了，估计hold不住。

• Redisson ：https://github.com/redisson/redisson/wiki

Spring Data Redis

1.介绍

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，相当于定义了一些如增删改查的抽象接口，继而有对应不同数据库的实现。

• Spring Data JDBC
• Spring Data JPA
• Spring Data MongoDB
• Spring Data Redis
• 。。。

其中对redis集成模块就叫做Spring Data Redis。

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

SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：

2.使用

2.1 引入依赖

        <!--连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
		
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
		<!--Jackson依赖-->
		<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

2.2 编写配置文件

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

2.3 测试与问题

可以看到是可以正常写入和获取的，那么我们来看看数据库。

发现问题：

1. 插入进来的怎么不是“coderbin”，多了前面一坨东西呢？
2. 为什么查不到值呢？

追溯问题：

RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果就是上图所示

2.4 解决序列化问题

简单方法：直接不用RedisTemplate，我们用StringRedisTemplate.

正常输出，再去看数据库。

键值的数据也是正常的，但是！这里又有问题。

stringRedisTemplate的set方法要求键值都为string类型，这就无法满足我们的需求。

那么我们就要自定义RedisTemplate的序列化方式啦！

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

可以看到已经大功告成了。

总结一下：

RedisTemplate的两种序列化实践方案：

• 方案一：

  • 自定义RedisTemplate
  • 修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer

• 方案二：

  • 使用StringRedisTemplate
  • 写入Redis时，手动把对象序列化为JSON
  • 读取Redis时，手动把读取到的JSON反序列化为对象

Jedis

(25条消息) Jedis常用方法API_遛狗大师的博客-CSDN博客_jedis方法

使用阻塞的I/O，且其方法调用都是同步的（慢！），程序流需要等到sockets处理完I/O才能执行，不支持异步。Jedis客户端实例不是线程安全的，所以需要通过连接池来使用Jedis。

1.快速入门

1.1引入依赖

<!--jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version>
</dependency>

1.2 创建连接池

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

有关池化思想，并不仅仅是这里会使用，很多地方都有，比如说我们的数据库连接池，比如我们tomcat中的线程池，这些都是池化思想的体现。

public class JedisConnectionFacotry {
     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,
                 "localhost",6379,1000);
     }

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

1.3 测试

  @BeforeEach
    void setUp(){
        //建立连接
        /*jedis = new Jedis("127.0.0.1",6379);*/
        jedis = JedisConnectionFacotry.getJedis();
         //选择库
        jedis.select(0);
    }
    @Test
    void testHash() {
        // 插入hash数据
        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();
        }
    }

测试成功！

Redisson

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。Redisson的宗旨是促进使用者对Redis的关注分离（Separation of Concern），从而让使用者能够将精力更集中地放在处理业务逻辑上。

1.快速入门

1.1 引入依赖

<dependency>
	<groupId>org.redisson</groupId>
	<artifactId>redisson</artifactId>
	<version>3.13.6</version>
</dependency>

1.2 配置Redisson客户端

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient(){
        // 配置
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.150.101:6379")
            .setPassword("123321");
        // 创建RedissonClient对象
        return Redisson.create(config);
    }
}

1.3 使用Redission的分布式锁

@Resource
private RedissionClient redissonClient;

@Test
void testRedisson() throws Exception{
    //获取锁(可重入)，指定锁的名称
    RLock lock = redissonClient.getLock("anyLock");
    //尝试获取锁，参数分别是：获取锁的最大等待时间(期间会重试)，锁自动释放时间，时间单位
    boolean isLock = lock.tryLock(1,10,TimeUnit.SECONDS);
    //判断获取锁成功
    if(isLock){
        try{
            System.out.println("执行业务");          
        }finally{
            //释放锁
            lock.unlock();
        }
        
    } 
}

Redisson有非常多的分布式服务：

具体的各个用法需要结合官网和你的具体业务实现。

Java客户端总结

• 如果使用了Spring，并且没有过多的定制化要求，那么大可以选择Spring Data Redis
• 如果没有使用Spring，只需要实现简单的业务，也没有过高的性能要求，那么可以选择Jedis
• 如果没有使用Spring，并且追求高性能、高定制化，可以用 Lettuce，支持异步、连接池
• 如果项目是分布式架构，需要一些分布式服务（分布式锁，分布式集合等等），那么可以选择Redisson