博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
SpringBoot中搭建Redis缓存
阅读量：7090 次
发布时间：2019-06-28

本文共 9104 字，大约阅读时间需要 30 分钟。

SpringBoot中搭建Redis缓存

（一）SpringBoot中搭建Redis缓存

这篇文章讲述如何在Springboot中搭建redis，参考了很多大神的文章但是运用在我的项目里却不能发挥出来

，可能框架原因把，因为是在项目搭建完成后再来搭的redis的。搭建redis我感觉我这篇文章比较简单、方便、容易维护话不多说进入正题。

1)、以下链接 是如何在window本地搭建redis进行测试

注意：在导入jedis-2.6.2.jar、spring-data-redis-1.4.2.RELEASE.jar  如果你下载的版本太低可能会提示版本有误（解决方法只要重新下一个高版本就行了），我这个版本应该是没错的。之前

spring-data-redis-1.4.2.RELEASE.jar 我是下载1.0.0所以太低了。

2）在Springboot运用redis方法进行缓存操作

第一步：在pom.xml文件中配置redis

[html] view plain copy

  1. <!--redis配置-->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-redis</artifactId>  <!-- 可以不需要加入版本号 -->
  5. </dependency>
  7.  <dependency>
  8.         <groupId>redis.clients</groupId>
  9.         <artifactId>jedis</artifactId>
  10.          <version>2.5.2</version>
  11.     </dependency>

第二步：初始化Redis连接池 ，操作redis

CacheKit.java:

[html] view plain copy

  1. package com.zcwl.redis;
  3. import java.util.ArrayList;
  4. import java.util.Date;
  5. import java.util.Iterator;
  6. import java.util.List;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  11. import com.alibaba.fastjson.JSONArray;
  12. import com.alibaba.fastjson.JSONObject;
  14. import redis.clients.jedis.Jedis;
  15. import redis.clients.jedis.JedisPool;
  16. import redis.clients.jedis.JedisPoolConfig;
  17. import redis.clients.jedis.exceptions.JedisConnectionException;
  19. public class CacheKit {
  21.     private static Logger logger = LoggerFactory.getLogger(CacheKit.class);
  23.     private List<JSONObject> resultList;
  25.     private static JedisPool pool;
  28.      /**
  29.      * 初始化Redis连接池
  30.      */
  31.     private static void initializePool() {
  32.         //redisURL 与 redisPort 的配置文件
  34.         JedisPoolConfig config = new JedisPoolConfig();
  35.         //设置最大连接数（100个足够用了，没必要设置太大）
  36.         config.setMaxTotal(100);
  37.         //最大空闲连接数
  38.         config.setMaxIdle(10);
  39.         //获取Jedis连接的最大等待时间（50秒）
  40.         config.setMaxWaitMillis(50 * 1000);
  41.         //在获取Jedis连接时，自动检验连接是否可用
  42.         config.setTestOnBorrow(true);
  43.         //在将连接放回池中前，自动检验连接是否有效
  44.         config.setTestOnReturn(true);
  45.         //自动测试池中的空闲连接是否都是可用连接
  46.         config.setTestWhileIdle(true);
  47.         //创建连接池
  48.         //pool = new JedisPool(config, "120.88.166.244",6379);  //连接阿里云服务器上面的缓存（如果本地在使用地址，本地运行将会把本地缓存数据同步在线上缓存中）
  49.         pool = new JedisPool(config, "127.0.0.1",6379); //本地缓存（更新需要将这个注释起来，解开上面地址）
  50.     }
  53.     /**
  54.      * 多线程环境同步初始化（保证项目中有且仅有一个连接池）
  55.      */
  56.     private static synchronized void poolInit() {
  57.         if (null == pool) {
  58.             initializePool();
  59.         }
  60.     }
  62.     /**
  63.      * 获取Jedis实例
  64.      */
  65.     private static Jedis getJedis() {
  66.         if (null == pool) {
  67.             poolInit();
  68.         }
  70.         int timeoutCount = 0;
  71.         while (true) {
  72.             try {
  73.                 if (null != pool) {
  74.                     return pool.getResource();
  75.                 }
  76.             } catch (Exception e) {
  77.                 if (e instanceof JedisConnectionException) {
  78.                     timeoutCount++;
  79.                     logger.warn("getJedis timeoutCount={}", timeoutCount);
  80.                     if (timeoutCount > 3) {
  81.                         break;
  82.                     }
  83.                 } else {
  84.                    /* logger.warn("jedisInfo ... NumActive=" + pool.getResource().get("")
  85.                             + ", NumIdle=" + pool.getNumIdle()
  86.                             + ", NumWaiters=" + pool.getNumWaiters()
  87.                             + ", isClosed=" + pool.isClosed());  */
  88.                     logger.warn(pool.getResource()+"//"+pool);
  89.                     logger.error("GetJedis error,", e);
  90.                     break;
  91.                 }
  92.             }
  93.             break;
  94.         }
  95.         return null;
  96.     }
  99.     /**
  100.      * 释放Jedis资源
  101.      *
  102.      * @param jedis
  103.      */
  104.     private static void returnResource(Jedis jedis) {
  105.         if (null != jedis) {
  106.             pool.returnResourceObject(jedis);
  107.         }
  108.     }
  110.     /**
  111.      * 绝对获取方法（保证一定能够使用可用的连接获取到 目标数据）
  112.      * Jedis连接使用后放回
  113.      * @param key
  114.      * @return
  115.      */
  116.     private String safeGet(String key) {
  117.         Jedis jedis = getJedis();
  118.         while (true) {
  119.             if (null != jedis) {
  120.                 break;
  121.             } else {
  122.                 jedis = getJedis();
  123.             }
  124.         }
  125.         String value = jedis.get(key);
  126.         returnResource(jedis);
  127.         return value;
  128.     }
  131.     /**
  132.      * 绝对设置方法（保证一定能够使用可用的链接设置 数据）
  133.      * Jedis连接使用后返回连接池
  134.      * @param key
  135.      * @param time
  136.      * @param value
  137.      */
  138.     public void safeSet(String key, int time, String value) {
  139.         Jedis jedis = getJedis();
  140.         while (true) {
  141.             if (null != jedis) {
  142.                 break;
  143.             } else {
  144.                 jedis = getJedis();
  145.             }
  146.         }
  147.         jedis.setex(key, time, value);
  148.         returnResource(jedis);
  149.     }
  151.     /**
  152.      * 绝对删除方法（保证删除绝对有效）
  153.      * Jedis连接使用后返回连接池</span>
  154.      * @param key
  155.      */
  156.     private void safeDel(String key) {
  157.         Jedis jedis = getJedis();
  158.         while (true) {
  159.             if (null != jedis) {
  160.                 break;
  161.             } else {
  162.                 jedis = getJedis();
  163.             }
  164.         }
  165.         jedis.del(key);
  166.         returnResource(jedis);
  167.     }
  169.     /**
  170.      * 清除所有缓存
  171.      */
  172.     private static void clearCache(){
  173.         CacheKit kit = new CacheKit();
  174.         Jedis jedis = getJedis();
  175.         while (true) {
  176.             if (null != jedis) {
  177.                 break;
  178.             } else {
  179.                 jedis = getJedis();
  180.             }
  181.         }

[html] view plain copy

  1.        //PS:redis默认有一些key已经存在里面，不能删除，所以后面在添加key的时候用一个统一的标识符这样将自己添加的删除
  2.         Iterator it = jedis.keys("redis*").iterator();  //带*号清除所有，如果写有前缀就匹配出来sy*
  3.         while (it.hasNext()) {
  4.             String key = (String) it.next();
  5.             kit.delByCache(key);    //删除key
  6.             logger.info(new Date()+"：将redis缓存"+key+"值删除成功！");
  7.         }
  8.         returnResource(jedis);
  9.     }
  12.     /**自定义的一些 get set del 方法，方便使用  在其他地方直接调用**/
  13.     public JSONObject getByCache(String key) {
  14.         String result = safeGet(key);
  15.         if (result != null) {
  16.             return (JSONObject) JSONObject.parse(result);
  17.         }
  18.         return null;
  19.     }
  21.     public String getByCacheToString(String key) {
  22.         String result = safeGet(key);
  23.         if (result != null) {
  24.             return result;
  25.         }
  26.         return null;
  28.     }
  30.     public List<JSONObject> getArrayByCache(String key) {
  31.         String result = safeGet(key);
  32.         if (result != null) {
  33.             resultList = JSONArray.parseArray(result, JSONObject.class);
  34.             return resultList;
  35.         }
  36.         return null;
  37.     }
  39.     public JSONArray getJSONArrayByCache(String key) {
  40.         String result = safeGet(key);
  41.         if (result != null) {
  42.             return JSONArray.parseArray(result);
  43.         }
  44.         return null;
  45.     }
  47.     public void setByCache(String key, String s) {
  48.         safeSet(key, 86400, s);
  49.     }
  51.     public void setByCacheOneHour(String key, String s) {
  52.         safeSet(key, 3600, s);
  53.     }
  55.     public void setByCacheOneHour(String key, List<JSONObject> json) {
  56.         safeSet(key, 86400, JSONObject.toJSONString(json));
  57.         resultList = json;
  58.     }
  60.     public void setByCache(String key, JSONObject json) {
  61.         safeSet(key, 86400, JSONObject.toJSONString(json));
  62.     }
  64.     public void setByCache(String key, List<JSONObject> list) {
  65.         safeSet(key, 86400, JSONObject.toJSONString(list));
  66.         resultList = list;
  67.     }
  69.     public void setByCache(String key, JSONArray array) {
  70.         safeSet(key, 86400, JSONArray.toJSONString(array));
  71.     }
  73.     public void setByCacheCusTime(String key, String s, int time) {
  74.         safeSet(key, time, s);
  75.     }
  77.     public void delByCache(String key) {
  78.         //该方法删除指定的key
  79.         if (null != safeGet(key)) {
  80.             safeDel(key);
  81.         }
  82.     }
  84.     //该方法用来清除所有相关redis的key
  85.     public void delRedisRelevantKey(){
  86.         clearCache();
  87.     }
  89.     public JSONObject toJSON(JSONObject db) {
  90.         return (JSONObject) JSONObject.toJSON(db);
  91.     }
  93.     public List<JSONObject> toJSON(List<JSONObject> list) {
  94.         List<JSONObject> json = new ArrayList<>();
  95.         for (JSONObject aList : list) {
  96.             json.add((JSONObject) JSONObject.toJSON(aList));
  97.         }
  98.         return json;
  99.     }
  101.     public boolean notNull() {
  102.         return resultList != null && resultList.size() > 0;
  103.     }
  105.     public List<JSONObject> getResult() {
  106.         return resultList;
  107.     }
  109.     public static void main(String[] args) {
  110.         //clearCache();  到这里自己去测试一下是否可以
  111.     }
  113. }

之前看过其它大神的文章，都是将缓存地址放到application.properties、还有什么application.yml里面，但是我试过到我这里取不到地址，试过很多方式取不到所以才决定地址放到外面，我个人觉得影响应该不会很大。

里面也写了很多公共方法方便调用管理。如果这里测试没问题那就运用到业务流程存储数据。

RedisUtil.java

这个类用来写redis公共方法

[html] view plain copy

  1. package com.zcwl.redis;
  3. import java.util.ArrayList;
  4. import java.util.Date;
  5. import java.util.List;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  10. import com.zcwl.goods.dto.GoodsBrand;
  12. import net.sf.json.JSONObject;
  14. /**
  15.  * redis缓存公共方法
  16.  * @author Liangth
  17.  */
  19. public class RedisUtil {
  21.     private static Logger log = LoggerFactory.getLogger(RedisUtil.class);
  23.     //redisSyIndexBrand    命名分解  redis（用来清除缓存时候，查找） SY（代表首页比如商城：SC） 后面随机变化
  24.     private static final String index_Brand = "redisSyIndexBrand";      //首页推荐品牌
  26.     private static CacheKit kit = new CacheKit();
  28.     /**
  29.      * 首页推荐品牌
  30.      * start
  31.      */
  32.     //缓存数据
  33.     public void saveIndexBrand(List<GoodsBrand> goodsBrand){
  34.         try {
  35.             List<JSONObject> array = new ArrayList<JSONObject>();
  36.             for (int i = 0; i < goodsBrand.size(); i++) {
  37.                 JSONObject object = new JSONObject();
  38.                 object.put("id", goodsBrand.get(i).getId());
  39.                 object.put("brandName", goodsBrand.get(i).getBrandName());
  40.                 object.put("brandImg", goodsBrand.get(i).getBrandImg());
  41.                 if(goodsBrand.get(i).getCountryImgUrl()==null){
  42.                     object.put("countryImgUrl", "");
  43.                 }else{
  44.                     object.put("countryImgUrl", goodsBrand.get(i).getCountryImgUrl());
  45.                 }
  46.                 object.put("specialType", goodsBrand.get(i).getSpecialType());
  47.                 array.add(object);
  48.             }
  49.             kit.setByCache(index_Brand, array.toString());
  50.             log.info(new Date()+"：缓存数据首页推荐品牌成功。key："+index_Brand);
  51.         } catch (Exception e) {
  52.             log.error("数据缓存首页推荐品牌异常，请检查RedisUtil方法!。key："+index_Brand);
  53.         }
  54.     }
  56.     //读取缓存
  57.     public List<GoodsBrand> readIndexBrand(){
  58.         List<GoodsBrand> goodsBrand = new ArrayList<GoodsBrand>();
  59.         try {
  60.             List<com.alibaba.fastjson.JSONObject> list = kit.getArrayByCache(index_Brand);
  61.             for (int i = 0; i < list.size(); i++) {
  62.                 GoodsBrand brand = new GoodsBrand();
  63.                 brand.setId(Integer.parseInt(list.get(i).get("id").toString()));
  64.                 brand.setBrandName(list.get(i).get("brandName").toString());
  65.                 brand.setBrandImg(list.get(i).get("brandImg").toString());
  66.                 if(list.get(i).get("countryImgUrl").toString() != null){
  67.                     brand.setCountryImgUrl(list.get(i).get("countryImgUrl").toString());
  68.                 }else{
  69.                     brand.setCountryImgUrl("");
  70.                 }
  71.                 brand.setSpecialType(list.get(i).get("specialType").toString());
  72.                 goodsBrand.add(brand);
  73.             }
  74.             log.info(new Date()+"：读取缓存数据首页推荐品牌成功。key："+index_Brand);
  75.         } catch (Exception e) {
  76.             // TODO: handle exception
  77.             log.error("读取缓存首页推荐品牌异常，请检查RedisUtil方法!。key："+index_Brand);
  78.         }
  79.         return goodsBrand;
  80.     }
  82.     /**
  83.      * end
  84.      */
  86. }

注意：redis数据结构以key-value存储，所以将自己的数据结构转换成这种方式去存储，

3）：在控制器里面去调用上面接口

这里应该都看得懂，我就不解释啦。里面有打印那些提示，在控制台查看缓存功能是不是成功了！

4）清除缓存

我这里暂时没有做到数据库和redis数据的实时同步。

现在有两个方案可以更新：

（1）如果后台改动数据需要马上更新，那我们就可以在前台触发事件来调用后台清理缓存接口

（2）还有设置一个定时器调用接口，到某个时间段来同步数据

原文地址

 

你可能感兴趣的文章
HDU 4902 Nice boat(线段树)
查看>>
Codeforces Round #114 (Div. 1) E. Wizards and Bets 高斯消元
查看>>
怎样调通微信支付及微信发货通知接口（Js API）
查看>>
Android 属性动画（Property Animation） 全然解析 （下）
查看>>
推断汉字正則表達式更严谨方法！
查看>>
如何避免误删CleanMyMac语言文件
查看>>
Linux下免安装mysql
查看>>
快钱报错：javax.net.ssl.SSLProtocolException: handshake alert: unrecognized_name解决
查看>>
Hadoop集群WordCount运行详解（转）
查看>>
[转]SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
查看>>
一次性搞清楚equals和hashCode
查看>>
Android Studio IDE的 LogCat如何过滤指定应用的调试信息
查看>>
23个常用正则表达式(数值和字符串)
查看>>
struts2中struts.xml配置文件详解
查看>>
Javascript中的with用法
查看>>
GIS-008-ArcGIS JS API 全图
查看>>
js splice方法
查看>>
Linux--多网卡的7种Bond模式
查看>>
ADO 连接数据库，取到VT_DATE型日期转换成 int型
查看>>
C语言 · 寂寞的数
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2025-02-08 13:08:23   当前IP: 3.15.185.186   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我