java操作redis

1. 导论

redis官网推荐的java操作redis的客户端

官网地址：https://redis.io/docs/clients/#java

1. Jedis：以Redis命令作为方法名称，学习成本低，简单实用。但是Jedis实例是线程不安全的，多线程环境下需要基于连接池来使用
2. Lettuce：Lettuce是基于Netty实现的，支持同步，异步和响应式编程方式，并且是线程安全的。支持Redis哨兵模式，集群模式，管道模式
3. Redisson：Redisson是一个基于Redis实现的分布式、可伸缩的Java数据结构集合。包含了诸如Map，Queue，Lock，Semaphore，AtomicLong等强大功能
4. Spring Data Redis底层可以以Jedis或者Lettuce来实现

2. Jedis

2.1 Jedis的基本使用

1. 引入pom依赖

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

2. 设置连接，端口，密码

3. 编写功能

4. 关闭连接

public class JedisDemo {
    private Jedis jedis;

    @BeforeEach
    void before() {
        // 1.建立连接
        jedis = new Jedis("localhost", 6379);
        // 2.设置密码
        jedis.auth("zjh");
        // 3.选择数据库
        jedis.select(0);
    }

    @Test
    public void test() {
        // 插入数据
        jedis.set("jedis", "jedis");
        // 获取String数据
        String result = this.jedis.get("jedis");
    }

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

使用jedis测试Hash数据类型

	@Test
    public void hashTest(){
        jedis.hset("jedis:test:1","first","1");
        jedis.hset("jedis:test:1","second","2");
        String first = jedis.hget("jedis:test:1", "first");
        System.out.println(first);
        Map<String, String> map = jedis.hgetAll("jedis:test:1");
        System.out.println(map.toString());

    }

使用Jedis，方法名与Redis命令基本一致。

2.2 Jedis连接池

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

public class JedisConnectionFactory {
    // 创建JedisPool对象
    private static final JedisPool jedisPool;
    
    static{
        // 创建JedisConfig
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 配置JedisConfig，设置最大连接数
        jedisPoolConfig.setMaxTotal(8);
        // 设置最大空闲连接数
        jedisPoolConfig.setMaxIdle(8);
        // 设置最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        // 设置最长等待时间，单位是ms
        jedisPoolConfig.setMaxWaitMillis(200);
        // 实例化JedisPool，将JedisConfig，地址，端口，连接超时时间，密码传入
        jedisPool = new JedisPool(jedisPoolConfig,"localhost",6379,10000,"zjh");
    }
    
    public static Jedis getJedis(){
        Jedis jedis = jedisPool.getResource();
        return jedis;
    }
    
}

3. SpringDataRedis

pringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫

SpringDataRedis，官网地址：https://spring.io/projects/spring-data-redis

提供了对不同Redis客户端的整合（Lettuce和Jedis）

1. 提供了RedisTemplate统一API来操作Redis
2. 支持Redis的发布订阅模型
3. 支持Redis哨兵和Redis集群
4. 支持基于Lettuce的响应式编程
5. 支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化
6. 支持基于Redis的JDKCollection实现

由于Jedis类中封装了Redis客户端的所有操作命令，所以Jedis类显得就很臃肿

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

3.1 SpringDataRedis

1. 新建SpringBoot项目
2. 加入SpringDataRedis依赖和Commons-tool2依赖

  		<dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.10.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

3. 编写相关配置

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=zjh
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
spring.redis.lettuce.pool.max-wait=100

Spring默认使用的是lettuce，如果要使用Jedis需要自己进行相关配置

4. 依赖注入RedisTemplate使用即可

5. 测试

public class RedisDemo {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test(){
        redisTemplate.opsForValue().set("h","h");
    }
}

进入redis-cli中查看

redis-cli中查询出来和代码中写入的不一致，因为redisTemplate底层是由序列化机制的，他和Jedis不一样，Jedis

的set方法传入的都是String类型，但是RedisTemplate传入的是Object对象，在底层会进行序列化。

RedisTemplate底层有四个序列化器，keySerializer，valueSerializer，hashKeySerializer，hashValueSerializer。

默认是使用JDK序列化器进行序列化的初始化。

这种JDK序列化器的缺点是

1. 可读性差
2. 内存占用较大

那么如何做到存入的数据所见即所得呢？改变RedisSerializer，不要使用默认的JDK序列化器。

这些都是可以进行序列化初始的类

StringRedisSerializer是专门由于处理字符串的，我们的key可以使用这个序列化

GenericJackson2JsonRedisSerializer可以用于处理我们的value，因为value不一定是String类型，还有可能是对

象，使用使用Json序列化来处理value

@Component
public class RedisConfig {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        // 创建RedisTemplate对象
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 创建Json序列化工具
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // String序列化工具
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        return redisTemplate;
    }
}

将对象写入Redis

@SpringBootTest
public class RedisDemo {

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    @Test
    public void test(){
        redisTemplate.opsForValue().set("h",new Dog(20,"jxj"));
    }
}

但是JSON序列化也会有一些问题，例如将对象存入Redis时，发现除了对象的属性，还存入了对象的字节码
存入的字节码甚至比存入的属性所占的空间还要长，这样子无疑是额外占用了内存空间。但是为了自动的序列化和反序列化，所以必须加入字节码来反序列化时自动辨别是哪个类

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

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

   @Autowired
    private  StringRedisTemplate stringStringStringRedisTemplate;

    @Autowired
    private ObjectMapper objectMapper;

    @Test
    public void test() throws JsonProcessingException {
    // 手动序列化
        Dog dog = new Dog(200, "baby");
        String s = objectMapper.writeValueAsString(dog);
        stringStringStringRedisTemplate.opsForValue().set("dog",s);
        // 取出对象
        String dog1 = stringStringStringRedisTemplate.opsForValue().get("dog");
        Dog dog2 = objectMapper.readValue(dog1, Dog.class);
        System.out.println(dog2.toString());
    }