Jedis API操作redis数据库

1、配置文件

classpath路径下，新建redis.properties配置文件

配置文件内容

# Redis settings
redis.host=127.0.0.1
redis.port=6379
redis.timeout=10000
redis.maxIdle=300
redis.maxTotal=600
# 毫秒
redis.maxWaitMillis=1000
redis.testOnBorrow=false

新建属性文件工具类，用来读取redis.properties配置文件

/**
 * <p>属性文件工具类
 *
 * @author xupeng
 * @date 2019/10/28 10:39
 */
public class PropertyUtil {

    //加载property文件到io流里面
    public static Properties loadProperties(String fileName) {
        Properties properties = new Properties();
        try {
            InputStream is = PropertyUtil.class.getClassLoader().getResourceAsStream(fileName);
            properties.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }

    /**
     * 根据key值取得对应的value值
     *
     * @param key
     * @return
     */
    public static String getValue(String fileName, String key) {
        Properties properties = loadProperties(fileName);
        return properties.getProperty(key);
    }

}

新建Jedis工具类，封装常用方法

/**
 * <p>Jedis工具类
 *
 * @author xupeng
 * @date 2019/10/28 11:02
 */
public class JedisUtil {

    private Logger logger = LoggerFactory.getLogger(JedisUtil.class);

    private static JedisPool jedisPool = null;

    private JedisUtil(){}

    static {
        Properties properties = PropertyUtil.loadProperties("redis.properties");
        String host = properties.getProperty("redis.host");
        String port = properties.getProperty("redis.port");
        String timeout = properties.getProperty("redis.timeout");
        String maxIdle = properties.getProperty("redis.maxIdle");
        String maxTotal = properties.getProperty("redis.maxTotal");
        String maxWaitMillis = properties.getProperty("redis.maxWaitMillis");
        String testOnBorrow = properties.getProperty("redis.testOnBorrow");

        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(Integer.parseInt(maxIdle));
        config.setMaxTotal(Integer.parseInt(maxTotal));
        config.setMaxWaitMillis(Long.parseLong(maxWaitMillis));
        config.setTestOnBorrow(Boolean.valueOf(testOnBorrow));
        jedisPool = new JedisPool(config, host, Integer.parseInt(port), Integer.parseInt(timeout));
    }

    /**
     * <p>从jedis连接池中获取获取jedis对象
     */
    private Jedis getJedis() {
        return jedisPool.getResource();
    }

    private static final JedisUtil jedisUtil = new JedisUtil();

    /**
     * <p>获取JedisUtil实例
     */
    public static JedisUtil getInstance() {
        return jedisUtil;
    }

    /**
     * <p>设置值
     * @param key 键
     * @param value 值
     */
    public String set(String key,String value){
        String status = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                status = jedis.set(key, value);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return status;
    }

    /**
     * <p>根据键名称获取值
     * @param key 键名称
     * @return 值
     */
    public String get(String key){
        Jedis jedis = null;
        String value = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                value = jedis.get(key);

            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return value;
    }

    /**
     * <p>如果存在，不设置，返回0；不存在，进行设置，返回1。
     * @param key 键
     * @param value 值
     */
    public Long setnx(String key,String value){
        Long setnx = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                setnx = jedis.setnx(key, value);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return setnx;
    }

    /**
     * <p>设置key的有效时间
     * @param key 键
     * @param value 值
     */
    public String setex(String key,int seconds,String value){
        String setex = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                setex = jedis.setex(key, seconds, value);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return setex;
    }

    /**
     * <p>对某个值进行递增
     * @param key 键
     */
    public Long incr(String key){
        Long incr = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                incr = jedis.incr(key);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return incr;
    }

    /**
     * <p>对某个值进行递减
     * @param key 键
     */
    public Long decr(String key){
        Long incr = null;
        Jedis jedis = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                incr = jedis.decr(key);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return incr;
    }

    /**
     * <p>设置一个map类型的值
     *
     * @author zhuangxupeng
     * @date 2019/10/31 10:30
     */
    public String hmset(String key, Map<String,String> map){
        Jedis jedis = null;
        String hmset = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                hmset = jedis.hmset(key, map);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return hmset;
    }

    /**
     * <p>获取一个map类型的值
     *
     * @author zhuangxupeng
     * @date 2019/10/31 10:30
     */
    public Map<String, String> hgetAll(String key){
        Jedis jedis = null;
        Map<String, String> map = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                map = jedis.hgetAll(key);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return map;
    }

    /**
     * <p>获取key对应map的大小
     *
     * @author zhuangxupeng
     * @date 2019/10/31 10:30
     */
    public Long hlen(String key){
        Jedis jedis = null;
        Long hlen = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                hlen = jedis.hlen(key);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return hlen;
    }

    /**
     * <p>获取key对应map的所有的键的集合
     *
     * @author zhuangxupeng
     * @date 2019/10/31 10:30
     */
    public Set<String> hkeys(String key){
        Jedis jedis = null;
        Set<String> sets = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                sets = jedis.hkeys(key);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return sets;
    }

    /**
     * <p>获取key对应map的所有的值的集合
     *
     * @author zhuangxupeng
     * @date 2019/10/31 10:30
     */
    public List<String> hvals(String key){
        Jedis jedis = null;
        List<String> list = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                list = jedis.hvals(key);

            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return list;
    }

    /**
     * <p>删除
     *
     * @param key 键名称
     * @return del 删除成功返回1，失败返回0
     */
    public long del(String key) {
        Jedis jedis = null;
        Long del = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                del = jedis.del(key);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return del;
    }

    /**
     * <p>是否存在KEY
     * @param key 键
     */
    public boolean exists(String key) {
        Jedis jedis = null;
        Boolean exists = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                exists = jedis.exists(key);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return exists;
    }

    /**
     * <p>设置失效时间
     * @param key 键名称
     * @param seconds 秒数
     */
    public Long expire(String key, int seconds) {
        Jedis jedis = null;
        Long aLong = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                aLong = jedis.expire(key, seconds);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return aLong;
    }

    /**
     * 删除失效时间
     * @param key
     */
    public Long persist(String key) {
        Jedis jedis = null;
        Long persist  = null;
        try {
            jedis = getJedis();
            if (null != jedis){
                persist = jedis.persist(key);
            }
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return persist;
    }

    /**
     * <p>添加sorted set
     * <p>已经存在的值，再次添加会失败。
     *
     * @param key 键名称
     * @param score 分数值
     * @param value 实际值
     * @return zadd 成功返回1，失败返回0。
     */
    public Long zadd(String key,double score,String value) {
        Jedis jedis = null;
        Long zadd = null;
        try {
            jedis = getJedis();
            zadd = jedis.zadd(key, score, value);
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return zadd;
    }

    /**
     * 返回指定下标的集合元素
     * @param key
     * @param start 0为第一个
     * @param end -1为最后一个
     * @return
     */
    public Set<String> zrange(String key, int start, int end) {
        Jedis jedis = null;
        Set<String> sets = null;
        try {
            jedis = getJedis();
            sets = jedis.zrange(key, start, end);
        }catch (Exception e){
            logger.info("Unable to get connection from connection pool");
        }finally {
            if (null != jedis){
                jedis.close();
            }
        }
        return sets;
    }

}

写一个main方法，来进行简单测试

/**
 * <p>Jedis客户端操作redis的string数据类型
 * @author xupeng
 * @date 2019年10月28日
 */
public class JedisStringDemo {
    public static void main(String[] args) {

        JedisUtil instance = JedisUtil.getInstance();
        instance.set("name", "zhuang");

        String getNameVal = instance.get("name");
        System.out.println("get name value:" + getNameVal);

    }
}

原文地址：https://www.cnblogs.com/beanbag/p/11781298.html

时间： 2024-11-08 20:37:10

Jedis API操作redis数据库的相关文章

Redis学习（5）-Jedis(Java操作redis数据库技术)

Java连接redis 一,导入jar包 Redis有什么命令,Jedis就有什么方法 设置防火墙 在Linux上面运行如下代码: 单实例:Jedis实例: package com.jedis.demo; import org.junit.Test; import redis.clients.jedis.Jedis; public class Demo1 { /* * 单实例连接redis数据库 * */ @Test public void run() { //参数:ip地址,端口号 Jedis

java操作redis数据库实例（redis集群）

1.配置redis集群 <?xml version="1.0" encoding="UTF-8"?> <redisCluster> <!--userRoute --> <clusterGroup name="userRoute" selectdb="1"> <server host="10.177.129.16" port="6379"

Python学习之使用Python操作Redis数据库

最近在写一个检查一台服务器上所有游戏区服配置文件中redis某个key值大小的脚本,本打算使用shell+awk+sed的方式去解决这个问题,但是由于redis的配置信息是php数组形式.shell脚本一时没有写出来,就请教他人帮忙写了个python脚本,但是自己python不是很精通,于是按照脚本中涉及到的python知识现学现用,然后根据自己的需求更改脚本.这里分享一下如何使用python操作redis数据库. Redis的Python驱动源码下载地址是https://github.com/

C++操作Redis数据库

今天,Mayuyu来学习如何用C++来操作redis数据库.通过hiredis.h接口来实现,目前只能在Linux环境使用. hiredis.h的下载地址为:https://github.com/redis/hiredis 主要包括如下四个方法 1. redisContext* redisConnect(const char *ip, int port) 该函数用来连接redis数据库, 两个参数分别是redis数据库的ip和端口,端口号一般为6379.类似 的还提供了一个函数,供连接超时限定,

Anaconda 安装redis-py模块操作redis数据库

今天遇到了一个很神奇的事情 ,在使用python操作redis 数据库的时候 ,如果使用  pip install redis    安装的是python 连接 redis的模块,  但是如果是在anaconda  里面使用  conda install -c anaconda redis  安装的是  redis数据库, 这个问题折腾了一下午,最终还是搞明白的,其实在使用 conda 要安装的是  redis-py   这个文件才对,但是至于pip安装与conda安装为什么是不同的文件我也不清

python(13)---发邮件、写日志、操作redis数据库

一.写邮件 import yagmail user = '[email protected]' password = 'rtcxbuejmqrdgjcd' #不是qq密码,是邮件授权码 在qq邮箱,设置--账户--开启POP3/SMTP服务,获得授权码 m=yagmail.SMTP(host='smtp.qq.com',user=user,password=password) #host-- 163邮箱用 tp.163.com m.send(to=['[email protected]','xx

GO 语言操作 redis 数据库

redis数据库 是一种高性能的Key-Value数据库 ???NoSQL数据库 ???????缓存型数据库 key-value型数据库 错误的说法非关系型数据库 1.redis介绍 1.1NoSQL:一类新出现的数据库(not only sql) 泛指缓存型的数据库 不支持SQL语法 存储结构跟传统关系型数据库中的那种关系表完全不同,nosql中存储的数据都是KV形式 NoSQL的世界中没有一种通用的语言,每种nosql数据库都有自己的api和语法,以及擅长的业务场景 NoSQL中的产品种类相

python编程:excel文件操作,redis数据库,接口开发

1.操作mysql import pymysql # 1.连上数据库 账号.密码 ip 端口号 数据库 #2.建立游标 #3.执行sql #4 .获取结果 # 5.关闭游标 #6.连接关闭 coon = pymysql.connect( host='数据库ip',user='jxz',passwd='123456', port=3306,db='jxz',charset='utf8' #port必须写int类型, #charset这里必须写utf8 ) cur = coon.cursor() #

laravel-- 在laravel操作redis数据库的数据类型(string、哈希、无序集合、list链表、有序集合)

安装redis和连接redis数据库 在controller头部引入 一.基本使用 1 public function RedisdDbOne() { 2 // 清空Redis数据库 3 Redis::flushall(); 4 5 6 // redis的string类型 7 Redis::set("laravel","Hello woshi laravel"); 8 dump(Redis::get("laravel")) ; 9 10 11 /