redis的工具类详细

1. Java中常用的Redis工具类先是JedisUtil工具类：

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Redis工具类，封装Jedis操作Redis的基本方法
 */
public class JedisRedisUtil {

    private static String redisHost = "localhost"; // Redis服务器IP
    private static int redisPort = 6379; // Redis服务器端口号
    private static String redisAuth = null; // Redis服务器密码
    private static int redisTimeout = 5000; // 连接超时时间
    private static int redisMaxIdle = 10; // 最大空闲连接数
    private static int redisMaxTotal = 100; // 最大连接数
    private static int redisMaxWaitMillis = 5000; // 最大等待时间（毫秒）

    private static JedisPool jedisPool = null;

    /**
     * 初始化JedisPool连接池
     */
    static {
        try {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxTotal(redisMaxTotal);
            jedisPoolConfig.setMaxIdle(redisMaxIdle);
            jedisPoolConfig.setMaxWaitMillis(redisMaxWaitMillis);
            if (redisAuth != null && !redisAuth.isEmpty()) {
                jedisPool = new JedisPool(jedisPoolConfig, redisHost, redisPort, redisTimeout, redisAuth);
            } else {
                jedisPool = new JedisPool(jedisPoolConfig, redisHost, redisPort, redisTimeout);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取Jedis实例
     * @return Jedis实例
     */
    public synchronized static Jedis getJedis() {
        Jedis jedis = null;
        try {
            if (jedisPool != null) {
                jedis = jedisPool.getResource();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return jedis;
    }

    /**
     * 释放Jedis资源
     * @param jedis Jedis实例
     */
    public static void closeJedis(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }

    /**
     * 设置缓存
     * @param key 键
     * @param value 值
     * @return String 缓存结果
     */
    public static String set(String key, String value) {
        String result = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            result = jedis.set(key, value);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeJedis(jedis);
        }
        return result;
    }

    /**
     * 获取缓存
     * @param key 键
     * @return String 值
     */
    public static String get(String key) {
        String result = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            result = jedis.get(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeJedis(jedis);
        }
        return result;
    }

    /**
     * 删除缓存
     * @param key 键
     * @return Long 删除的数量
     */
    public static Long del(String key) {
        Long result = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            result = jedis.del(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeJedis(jedis);
        }
        return result;
    }

    /**
     * 判断缓存中是否存在指定的key
     * @param key 键
     * @return Boolean 存在返回true，否则返回false
     */
    public static Boolean exists(String key) {
        Boolean result = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            result = jedis.exists(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeJedis(jedis);
        }
        return result;
    }

    /**
     * 设置key的缓存超时时间
     * @param key 键
     * @param seconds 超时时间（秒）
     * @return Long 设置成功返回1，否则返回0
     */
    public static Long expire(String key, int seconds) {
        Long result = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            result = jedis.expire(key, seconds);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeJedis(jedis);
        }
        return result;
    }
}

1. 这个JedisUtil工具类完成了封装Jedis操作Redis的基本方法，包括以下方法：

• 初始化JedisPool连接池
• 获取Jedis实例
• 释放Jedis资源
• 设置缓存
• 获取缓存
• 删除缓存
• 判断缓存中是否存在指定的key
• 设置key的缓存超时时间

1. 以下是一个基于Lettuce的Redis工具类的示例代码：

import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.async.RedisAsyncCommands;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.cluster.ClusterClientOptions;
import io.lettuce.core.cluster.ClusterTopologyRefreshOptions;

import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Redis工具类，封装了Lettuce连接池，提供基本的同步和异步操作接口
 */
public class LettuceRedisUtils {
    private static RedisClient redisClient;
    private static StatefulRedisConnection<String, String> connection;
    private static RedisCommands<String, String> syncCommands;
    private static RedisAsyncCommands<String, String> asyncCommands;

    static {
        // 初始化Redis连接池
        redisClient = RedisClient.create("redis://localhost:6379");
        connection = redisClient.connect();
        syncCommands = connection.sync();
        asyncCommands = connection.async();
    }

    /**
     * 关闭Redis连接池
     */
    public static void close() {
        if (connection != null) {
            connection.close();
        }
        if (redisClient != null) {
            redisClient.shutdown();
        }
    }

    /**
     * 获取Redis连接池
     *
     * @return RedisClient对象
     */
    public static RedisClient getRedisClient() {
        return redisClient;
    }

    /**
     * 获取同步操作接口
     *
     * @return RedisCommands对象
     */
    public static RedisCommands<String, String> getSyncCommands() {
        return syncCommands;
    }

    /**
     * 获取异步操作接口
     *
     * @return RedisAsyncCommands对象
     */
    public static RedisAsyncCommands<String, String> getAsyncCommands() {
        return asyncCommands;
    }

    /**
     * 设置指定key的值
     *
     * @param key   键
     * @param value 值
     */
    public static void set(String key, String value) {
        syncCommands.set(key, value);
    }

    /**
     * 获取指定key的值
     *
     * @param key 键
     * @return 值
     */
    public static String get(String key) {
        return syncCommands.get(key);
    }

    /**
     * 删除指定key
     *
     * @param key 键
     */
    public static void del(String key) {
        syncCommands.del(key);
    }

    /**
     * 批量删除指定key
     *
     * @param keys 键的列表
     */
    public static void del(List<String> keys) {
        syncCommands.del(keys.toArray(new String[keys.size()]));
    }

    /**
     * 判断指定key是否存在
     *
     * @param key 键
     * @return 如果存在返回true，否则返回false
     */
    public static boolean exists(String key) {
        return syncCommands.exists(key) == 1;
    }

    /**
     * 获取指定key的过期时间
     *
     * @param key 键
     * @return 过期时间（秒）, 如果key不存在或未设置过期时间返回-1
     */
    public static long ttl(String key) {
        return syncCommands.ttl(key);
    }

    /**
     * 设置指定key的过期时间
     *
     * @param key     键
     * @param timeout 超时时间（秒）
     */
    public static void expire(String key, int timeout) {
        syncCommands.expire(key, timeout);
    }

    /**
     * 获取指定key的类型
     *
     * @param key 键
     * @return key的类型
     */
    public static String type(String key) {
        return syncCommands.type(key).name();
    }

    /**
     * 获取指定pattern匹配的所有key
     *
     * @param pattern 匹配模式
     * @return 键的列表
     */
    public static Set<String> keys(String pattern) {
        return syncCommands.keys(pattern);
    }

    /**
     * 在指定哈希表中设置字段的值
     *
     * @param key   哈希表名
     * @param field 字段名
     * @param value 值
     */
    public static void hset(String key, String field, String value) {
        syncCommands.hset(key, field, value);
    }

    /**
     * 在指定哈希表中获取指定字段的值
     *
     * @param key   哈希表名
     * @param field 字段名
     * @return 字段的值
     */
    public static String hget(String key, String field) {
        return syncCommands.hget(key, field);
    }

    /**
     * 删除指定哈希表中的指定字段
     *
     * @param key    哈希表名
     * @param fields 字段名列表
     * @return 删除的字段数量
     */
    public static long hdel(String key, String... fields) {
        return syncCommands.hdel(key, fields);
    }

    /**
     * 获取指定哈希表中所有的字段和值
     *
     * @param key 哈希表名
     * @return 哈希表中所有的字段和值
     */
    public static Map<String, String> hgetall(String key) {
        return syncCommands.hgetall(key);
    }

    /**
     * 在列表的头部添加一个或多个值
     *
     * @param key   列表名
     * @param value 值的列表
     * @return 列表长度
     */
    public static long lpush(String key, String... value) {
        return syncCommands.lpush(key, value);
    }

    /**
     * 在列表的尾部添加一个或多个值
     *
     * @param key   列表名
     * @param value 值的列表
     * @return 列表长度
     */
    public static long rpush(String key, String... value) {
        return syncCommands.rpush(key, value);
    }

    /**
     * 获取列表的长度
     *
     * @param key 列表名
     * @return 列表长度
     */
    public static long llen(String key) {
        return syncCommands.llen(key);
    }

    /**
     * 获取列表指定范围内的元素
     *
     * @param key   列表名
     * @param start 起始位置（含）
     * @param end   结束位置（含）
     * @return 列表元素的列表
     */
    public static List<String> lrange(String key, int start, int end) {
        return syncCommands.lrange(key, start, end);
    }

    /**
     * 配置Redis Cluster的Topology Refresh选项，启用自动刷新Cluster节点信息的功能
     *
     * @param interval 刷新间隔时间
     */
    public static void enableClusterTopologyRefresh(Duration interval) {
        ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
                .enablePeriodicRefresh(interval)
                .enableAllAdaptiveRefreshTriggers()
                .build();
        redisClient.setOptions(ClusterClientOptions.builder()
                .topologyRefreshOptions(topologyRefreshOptions)
                .build());
    }
}

1. 以上代码实现了基本的Redis操作功能，包括设置和获取值、删除键、判断键是否存在、设置和获取过期时间、获取键的类型、获取所有匹配的键、在哈希表中设置和获取字段值、在列表中添加和获取元素等。以下是各个方法的注释说明：

• close()：关闭Redis连接池
• getRedisClient()：获取RedisClient对象
• getSyncCommands()：获取RedisCommands对象（同步操作接口）
• getAsyncCommands()：获取RedisAsyncCommands对象（异步操作接口）
• set(String key, String value)：设置指定key的值
• get(String key)：获取指定key的值
• del(String key)：删除指定key
• del(List<String> keys)：批量删除指定key
• exists(String key)：判断指定key是否存在
• ttl(String key)：获取指定key的过期时间
• expire(String key, int timeout)：设置指定key的过期时间
• type(String key)：获取指定key的类型
• keys(String pattern)：获取指定pattern匹配的所有key
• hset(String key, String field, String value)：在指定哈希表中设置字段的值
• hget(String key, String field)：在指定哈希表中获取指定字段的值
• hdel(String key, String... fields)：删除指定哈希表中的指定字段
• hgetall(String key)：获取指定哈希表中所有的字段和值
• lpush(String key, String... value

?

?