java操作Redis（jedis和lettuce）

一.使用Jedis

1.初始化项目

创建Maven项目并导入jedis依赖和我们需要使用的fastjson依赖

依赖可在Maven仓库中搜索找到：https://search.maven.org/

        <!--jedis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <!--fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>

2.编程

1.测试连通

连接远程服务器上的redis时，需要在配置文件中修改为相关配置使得允许远程连接，若需要密码授权也需要进行配置。

运行输出 PONG，表示连通成功。

2.操作redis

jedis操作redis的方法就是redis的原生指令，几乎没有任何改变。

3.事务

package com.kuang;

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

/**
 * @Description:
 * @author: ZYQ
 * @date: 2020/10/18 17:18
 */
public class tesetTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("120.78.198.135", 6379);
        jedis.auth("dhsqj.1982");

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "kuangshen");
        String result = jsonObject.toJSONString();

        //开启事务
        Transaction multi = jedis.multi();
        try {
            //入队 此时还未执行
            multi.set("name", result);
            multi.set("age", result);
            //执行
            multi.exec();
            System.out.println(jedis.get("name"));
            System.out.println(jedis.get("age"));
        } catch (Exception e) {
            multi.discard();
            e.printStackTrace();
        } finally {
            jedis.close();
        }
    }
}

二.使用lettuce

1.初始化项目

新建SpringBoot项目，选择redis依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

2.编写配置文件

在SpringBoot2.x之后，redis依赖的底层实现用lettuce替换掉了jedis

jedis：采用的直连，多个线程操作的话，是不安全的；想要避免不安全，使用jedis pool连接池。更像BIO模式

lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况；可以减少线程数量。更像NIO模式

源码分析：

简单配置一下

spring.redis.host=120.78.198.135
spring.redis.port=6379
spring.redis.password=dhsqj.1982

3.进行测试

package com.example.demo;

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.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {

        /**
         * 获取redis的连接对象象
         */
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();

        /**
         * opsForValue 操作String
         * opsForList 操作list
         * opsForSet 操作Set
         * opsForHash 操作Hash
         * opsForZset 操作Zset
         * opsForGeo
         * opsForHyperLogLog
         */
        redisTemplate.opsForValue().set("mykey", "kuangshen");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }

}

发现仅在控制台上可以看到正确的结果，而在redis客户端中查看到的序列化之后的结果是这样的

点击redisTemplate查看源码

找到序列化默认的方式为jdk序列化方式，这种方式会将字符进行转义，也就是上上图看到的转义之后的结果

通过redisTemplate上的conditionalOnMissingBean注解，表明我们可以通过自定义redisTemplate。

可以在自定义的redisTemplate中书写序列化方法来覆盖默认的序列化方法，从而解决这个转义问题。

---

在未自定义redisTemplate之前，我们再进行测试来加深了解缘由

在pojo包中编写一个最基础的User对象，此时未进行序列化

在测试类中，尝试直接将对象存储在redis中，发现报错，异常说明对象需要序列化。

解决方法：在User类中实现序列化接口 Serializable 即可，默认的redisTemplate具有jdk序列化的具体实现，因此在redis中查看到的键值对依然为转义的结果。

 接下来我们尝试将对象转化成json数据格式进行存储并读取

 发现结果如下，因为目前我们还没有覆盖默认的序列化方法

---

测试完毕，此时对redisTemplate序列化这方面有了一定的了解。接下来我们去自定义redisTemplate

package com.example.demo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @Description:
 * @author: ZYQ
 * @date: 2020/10/18 22:17
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> template(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        //配置具体的序列化方法
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        //String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value采用jackson序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value采用jackson序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

在测试中注入自定义的redisTemplate

    @Autowired
    @Qualifier("template")
    private RedisTemplate redisTemplate;

测试方法

注意：

1.pojo类可以不实现 Serialization 接口，自定义的jackson序列化会帮我们做好

2.pojo类必须有无参构造方法，否则会抛出异常

 运行后可以在redis客户端中发现键值对符合我们的需求了

4.总结

 不管是jedis还是lettuce，其操作方法书写起来都很简单但繁琐，我们可以自己去写一个工具类来包装一下常用的方法，使得代码更简洁。