Redis的Java客户端

Jedis

jedis就是基于java语言的redis客户端，集成了redis的命令操作，提供了连接池管理。
redis-cli是redis官方提供的客户端，可以看作一个shell程序，它可以发送命令对redis进行操作。
对于jedis同理是使用java语言操作redis，双方都遵循redis提供的协议，按照协议开发对应的客户端。

那么怎么使用呢?

Jedis的快速入门

jedis直连

第一步,引入依赖

        <!-- jedis-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.7.0</version>
        </dependency>
        <!-- junit-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>

第二步,建立连接

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

第三步,简单测试

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

第四步,关闭连接

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

---

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

使用连接池:

预先生成一批jedis连接对象放入连接池中，当需要对redis进行操作时从连接池中借用jedis对象，操作完成后归还。这样jedis对象可以重复使用，避免了频繁创建socket连接，节省了连接开销。**

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);//等待时长,默认-1

        //创建连接池对象
        jedisPool = new JedisPool(poolConfig,
                "127.0.0.1",6379,1000,"123");

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

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的快速入门

第一步,引入依赖

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

第二步,配置文件

在springboot项目的application.yaml中进行配置

spring:
  redis:
    host: 127.0.0.1 #你项目的ip地址
    port: 6379 #端口
    password: 123 #密码
    lettuce:
      pool:
        max-active: 8 # 最大连接
        max-idle: 8 # 最大空闲连接
        min-idle: 0 # 最小空闲连接
        max-wait: 100ms # 连接等待时间

第三步,注入RedisTemplate

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

第四步,编写测试

    @Test
    void testString() {
        //写入一条string数据
        stringRedisTemplate.opsForValue().set("name","codecat");
        //获取string数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name="+name);
    }

SpringDataRedis的序列化方式

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

尽管JSON的序列化方式可以满足我们的需求，但依然存在一些问题，为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。

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

Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们上面自定义RedisTemplate的过程：

    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    void testSaveUser() throws JsonProcessingException {
        //创建对象
        User user = new User("小明",18);
        //手动序列化
        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);
    }

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

方案一：

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

方案二：

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