package com.fly.jedis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisPooled;
import redis.clients.jedis.params.SetParams;

import java.util.Set;

/**
 * Jedis操作Redis
 */
public class JedisExample {
    private static final String HOST = "192.168.159.128";
    private static final int PORT = 6379;

    /**
     * 创建Jedis连接池,用于复用连接,提升性能,且线程安全。
     * 多个线程操作Jedis实例是非线程安全的,而且会创建大量Jedis实例,
     * 因为这意味着大量的套接字和连接,这也会导致奇怪的错误。
     *
     * @return
     */
    public static JedisPool createJedisPool() {
        // 初始化Jedis连接配置类
        JedisPoolConfig config = new JedisPoolConfig();
        // 连接池最大空闲连接数,默认8
        config.setMaxIdle(10);
        // 连接池最小空闲连接数,默认0
        config.setMinIdle(0);
        // 连接池最大连接数,默认8
        config.setMaxTotal(10);
        // 连接池最大等待毫秒数
        config.setMaxWaitMillis(100);
        // 根据连接池配置、HOST、PORT初始化Jedis连接池
        JedisPool jedisPool = new JedisPool(config, HOST, PORT);
        return jedisPool;
    }

    public static void main(String[] args) {
        System.out.println("=============== 方式1:Jedis实例操作Redis =================");
        JedisPool pool = JedisExample.createJedisPool();
        // 通过Jedis连接池获取一个Jedis实例,也可以通过new Jedis(HOST,PORT)初始化Jedis
        Jedis jedis = pool.getResource();
        // 设置key-value
        String key01Result = jedis.set("key01", "value01");
        String key02Result = jedis.set("key02", "value02");
        System.out.println(key01Result); // OK
        System.out.println(key02Result); // OK
        /**
         * 设置key的value。SetParams用于set key时设置key的参数,例如:
         *  - 设置策略,NX表示仅当key不存在时,set才会生效,XX表示仅当key存在时,set才会生效。
         *    - nx():等同于设置NX参数。
         *    - xx():等同于设置XX参数。
         *  - 过期时间单位,EX表示过期时间单位为秒,PX表示过期时间单位为毫秒:
         *    - exAt(long milliseconds):以秒为单位设置key的过期时间。-1表示永不过期,默认-1。
         *    - pxAt(long milliseconds):以毫秒为单位设置key的过期时间。-1表示永不过期,默认-1。
         *  - keepttl():以秒为单位返回key的存活时间。
         */
        SetParams setParams = new SetParams().nx().pxAt(5000);
        String key03Result = jedis.set("key03", "value03", setParams);
        System.out.println(key03Result); // OK

        // 获取所有key
        Set<String> keys = jedis.keys("*");
        System.out.println("keys:" + keys); // keys:["key02","key01","k2"]

        // 刪除key,返回删除key的数量
        Long key02DelResult = jedis.del("key02");
        System.out.println("删除key的数量:" + key02DelResult); // 删除key的数量:1

        // 根据key获取value
        System.out.println(jedis.get("key01")); // value01
        System.out.println(jedis.get("key02")); // null
        System.out.println(jedis.get("key03")); // null
        System.out.println("=================================");

        System.out.println("=============== JedisPooled实例操作Redis =================");
        JedisPooled pooled = new JedisPooled(HOST, PORT);
        System.out.println(pooled.set("k1", "v1")); // OK
        System.out.println(pooled.set("k2", "v2")); // OK
        System.out.println("del key length:" + pooled.del("k1")); // del key length:1
        System.out.println("k1 value:" + pooled.get("k1")); // k1 value:null
        System.out.println("k2 value:" + pooled.get("k2")); // k1 value:v2
        System.out.println("k1 是否存在:" + pooled.exists("k1")); // k1 是否存在:false
        System.out.println("k2 type:" + pooled.type("k2")); // k2 type:string
        // 根据表达式返回匹配的key,*表示任意
        Set<String> setKeys = pooled.keys("*");
        System.out.println("k2 type:" + setKeys.size()); // 2
    }
}

package com.fly.lettuce;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.SetArgs;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.async.RedisStringAsyncCommands;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.api.sync.RedisStringCommands;

import java.util.List;
import java.util.concurrent.TimeUnit;

/**
* Lettuce操作Redis
*/
public class LettuceExample {

    private static final String HOST = "192.168.159.128";
    private static final int PORT = 6379;

    static RedisClient client;
    static StatefulRedisConnection<String, String> connection;

    /**
     * 创建连接
     */
    public static void createConnection() {
        // 创建Redis客户端实例
        client = RedisClient.create(RedisURI.create(HOST, PORT));
        // 设置默认超时时间
        client.setDefaultTimeout(20, TimeUnit.SECONDS);
        // 获取Redis状态连接
        connection = client.connect();
    }

    /**
     * 关闭连接和客户端
     */
    public static void closeConnection() {
        if (connection != null) {
            connection.close();
        }
        if (client != null) {
            client.shutdown();
        }
    }

    public static void main(String[] args) {
        LettuceExample.createConnection();
        if (connection == null) return;
        /**
         * 同步接口,connection.sync()返回一个RedisCommands对象,RedisCommands对象是一个组合接口,继承子如下接口:
         * - BaseRedisCommands:Redis基本操作命令对象。提供了ping()、reset()、检查连接状态、订阅等方法。
         * - RedisAclCommands:Redis Acl操作命令对象。Acl用于提高Redis操作安全性。
         * - RedisClusterCommands:Redis集群操作命名对象。
         * - RedisServerCommands:Redis服务器操作命令对象,用于Redis服务器相关操作。
         * - RedisKeyCommands:Redis key操作命令对象。提供了key操作方法,例如key()、keys()...
         * - RedisListCommands:Redis List类型操作命令对象,用于操作List。
         * - RedisScriptingCommands:Redis脚本操作命令对象,用于Lua脚本操作。
         * - RedisSetCommands:Redis Set类型操作命令对象。
         * - RedisSortedSetCommands:Redis ZSet类型操作命令对象。
         * - RedisStringCommands:表示Redis String类型操作命令对象。
         * - RedisGeoCommands:Redis Geo(地理位置)类型操作命令。
         * - RedisHashCommands:Redis Hashmap类型操作命令对象。
         * - RedisStreamCommands:Redis Stream类型操作命令对象。
         * - RedisTransactionalCommands:Redis事务操作命名对象。
         * - RedisHLLCommands:Redis HyperLogLog(超日志)类型操作命令对象。
         */
        RedisCommands<String, String> commands = connection.sync();
        RedisStringCommands sync = connection.sync();
        // 设置key-value
        System.out.println(sync.set("key_01", "value_01")); // OK
        /**
         * 设置key-value并指定参数:
         * - nx():等同于set key时设置NX参数。NX表示仅当key不存在时,set才会生效。
         * - xx():等同于set key时设置XX参数。XX表示仅当key存在时,set才会生效。
         * - exAt(long timestamp):以秒为单位设置key的过期时间。-1表示永不过期,默认-1。
         * - pxAt(long timestamp):以毫秒为单位设置key的过期时间。-1表示永不过期,默认-1。
         * - keepttl():以秒为单位返回key的存活时间。
         */
        SetArgs setArgs = SetArgs.Builder.nx().pxAt(5000);
        System.out.println(sync.set("key_02", "value_02",setArgs)); // OK
        System.out.println(sync.get("key_01")); // value_01
        // 获取key的类型
        System.out.println(commands.type("key_01")); // string
        // 判断key是否存在,返回一个long类型,1表示存在,0表示不存在
        System.out.println(commands.exists("key_01111")); // 1
        // 根据表达式返回匹配的key,*表示任意
        List<String> keys = commands.keys("*");
        System.out.println("all key length:"+keys.size()); // all key length:2
        LettuceExample.closeConnection();
    }
}

package com.fly;

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.DataType;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import java.time.Duration;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @SpringBootTest标识当前类是一个SpringBoot测试类, classes用于指定SpringBoot启动类
 */
@SpringBootTest(classes = RedisApplication.class)
public class RedisKeyTest {

    @Autowired
    RedisTemplate redisTemplate;

    /**
     * redis key 相关操作
     */
    @Test
    public void redisKeyTest() throws InterruptedException {
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        ops.set("k_01","v_01");
        // 设置key-value并设置过期时间,过期时间为1分钟
        ops.set("k_02","v_02", Duration.ofMinutes(1));
        // 设置key-value并设置过期时间,过期时间为10000,时间单位毫秒
        ops.set("k_03","v_03",10000, TimeUnit.MILLISECONDS);
        // 仅当key不存在时set key,若key存在则不做任何操作,set key成功返回true,否则返回false
        Boolean bool1 = ops.setIfAbsent("k_04","v_04");
        Boolean bool2 = ops.setIfAbsent("k_01","v_01");
        System.out.println("bool1:"+bool1); // bool1:true
        System.out.println("bool2:"+bool2); // bool2:false

        // 仅当key存在时set key,若key不存在则不做任何操作,set key成功返回true,否则返回false
        Boolean bool3 = ops.setIfPresent("k_01", "v_01_01");
        Boolean bool4 = ops.setIfPresent("k_05", "v_05");
        System.out.println("bool3:"+bool3); // bool3:true
        System.out.println("bool4:"+bool4); // bool4:false

        // 匹配以k_为前缀的key,*表示匹配所有key
        Set<String> keys = redisTemplate.keys("k_*");
        System.out.println("keys length:"+keys.size());

        Thread.sleep(1000);

        // 返回key对应value的类型
        DataType type = redisTemplate.type("k_01");
        System.out.println("type:"+type.code()); // type:string

        // 删除指定key
        Boolean delBool = redisTemplate.delete("k_01");
        System.out.println("delBool:"+delBool); // delBool:true
        // 删除多个指定key
        Long batchDelLong = redisTemplate.delete(
                Stream.of("k_02","k_03")
                        .collect(Collectors.toList()));
        System.out.println("batchDelLong:"+batchDelLong); // batchDelLong:2

        // 判断key是否存在
        System.out.println(redisTemplate.hasKey("k_04")); // true
        System.out.println(redisTemplate.hasKey("k_00004")); // false
        // 判断key是否持久化
        System.out.println(redisTemplate.persist("k_04")); // false
        // 修改key名称
        redisTemplate.rename("k_04","k_004");
        System.out.println("k_004:"+ops.get("k_004")); // k_004:v_04

        // 用于序列化指定key,并返回序列化后的值
        byte[] keyBytes = redisTemplate.dump("k_004");
        /**
         * restore(K key, byte[] value, long timeToLive, TimeUnit unit):将DUMP的结果反序列化回Redis
         * - key:序列化value存储的key。
         * - value:反序列的值。
         * - timeToLive:ttl,key的生存时间。
         * - unit:ttl时间单位。
         */
        redisTemplate.restore("k_0004",keyBytes,60000L,TimeUnit.MILLISECONDS);
        System.out.println("k_0004:"+ops.get("k_0004")); // k_0004:v_04

        // rename(K oldKey, K newKey):修改key的名称,将oldKey修改为newKey
        redisTemplate.rename("k_0004","k_04");
        System.out.println("k_04:"+ops.get("k_04")); // k_04:v_04

        // move(K key, final int dbIndex):将key移动到指定数据库,默认所有key都存储在0号数据库
        Boolean moveBool = redisTemplate.move("k_04", 1);
        System.out.println("moveBool:"+moveBool); // moveBool:true
        Thread.sleep(200);
        System.out.println("k_04:"+ops.get("k_04")); // k_04:null

        // 获取Lettuce连接工厂
        LettuceConnectionFactory connFactory = (LettuceConnectionFactory)redisTemplate.getConnectionFactory();
        // 切换数据库(切换至1号数据库)
        connFactory.setDatabase(1);
        // 设置连接工厂
        redisTemplate.setConnectionFactory(connFactory);
        System.out.println("k_04:"+redisTemplate.opsForValue().get("k_04")); // k_04:v_04

        // 从数据库中随机获取一个key
        System.out.println("randomKey:"+redisTemplate.randomKey()); // randomKey:k_004
    }
}

package com.fly.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.serializer.*;

/**
 * @author zchengfeng
 */
@Configuration
public class RedisConfiguration {

    /**
     * RedisTemplate是SpringBoot Redis整合包提供的用于操作Redis的模板类,提供了一列类操作
     * Redis的API,默认采用JdkSerialization进行序列化,set后的数据实际上存储的是
     * 二进制字节码,可读性非常差,通过自定义RedisTemplate
     * @param factory
     * @return
     */
     @Bean
     public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
         RedisTemplate<String, Object> template = new RedisTemplate<>();
         template.setConnectionFactory(factory);
         // Jackson2Json序列化
         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
                    new Jackson2JsonRedisSerializer(Object.class);
         ObjectMapper objectMapper = new ObjectMapper();
         objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
         jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        StringRedisSerializer stringRedisSerializer= new StringRedisSerializer();

         /**
          * 设置key采用String序列化方式,
          * Redis存取默认使用JdkSerializationRedisSerializer序列化,
          * 这种序列化会key的前缀添加奇怪的字符,例如\xac\xed\x00\x05t\x00user_id,
          * 使用StringRedisSerializer序列化可以去掉这种字符
          */
         template.setKeySerializer(stringRedisSerializer);
         template.setValueSerializer(jackson2JsonRedisSerializer);
         // hash的key也采用String的序列化方式
         template.setHashKeySerializer(stringRedisSerializer);
         // hash的value序列化方式采用jackson
         template.setHashValueSerializer(jackson2JsonRedisSerializer);
         template.afterPropertiesSet();

         /*
          * 开启Redis事务,默认是关闭的。也可以手动开启事务,
          * 通过template.multi()开启事务,template.exec()关闭事务
          */
         // template.setEnableTransactionSupport(true);
         return template;
     }
}