jedis 连接池工具类，single和sentinel方式

Alex_cun

已于 2022-01-27 10:08:37 修改

阅读量858

点赞数

分类专栏：个人笔记文章标签： java 开发语言

于 2021-12-30 10:21:01 首次发布

本文链接：https://blog.csdn.net/Alex_cun/article/details/122230450

版权

个人笔记专栏收录该内容

35 篇文章

订阅专栏

这是一个关于Java中使用Jedis连接Redis的工具类实现，包括单节点和哨兵模式的配置。代码展示了如何初始化JedisPool，获取Jedis实例，并提供了资源的关闭方法。此外，还包含了一个ConfigProperties类用于存储配置信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package com.wen.wdemo.redis;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import lombok.Data;
import org.apache.commons.collections4.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;
import redis.clients.util.Pool;

import java.util.List;

/**
 * @Description jedis 连接池工具类
 * @createTime 2021-12-24  16:02
 */
public class RedisUtil {

    private static Logger logger = LoggerFactory.getLogger(RedisUtil.class);

    private static volatile Pool<Jedis> jedisPool;

    private static final String SINGLE = "single";
    private static final String SENTINEL = "sentinel";


    /**
     * 初始化调用一次
     *
     * @param configProperties
     * @return
     */
    public static void init(ConfigProperties configProperties) {
        if (jedisPool == null) {
            synchronized (RedisUtil.class) {
                if (jedisPool == null) {
                    jedisPool = initPool(configProperties);
                }
            }
        }
        if (jedisPool == null) {
            throw new RuntimeException("JedisPool 初始化失败");
        }
    }

    /**
     * 获得连接池
     *
     * @return
     */
    public static Pool<Jedis> getInstance() {
        if (jedisPool == null) {
            throw new RuntimeException("JedisPool 没有初始化 ");
        }
        return jedisPool;
    }

    /**
     * 获得jedis客户端连接
     * 使用完需要归还连接池，调用.close()方法；或者try(){}  自动关闭
     *
     * @return
     */
    public static Jedis getJedis() {
        return getInstance().getResource();
    }

    private static Pool<Jedis> initPool(ConfigProperties configProperties) {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(configProperties.getMaxTotal());
        config.setMaxIdle(configProperties.getMaxIdle());
        config.setMaxWaitMillis(configProperties.getMaxWaitMillis());
        //在获取连接的时候检查有效性,
        //config.setTestOnBorrow(true);
        //在空闲时检查有效性, 默认false
        //config.setTestWhileIdle(true);
        if (CollectionUtils.isEmpty(configProperties.getHosts())) {
            logger.error("redis {} init failed, nodes not configured", configProperties.getType());
            return null;
        }

        if (SINGLE.equals(configProperties.getType())) {
            jedisPool = new JedisPool(config, configProperties.getHosts().get(0),
                    configProperties.getPort(), configProperties.getTimeout(),
                    configProperties.getPassword(), configProperties.getDatabase());
        }

        if (SENTINEL.equals(configProperties.getType())) {
            jedisPool = new JedisSentinelPool(configProperties.getMasterName(), Sets.newHashSet(configProperties.getHosts()), config, configProperties.getTimeout(), configProperties.getPassword(), configProperties.getDatabase());
        }


        return jedisPool;
    }


    /**
     * 配置类
     */
    @Data
    public static class ConfigProperties {
        private String type;
        private int maxTotal = 8;
        private int maxIdle = 8;
        private long maxWaitMillis = -1L;
        private List<String> hosts;
        private int port;
        private String password;
        private String masterName;
        /**
         * 单位秒，默认0；如果在一个 timeout 时间内，没有数据的交互，是否断开连接。0代表永不断开
         */
        private int timeout = 2000;
        private int database;
    }

    private RedisUtil() {

    }

    public static void main(String[] args) {
        ConfigProperties c = new ConfigProperties();
        c.setDatabase(0);
        c.setMaxIdle(2);
        c.setMaxTotal(2);
        c.setHosts(Lists.newArrayList("Hosts"));
        c.setPort(6379);
        c.setPassword("password");
        c.setType(SINGLE);
        //c.setTimeout(4);
        RedisUtil.initPool(c);


        new Thread(() -> {
            try (Jedis jedis = RedisUtil.getJedis()) {
                jedis.set("1", "1");
                jedis.expire("1", 1000);
                Thread.sleep(1000 * 3L);
                System.out.println("Thread1");
            } catch (Exception e) {
                System.err.println("Thread1 " + e.getMessage());
            }


        }, "Thread1").start();

        new Thread(() -> {
            try (Jedis jedis = RedisUtil.getJedis()) {
                jedis.set("2", "1");
                jedis.expire("2", 1000);

                Thread.sleep(1000 * 3L);
                System.out.println("Thread2");
            } catch (Exception e) {
                System.err.println("Thread2 " + e.getMessage());
            }

        }, "Thread2").start();

        new Thread(() -> {
            try (Jedis jedis = RedisUtil.getJedis()) {
                jedis.set("3", "1");
                jedis.expire("3", 1000);
                Thread.sleep(1000 * 3L);
                System.out.println("Thread3");
            } catch (Exception e) {
                System.err.println("Thread3 " + e.getMessage());
            }

        }, "Thread3").start();


    }
}