配置类

pom.xml

pom.xml 里配置依赖

  1. <dependency>
  2.     <groupId>redis.clients</groupId>
  3.     <artifactId>jedis</artifactId>
  4.     <version>2.5.2</version>
  5. </dependency>

application.properties

spring 属性文件 application.properties 里配置 redis 配置项

  1. REDIS_HOST=127.0.0.1
  2. REDIS_PORT=6379
  3. REDIS_PASSWORD=xxxxxxx
    #超时时间，毫秒
  4. REDIS_TIMEOUT=1000
  5. #最大连接数
  6. REDIS_MAXTOTAL=1000
  7. #最大空闲连接数
  8. REDIS_MAXIDLE=100
  9. #最小空闲连接数
  10. REDIS_MINIDLE=100
  11. #获取连接时的最大等待毫秒数
  12. REDIS_MAXWAITMILLIS=100
  13. #默认缓存过期时间，单位秒
  14. REDIS_DEFAULT_TIMEOUT=7200

常量配置类

  1. @Configuration
  2. public class Constants {
  3.  
  4.     public static String REDIS_HOST;
  5.     public static int REDIS_PORT;
  6.     public static String REDIS_PASSWORD;
  7.     public static int REDIS_TIMEOUT;
  8.     public static int REDIS_MAXTOTAL;
  9.     public static int REDIS_MAXIDLE;
  10.     public static int REDIS_MINIDLE;
  11.     public static int REDIS_MAXWAITMILLIS;
  12.     public static int REDIS_DEFAULT_TIMEOUT;
  13.  
  14.     @Value("${REDIS_HOST}")
  15.     public void setREDIS_HOST(String rEDIS_HOST) {
  16.         REDIS_HOST = rEDIS_HOST;
  17.     }
  18.  
  19.     @Value("${REDIS_PORT}")
  20.     public void setREDIS_PORT(int rEDIS_PORT) {
  21.         REDIS_PORT = rEDIS_PORT;
  22.     }
  23.  
  24.     @Value("${REDIS_PASSWORD}")
  25.     public void setREDIS_PASSWORD(String rEDIS_PASSWORD) {
  26.         REDIS_PASSWORD = rEDIS_PASSWORD;
  27.     }
  28.  
  29.     @Value("${REDIS_TIMEOUT}")
  30.     public void setREDIS_TIMEOUT(int rEDIS_TIMEOUT) {
  31.         REDIS_TIMEOUT = rEDIS_TIMEOUT;
  32.     }
  33.  
  34.     @Value("${REDIS_MAXTOTAL}")
  35.     public void setREDIS_MAXTOTAL(int rEDIS_MAXTOTAL) {
  36.         REDIS_MAXTOTAL = rEDIS_MAXTOTAL;
  37.     }
  38.  
  39.     @Value("${REDIS_MAXIDLE}")
  40.     public void setREDIS_MAXIDLE(int rEDIS_MAXIDLE) {
  41.         REDIS_MAXIDLE = rEDIS_MAXIDLE;
  42.     }
  43.  
  44.     @Value("${REDIS_MINIDLE}")
  45.     public void setREDIS_MINIDLE(int rEDIS_MINIDLE) {
  46.         REDIS_MINIDLE = rEDIS_MINIDLE;
  47.     }
  48.  
  49.     @Value("${REDIS_MAXWAITMILLIS}")
  50.     public void setREDIS_MAXWAITMILLIS(int rEDIS_MAXWAITMILLIS) {
  51.         REDIS_MAXWAITMILLIS = rEDIS_MAXWAITMILLIS;
  52.     }
  53.  
  54.     @Value("${REDIS_DEFAULT_TIMEOUT}")
  55.     public void setREDIS_DEFAULT_TIMEOUT(int rEDIS_DEFAULT_TIMEOUT) {
  56.         REDIS_DEFAULT_TIMEOUT = rEDIS_DEFAULT_TIMEOUT;
  57.     }
  58. }

工厂类

Jedis工厂类（枚举）

  1. import org.slf4j.Logger;
  2. import org.slf4j.LoggerFactory;
  3.  
  4. import com.zcdog.market.util.Constants;
  5.  
  6. import redis.clients.jedis.Jedis;
  7. import redis.clients.jedis.JedisPool;
  8. import redis.clients.jedis.JedisPoolConfig;
  9. import redis.clients.jedis.exceptions.JedisConnectionException;
  10. import redis.clients.jedis.exceptions.JedisDataException;
  11.  
  12. public enum JedisFactory {
  13.  
  14.     INSTANCE;
  15.  
  16.     private static Logger logger = LoggerFactory.getLogger(JedisFactory.class);
  17.  
  18.     private volatile JedisPool pool;
  19.  
  20.     /**
  21.      * 获取Jedis连接
  22.      * @return
  23.      */
  24.     public Jedis getConnection() {
  25.         if (pool == null) {
  26.             synchronized (INSTANCE) {
  27.                 if (pool == null) {
  28.                     logger.debug("init jedis pool." + Thread.currentThread().getName());
  29.                     JedisPoolConfig poolConfig = new JedisPoolConfig();
  30.                     poolConfig.setMaxTotal(Constants.REDIS_MAXTOTAL);
  31.                     poolConfig.setMaxIdle(Constants.REDIS_MAXIDLE);
  32.                     poolConfig.setMinIdle(Constants.REDIS_MINIDLE);
  33.                     poolConfig.setMaxWaitMillis(Constants.REDIS_MAXWAITMILLIS);
  34.                     if (Constants.REDIS_PASSWORD != null && !"".equals(Constants.REDIS_PASSWORD)) {
  35.                         pool = new JedisPool(poolConfig, Constants.REDIS_HOST, Constants.REDIS_PORT, Constants.REDIS_TIMEOUT, Constants.REDIS_PASSWORD);
  36.                     }else {
  37.                         pool = new JedisPool(poolConfig, Constants.REDIS_HOST, Constants.REDIS_PORT, Constants.REDIS_TIMEOUT);
  38.                     }
  39.                 }
  40.             }
  41.         }
  42.         return pool.getResource();
  43.     }
  44.  
  45.     /**
  46.      * 处理Jedis连接异常
  47.      * 记录日志并返回连接是否中断
  48.      * @param jedisException
  49.      * @return
  50.      */
  51.     public boolean handleJedisException(Exception jedisException) {
  52.         if (jedisException instanceof JedisConnectionException) {
  53.             logger.error("Redis connection lost.", jedisException);
  54.         } else if (jedisException instanceof JedisDataException) {
  55.             if ((jedisException.getMessage() != null) && (jedisException.getMessage().indexOf("READONLY") != -1)) {
  56.                 logger.error("Redis connection is read-only slave.", jedisException);
  57.             } else {
  58.                 return false;
  59.             }
  60.         } else {
  61.             logger.error("Jedis happen exception.", jedisException);
  62.         }
  63.         return true;
  64.     }
  65.  
  66.    /**
  67.     * 返回Jedis连接到连接池
  68.     * 根据连接状态调用不同的返回方法
  69.     * @param jedis
  70.     * @param exceptionFlag
  71.     */
  72.     public void closeResource(Jedis jedis, boolean exceptionFlag) {
  73.         try {
  74.             if (exceptionFlag) {
  75.                 pool.returnBrokenResource(jedis);
  76.             } else if (!exceptionFlag && jedis != null) {
  77.                 pool.returnResource(jedis);
  78.             }
  79.         } catch (Exception e) {
  80.             logger.error("Return back jedis failed, will close the jedis.", e);
  81.             try {
  82.                 jedis.quit();
  83.             } catch (Exception ex) {
  84.                 logger.error("Jedis quit error.", ex);
  85.             }
  86.             try {
  87.                 jedis.disconnect();
  88.             } catch (Exception exd) {
  89.                 logger.error("Jedis disconnect error.", exd);
  90.             }
  91.         }
  92.     }
  93. }

工具类

Jedis工具类，如果没有适用的方法，可自行添加，仅作示例。

更多可参考：Jedis工具类

  1. import java.util.List;
  2. import java.util.Map;
  3. import java.util.Set;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import redis.clients.jedis.Jedis;
  7. import redis.clients.jedis.Transaction;
  8.  
  9. public class RedisUtils {
  10.  
  11.     private static Logger logger = LoggerFactory.getLogger(RedisUtils.class);
  12.  
  13.     private static Jedis getConnection() {
  14.         return JedisFactory.INSTANCE.getConnection();
  15.     }
  16.  
  17.     public static void closeResource(Jedis jedis, boolean exceptionFlag) {
  18.         JedisFactory.INSTANCE.closeResource(jedis, exceptionFlag);
  19.     }
  20.  
  21.     public static boolean handleJedisException(Exception jedisException) {
  22.         return JedisFactory.INSTANCE.handleJedisException(jedisException);
  23.     }
  24.  
  25.     public static void save(String key, String value) {
  26.         save(key, value, Constants.REDIS_DEFAULT_TIMEOUT);
  27.     }
  28.  
  29.     public static void save(String key, String value, int expires) {
  30.         Jedis jedis = null;
  31.         boolean exceptionFlag = false;
  32.         try {
  33.             jedis = getConnection();
  34.             if (key == null || "".equals(key)) {
  35.                 return;
  36.             }
  37.             jedis.setex(key, expires, value);
  38.         } catch (Exception e) {
  39.             exceptionFlag = handleJedisException(e);
  40.             logger.error("save redis error:", e);
  41.         } finally {
  42.             closeResource(jedis, exceptionFlag);
  43.         }
  44.     }
  45.  
  46.     public static String get(String key) {
  47.         boolean exceptionFlag = false;
  48.         Jedis jedis = null;
  49.         String value = null;
  50.         try {
  51.             jedis = getConnection();
  52.             value = jedis.get(key);
  53.             return value;
  54.         } catch (Exception e) {
  55.             exceptionFlag = handleJedisException(e);
  56.             logger.error("get redis error :", e);
  57.             return value;
  58.         } finally {
  59.             closeResource(jedis, exceptionFlag);
  60.         }
  61.     }
  62.  
  63.     public static void delete(String key) {
  64.         boolean exceptionFlag = false;
  65.         Jedis jedis = null;
  66.         try {
  67.             if (key == null || "".equals(key)) {
  68.                 return;
  69.             }
  70.             jedis = getConnection();
  71.             jedis.del(key);
  72.         } catch (Exception e) {
  73.             exceptionFlag = handleJedisException(e);
  74.             logger.error("delete redis error:", e);
  75.         } finally {
  76.             closeResource(jedis, exceptionFlag);
  77.         }
  78.     }
  79.  
  80.     public static List<String> mget(String[] keys) {
  81.         boolean exceptionFlag = false;
  82.         Jedis jedis = null;
  83.         try {
  84.             List<String> list = null;
  85.             jedis = getConnection();
  86.             list = jedis.mget(keys);
  87.             return list;
  88.         } catch (Exception e) {
  89.             exceptionFlag = handleJedisException(e);
  90.             return null;
  91.         } finally {
  92.             closeResource(jedis, exceptionFlag);
  93.         }
  94.     }
  95.  
  96.     public static String hget(String key, String field) {
  97.         boolean exceptionFlag = false;
  98.         Jedis jedis = null;
  99.         String value = null;
  100.         try {
  101.             jedis = getConnection();
  102.             value = jedis.hget(key, field);
  103.             return value;
  104.         } catch (Exception e) {
  105.             exceptionFlag = handleJedisException(e);
  106.             return value;
  107.         } finally {
  108.             closeResource(jedis, exceptionFlag);
  109.         }
  110.     }
  111.  
  112.     public static String setnx(String key, String value) {
  113.         boolean exceptionFlag = false;
  114.         Jedis jedis = null;
  115.         String result = null;
  116.         try {
  117.             jedis = getConnection();
  118.             result = jedis.set(key, value, "NX", "EX", 300L);
  119.             return result;
  120.         } catch (Exception e) {
  121.             exceptionFlag = handleJedisException(e);
  122.             return result;
  123.         } finally {
  124.             closeResource(jedis, exceptionFlag);
  125.         }
  126.     }
  127.  
  128.     public static void hsetTransaction(String key1, String field1, String value1, String key2, String field2,
  129.             String value2, int timeout) {
  130.         boolean exceptionFlag = false;
  131.         Jedis jedis = null;
  132.         try {
  133.             jedis = getConnection();
  134.             Transaction multi = jedis.multi();
  135.             multi.hset(key1, field1, value1);
  136.             multi.expire(key1, Constants.REDIS_DEFAULT_TIMEOUT);
  137.  
  138.             multi.hset(key2, field2, value2);
  139.             multi.expire(key2, timeout);
  140.             multi.exec();
  141.             logger.info("[redis] hsetTransaction success key1: {} field1: {} key2: {} field2: {}", key1, field1, key2,
  142.                     field2);
  143.         } catch (Exception e) {
  144.             exceptionFlag = handleJedisException(e);
  145.             logger.error("  hset hsetTransaction error :", e);
  146.         } finally {
  147.             closeResource(jedis, exceptionFlag);
  148.         }
  149.  
  150.     }
  151.  
  152.     public static void hsetTransactionWithDeleteV2(String key1, String field1, String value1, String key2,
  153.             String field2, String value2, int timeout, String deleteKey) {
  154.         boolean exceptionFlag = false;
  155.         Jedis jedis = null;
  156.         try {
  157.             jedis = getConnection();
  158.             Transaction multi = jedis.multi();
  159.             multi.hset(key1, field1, value1);
  160.             multi.expire(key1, Constants.REDIS_DEFAULT_TIMEOUT);
  161.  
  162.             multi.hset(key2, field2, value2);
  163.             multi.expire(key2, timeout);
  164.             multi.del(deleteKey);
  165.             multi.exec();
  166.             logger.info("[redis] hsetTransactionWithDelete success key1: {} field1: {} key2: {} field2: {}", key1,
  167.                     field1, key2, field2);
  168.         } catch (Exception e) {
  169.             exceptionFlag = handleJedisException(e);
  170.             logger.error("  hsetTransactionWithDelete redis error :", e);
  171.         } finally {
  172.             closeResource(jedis, exceptionFlag);
  173.         }
  174.  
  175.     }
  176.  
  177.     public static Map<?, ?> hgetall(String key) {
  178.         boolean exceptionFlag = false;
  179.         Jedis jedis = null;
  180.         Map<?, ?> value = null;
  181.         try {
  182.             jedis = getConnection();
  183.             value = jedis.hgetAll(key);
  184.             return value;
  185.         } catch (Exception e) {
  186.             exceptionFlag = handleJedisException(e);
  187.             logger.error("  hgetall redis error :", e);
  188.             return value;
  189.         } finally {
  190.             closeResource(jedis, exceptionFlag);
  191.         }
  192.     }
  193.  
  194.     public static void hset(String key, String field, String value) {
  195.         hset(key, field, value, Constants.REDIS_DEFAULT_TIMEOUT);
  196.     }
  197.  
  198.     public static void hset(String key, String field, String value, int expireTime) {
  199.         boolean exceptionFlag = false;
  200.         Jedis jedis = null;
  201.         try {
  202.             jedis = getConnection();
  203.             jedis.hset(key, field, value);
  204.             jedis.expire(key, expireTime);
  205.         } catch (Exception e) {
  206.             exceptionFlag = handleJedisException(e);
  207.             logger.error("  hset redis error :", e);
  208.         } finally {
  209.             closeResource(jedis, exceptionFlag);
  210.         }
  211.     }
  212.  
  213.     public static void hdelete(String key, String field) {
  214.         boolean exceptionFlag = false;
  215.         Jedis jedis = null;
  216.         try {
  217.             jedis = getConnection();
  218.             jedis.hdel(key, field);
  219.         } catch (Exception e) {
  220.             exceptionFlag = handleJedisException(e);
  221.             logger.error("  hdel redis error :", e);
  222.         } finally {
  223.             closeResource(jedis, exceptionFlag);
  224.         }
  225.     }
  226.  
  227.     public static boolean hexist(String key, String field) {
  228.         boolean exceptionFlag = false;
  229.         Jedis jedis = null;
  230.         try {
  231.             jedis = getConnection();
  232.             boolean flag = jedis.hexists(key, field);
  233.             return flag;
  234.         } catch (Exception e) {
  235.             exceptionFlag = handleJedisException(e);
  236.             logger.error("hexist redis error:", e);
  237.             return false;
  238.         } finally {
  239.             closeResource(jedis, exceptionFlag);
  240.         }
  241.     }
  242.  
  243.     public static int hlen(String key) {
  244.         boolean exceptionFlag = false;
  245.         Jedis jedis = null;
  246.         try {
  247.             jedis = getConnection();
  248.             return jedis.hlen(key).intValue();
  249.         } catch (Exception e) {
  250.             exceptionFlag = handleJedisException(e);
  251.             logger.error("  hlen redis error :", e);
  252.             return 0;
  253.         } finally {
  254.             closeResource(jedis, exceptionFlag);
  255.         }
  256.     }
  257.  
  258.     public static Set<String> hkeys(String key) {
  259.         boolean exceptionFlag = false;
  260.         Jedis jedis = null;
  261.         Set<String> skey = null;
  262.         try {
  263.             jedis = getConnection();
  264.             skey = jedis.hkeys(key);
  265.             return skey;
  266.         } catch (Exception e) {
  267.             exceptionFlag = handleJedisException(e);
  268.             logger.error("hkeys redis error:", e);
  269.             return skey;
  270.         } finally {
  271.             closeResource(jedis, exceptionFlag);
  272.         }
  273.     }
  274.  
  275. }

Jedis 操作 Redis 工具类的更多相关文章

  1. Java操作Redis工具类

    依赖 jar 包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis< ...

  2. redis 工具类 单个redis、JedisPool 及多个redis、shardedJedisPool与spring的集成配置

    http://www.cnblogs.com/edisonfeng/p/3571870.html http://javacrazyer.iteye.com/blog/1840161 http://ww ...

  3. Redis操作Set工具类封装，Java Redis Set命令封装

    Redis操作Set工具类封装,Java Redis Set命令封装 >>>>>>>>>>>>>>>>& ...

  4. Redis操作List工具类封装，Java Redis List命令封装

    Redis操作List工具类封装,Java Redis List命令封装 >>>>>>>>>>>>>>>> ...

  5. Redis操作Hash工具类封装，Redis工具类封装

    Redis操作Hash工具类封装,Redis工具类封装 >>>>>>>>>>>>>>>>>> ...

  6. Redis操作字符串工具类封装，Redis工具类封装

    Redis操作字符串工具类封装,Redis工具类封装 >>>>>>>>>>>>>>>>>>& ...

  7. redistemplate优雅地操作redis redis 工具类

    参考:https://www.cnblogs.com/superfj/p/9232482.html redis 工具类 package com.service; import org.springfr ...

  8. Java中使用Jedis操作Redis（转载）

    整理 1.字符串 添加:set keyname value 查询:get keyname 拼接:append keyname value 删除:del keyname 添加多个: mset keyna ...

  9. jedis操作redis全指南

    package com.wujintao.redis; import java.util.Date; import java.util.HashMap; import java.util.Iterat ...

随机推荐

  1. Install weblogic in silent mode

    使用静默(silent)模式来安装weblogic,在需要将安装脚本化,或无法使用图形界面的时候非常有用. 下面按照自己在实际工作中碰到的例子,来慢慢总结不同版本和平台weblogic的静默安装方法. ...

  2. git pull时解决分支分叉（branch diverged）问题

    git pull时出现分支冲突(branch diverged) $ git status # On branch feature/worker-interface # Your branch and ...

  3. centos7-内核版本降级

    1. 查看内核版本参考命令: [root@localhost ~]# cat /etc/redhat-release CentOS Linux release 7.3.1611 (Core) [roo ...

  4. Demo002 IDEA中Junit单元测试的使用(初级篇)

    推荐JUnit视频教程:JUnit-Java单元测试必备工具. 1.基本理论 1.1 单元测试 单元测试又称模块测试,属于白盒测试,是最小单位的测试.模块分为程序模块和功能模块.功能模块指实现了一个完 ...

  5. 清理xcode

    移除 Xcode 运行安装 APP 产生的缓存文件(DerivedData) ~/Library/Developer/Xcode/DerivedData 移除 APP 打包的ipa历史版本(Archi ...

  6. mybatis的基础Dao

    话不多说,直接贴代码吧,因为很多博客都需要用到这个基础dao,怕大家不好查询. 这个基类主要是使用了泛型,这样我就不必为每一个实体都写一个dao,大大节省了时间.其中sqlSessionTemplat ...

  7. 源发行版 1.8 需要目标发行版 1.8以及usage of api documented as @since 1.8+

    Maven项目每个Module都有单独的pom.xml,如果不在pom.xml中进行配置,则默认将Module的Language Level设置为5.所以要在pom.xml文件中添加插件进行配置. & ...

  8. jqgrid获取选中行指定列的值

    部分js如下: var id = $("#grid-table").jqGrid('getGridParam','selrow');//根据点击行获得点击行的id(id为jsonR ...

  9. 这里有一篇简单易懂的webSocket 快到碗里来~

    这篇文章是我在学习的时候看到的  刚开始还不是很理解  后来自己百度 又问了一些人  回过头在看这篇文章 真的挺好的 但是原创已经不知道是谁了  转载哦~~~ -------------------- ...

  10. javaweb开发.调试

    一.快速调试一个类 1.类里面写public static void main(String[] args) throws Exception{}方法 2.该类上右键->Run As->J ...