RedisUtils工具类，设置缓存，然后需要在删除，更新插入的时候清空缓存，保持redis和mysql的数据一致

已于 2022-08-19 15:54:14 修改
阅读量637 收藏
点赞数 1
分类专栏： 中间件 文章标签： 缓存 mysql redis
于 2022-08-18 12:12:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/houzhicongone/article/details/126403229
版权

文章目录

1.查询的时候先查询缓存，如果为空就会以查询数据库，然后设置值到缓存

public List<ClmHospitalLccc> queryClmHospitalLccc() {
        List<ClmHospitalLccc> list;
        List<ClmHospitalLccc> lv01 = new ArrayList<>();
        List<ClmHospitalLccc> lv02 = new ArrayList<>();
        List<ClmHospitalLccc> lv03 = new ArrayList<>();
        int count = 0;

        RedisUtils redisUtils = RedisUtils.getInstance();
        if(redisUtils.get(CustomerConstants.QUERY_XILL_HOSPITAL_TREE) !=null){
            log.info("医院索引缓存数据:{}",(List<ClmHospitalLccc>) redisUtils.get(CustomerConstants.QUERY_XILL_HOSPITAL_TREE));
            return (List<ClmHospitalLccc>) redisUtils.get(CustomerConstants.REGION_CUSTOMER,CustomerConstants.QUERY_XILL_HOSPITAL_TREE);
        }
        //查询所有医院代码数据
        list = this.hospitalCodeUpholdMapper.initPageList();


        //按节点遍历
        for(ClmHospitalLccc clmHospitalLccc:list){
            if(clmHospitalLccc.getHscode() != null && !"".equals(clmHospitalLccc.getHscode())){
                if(clmHospitalLccc.getHscode().trim().length() == 2){
                    lv01.add(clmHospitalLccc);
                }
                if(clmHospitalLccc.getHscode().trim().length() == 4){
                    lv02.add(clmHospitalLccc);
                }
                if(clmHospitalLccc.getHscode().trim().length() == 6){
                    lv03.add(clmHospitalLccc);
                }
            }


        }
        for(ClmHospitalLccc clmHospitalLccc02:lv02){
            List children = new ArrayList();
            for(ClmHospitalLccc clmHospitalLccc03:lv03){
                if(clmHospitalLccc03.getHscode().substring(0,4).equals(clmHospitalLccc02.getHscode())){
                    Map<String, Object> map = new HashMap();
                    map.put("hscode", clmHospitalLccc03.getHscode());
                    map.put("hsname", clmHospitalLccc03.getHsname());
                    map.put("children", clmHospitalLccc03.getChildren());
                    children.add(map);
                }
            }
            if (children.size() > 0) {
                clmHospitalLccc02.setChildren(children);
            }
        }


        for(ClmHospitalLccc clmHospitalLccc01:lv01){
            List children = new ArrayList();
            for(ClmHospitalLccc clmHospitalLccc02:lv02){
                if(clmHospitalLccc02.getHscode().substring(0,2).equals(clmHospitalLccc01.getHscode())){
                    Map<String, Object> map = new HashMap();
                    map.put("hscode", clmHospitalLccc02.getHscode());
                    map.put("hsname", clmHospitalLccc02.getHsname());
                    map.put("children", clmHospitalLccc02.getChildren());
                    children.add(map);
                }
            }
            if (children.size() > 0) {
                clmHospitalLccc01.setChildren(children);
            }
        }
        log.info("医院索引查询-数据缓存处理前:{}",System.currentTimeMillis());
        redisUtils.set(CustomerConstants.REGION_CUSTOMER, CustomerConstants.QUERY_XILL_HOSPITAL_TREE, lv01,30*24*3600);
        log.info("医院索引查询-数据缓存处理后:{}",System.currentTimeMillis());
        return lv01;
    }

2.在进行修改(insert,delete,update)操作的时候进行 删除缓存（这样就会下次查询的时候缓存为空，又会重新设置缓存）

3.缓存工具类

package com.sunline.framework.redis.utils;

import java.io.Serializable;
import java.util.Date;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.support.atomic.RedisAtomicLong;
import org.springframework.util.StringUtils;

import com.sunline.framework.redis.constants.CttRedis.Region;

import lombok.extern.slf4j.Slf4j;

 
/**
 * 
 * ClassName: RedisUtils <br/>
 * Function: TODO redis cache 工具类. <br/>
 * Reason: TODO ADD REASON(可选). <br/>
 * date: 2019年10月17日 下午2:40:29 <br/>
 *
 */
@Slf4j
public class RedisUtils   { 

	public static final String regionDefault = Region.REDIS_OBJ;

	private static RedisUtils redisUtils;

	private RedisTemplate<Serializable, Object> redisTemplate;


	public void setRedisTemplate(RedisTemplate<Serializable, Object> redisTemplate) {
		this.redisTemplate = redisTemplate;
	}

	public static RedisUtils getInstance() {
		if (null == redisUtils) {
			synchronized (RedisUtils.class) {
				if (null == redisUtils) {
					log.info("缓存实例为空，初始化开始...");
					redisUtils = new RedisUtils();
					log.info("缓存实例为空，初始化完成...");
				}
			}
		}
		return redisUtils;
	}
 

	/**
	 * 设置缓存（永不过期）
	 * @param region 缓存块名称（注意命名规范）
	 * @param key 缓存key
	 * @param value 缓存值 
	 */
	public Object get(String region, String key) {
		try {
			String factKey = this.getKeyName(region, key);
			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
			return operations.get(factKey);
		} catch (Exception e) {
			log.error("根据region[{}],key[{}]获取缓存时异常!", region, key);
			e.printStackTrace();
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
		return null;
	}
 
	public Object get(String key) {
		return this.get(this.regionDefault, key);
	}
 

	/**
	 * 设置缓存（永不过期）
	 * @param region 缓存块名称（注意命名规范）
	 * @param key 缓存key
	 * @param value 缓存值 
	 */
	public void set(String region, String key, Object value) {
		try {
			if (!StringUtils.isEmpty(key)) {
				String factKey = this.getKeyName(region, key);
				ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
				operations.set(factKey, value);
			}
		} catch (Exception e) {
			log.error("根据region[{}],key[{}]存储缓存时异常!", region, key);
			e.printStackTrace();
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
	}

	/**
	 * 设置缓存
	 * @param region 缓存块名称（注意命名规范）
	 * @param key 缓存key
	 * @param value 缓存值
	 * @param expireTime 到期时间（单位：秒）
	 */
	public void set(String region, String key, Object value, int expireTime) {
		try {
			if (!StringUtils.isEmpty(key)) {
				String factKey = this.getKeyName(region, key);
				ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
				operations.set(factKey, value);
				redisTemplate.expire(factKey, expireTime, TimeUnit.SECONDS);
			}
		} catch (Exception e) {
			log.error("根据region[{}],key[{}]存储缓存时异常!", region, key);
			e.printStackTrace();
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
	}

	/**
	 * 设置缓存 （使用默认块）
	 * @param key 缓存key
	 * @param value 缓存值 
	 */
	public void set(String key, Object value) {
		this.set(regionDefault, key, value);
	}

	/**
	 * 设置缓存
	 * @param region 缓存块名称（注意命名规范）
	 * @param key 缓存key
	 * @param value 缓存值
	 * @param expireTime 到期时间（单位：秒）
	 */
	public void set(String key, Object value, int expireTime) {
		try {
			String factKey = this.getKeyName(regionDefault, key);
			ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
			operations.set(factKey, value);
			redisTemplate.expire(factKey, expireTime, TimeUnit.SECONDS);
		} catch (Exception e) {
			log.error("根据key[{}],expireTime[{}]存储缓存时异常!", key, expireTime);
			e.printStackTrace();
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
	}
 
	/**
	 * 获取全部keys信息
	 * @param pattern
	 * @return
	 */
	public Set<Serializable> keys(String pattern) {
		try {
			return redisTemplate.keys(pattern);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
	}

	/**
	 * 删除缓存
	 * @param region 缓存块
	 * @param key 键
	 */
	public void remove(String region, String key) {
		try {
			String factKey = this.getKeyName(region, key);
			if (exists(factKey)) {
				redisTemplate.delete(factKey);
			}
		} catch (Exception e) {
			log.error("根据region[{}],key[{}]清理缓存时异常!", region, key);
			e.printStackTrace();
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
	} 
	
	/**
	 * 根据默认块+key删除缓存
	 * @param key
	 */
	public void remove(String key) {
		try {
			String factKey = this.getKeyName(this.regionDefault, key);
			if (exists(factKey)) {
				redisTemplate.delete(factKey);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
	}
 
	private boolean exists(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
		return false;
	}
	
	/**
	 * 根据前缀key模糊匹配清理缓存对象信息
	 * @param prefix
	 */
	public void clearAllStartingWith(String prefix) {
		try {
			Set<Serializable> setData = this.keys(prefix);
			if (null != setData) {
				redisTemplate.delete(setData);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
		}
	}
 

	/**
	 * 生成缓存的 key
	 * @param region
	 * @param key
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	protected String getKeyName(String region, Object key) {
		if (StringUtils.isEmpty(region)) {
			region = regionDefault;
		}
		if (key instanceof Number) {
			return region + ":I:" + key;
		} else {
			Class keyClass = key.getClass();
			if (String.class.equals(keyClass) || StringBuffer.class.equals(keyClass)
					|| StringBuilder.class.equals(keyClass)) {
				return region + ":S:" + key;
			}
		}
		return region + ":O:" + key;
	}
	

	public long generate( ) {
		RedisAtomicLong redisAtomicLong = new RedisAtomicLong(new Date().toString(), redisTemplate.getConnectionFactory());
		return redisAtomicLong.incrementAndGet();
	}
	public long generate(String key) {
		
		RedisAtomicLong redisAtomicLong = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
		return redisAtomicLong.incrementAndGet();
	}

	public long generate(String key,Date expireTime) {
		RedisAtomicLong redisAtomicLong = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
		redisAtomicLong.expireAt(expireTime);
		return redisAtomicLong.incrementAndGet();
	}

	public long generate(String key,int increment) {
		RedisAtomicLong redisAtomicLong = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
		return redisAtomicLong.addAndGet(increment);
	}
	public long generate(String key,int increment,Date expireTime) {
		RedisAtomicLong redisAtomicLong = new RedisAtomicLong(key, redisTemplate.getConnectionFactory());
		redisAtomicLong.expireAt(expireTime);
		return redisAtomicLong.addAndGet(increment);
	}

    /**
     * 
    * getRedisTemplate:(获取缓存模板). <br/>
    * TODO(这里描述这个方法的注意事项 – 可选).<br/>
    *
    * @since 2020-08-17
     */
    public RedisTemplate<Serializable, Object> getRedisTemplate() {
        return redisTemplate;
    }
	/**
	 * 向集合中添加元素，返回是否添加成功，1成功  0 失败
	 * @param region
	 * @param key
	 * @param value
	 * @return
	 */
	public  Long setValueToSet(String region, String key, String value) {
		String factKey = this.getKeyName(region, key);
		return redisTemplate.opsForSet().add(factKey,value);
	}

	/**
	 * 将元素从集合中移除,移除成功，返回1 ，否则0
	 */
	public Long removeFromSet(String region, String key, String value){
		String factKey = this.getKeyName(region, key);
		return redisTemplate.opsForSet().remove(factKey,value);
	}
	public Set<Object> getSet(String region, String key){
		String factKey = this.getKeyName(region,key);
		return redisTemplate.opsForSet().members(factKey);
	}
}
有时间指导毕业设计
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
redis 数据缓存工具类及使用示例
yiXin_Chen的博客
01-16 875
package cn.itrip.util; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.ValueOperations; import org.springframework.stereotype.Component; .
Redis清理缓存
qq_40024617的博客
11-10 241
在liunx下对redis进行清除缓存需要进行以下操作： 1：访问redis的安装目录 cd /JavaUtil/Redis-x64-3.2.100 2：进入src目录 cd ./redis-cli 3：当执行redis-cli 命令时，可能会出现连接失败的问题（如果没有出现第3步的情况则直接跳到第五步） could notconnect to redis at 127.0.0.1:6379 connection refused 4：当出现这种情况时，可以执行以下命令（127.0.0.1 可根据自己实
RedisUtils 操作五大集合 增删改查
最新发布
ehehhahs的博客
05-02 31
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！ /**批量删除key@param pattern*/public void removePattern(final String pattern) {Set keys = redisTemplate.keys(pattern);if (keys.size() > 0)redisTemplate.delete(keys);}/**删除对应的value@param key*/public void remove
【11/19-12/02（第七次）学习总结】
qq_45190838的博客
11-21 229
【11/19-11/25（第七次）学习总结】
一起学习Spring boot 2.1.X | 第二十篇：Redis
qq_41920732的博客
05-22 554
Windows： 下载地址：Redis Redis 支持 32 位和 64 位。这个需要根据你系统平台的实际情况选择，这里我们下载Redis-x64-xxx.zip压缩包到 C 盘，解压后，将文件夹重新命名为 Redis。 1.pom.xml <!-- Redis --> <dependency> <groupId>org.spring...
RedisUtil.java
09-25
采用了spring 的RedisTemplate，实现了用redis存入值，取出值，删除值，可直接使用
Python定时从Mysql提取数据存入Redis的实现
09-08
在本文中，我们将深入探讨如何使用Python实现一个定时任务，该任务从MySQL数据库中提取数据并将其存储到Redis缓存中。这个过程涉及到两个主要组件：`FromSql` 类用于从MySQL获取数据，`RedisQueue` 类用于处理Redis...
double-cache:双重缓存，通过guava-cache和redis实现本地缓存+服务器缓存的双重缓存
05-23
double-cache查询mysql数据库时，同样的输入需要不止一次获取值或者一个查询需要做大量运算时，很容易会想到使用redis缓存。但是如果查询并发量特别大的话，请求redis服务也会特别耗时，这种场景下，将redis迁移到...
springboot整合redis、mybatis以及redis和mybatis的联合使用
09-17
springboot集成redis、mybatis 1、集成redis 2、集成mybatis 3、自定义redis KEY生成器/CacheManager来管理redis... 方式一：redis原生方法工具类（RedisService）+redis+mybatis 方式二：CacheManager+redis+mybatis
Redis学习手册.docx
09-05
Redis 是一款高性能的键值对（Key-Value）数据库，常用于数据缓存、消息队列、实时数据存储等场景。其易用性和丰富的数据结构是其主要优势，包括字符串（String）、列表（List）、哈希（Hash）、集合（Set）和有序...
一个功能完备的个人博客系统, redis缓存记录可恢复未完成的博客 可以自己使用或者学习
02-24
一个功能完备的个人博客系统, redis缓存记录可恢复未完成的博客。可以自己使用或者学习 后端框架是SpringBoot、Mybatis，前端框架是VUE，数据库使用MySQL，缓存中间件Redis等技术 博客系统分为前台展示页面、...
RedisUtils.java
09-03
redis封装类----用于简化redis的操作，实现快速使用redis的作用
Redis的工具类(RedisUtil)，内含多种往redis中存放的方法
ccyy
05-13 626
内含多种往redis中存放的方法 指定数据失效时间 指定过期日期 删除数据 取数据 import java.util.Date; import javax.annotation.Resource; import org.springframework.dao.DataAccessException; import org.springframework.data.redis.connection.RedisConnection; import org.springframework.data.redis
RedisUtil
三年学说话，一生学闭嘴
11-25 559
redisUtil
redisutil
白_的博客
07-17 420
package com.lsh.product.config.redis; import lombok.extern.slf4j.Slf4j; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.spr.
【redis】redis实用Utils
九师兄
07-04 1125
package com.roadshow.uds.redis; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; @Component public class RedisConnection { @Value(value ...
RedisUtil工具类
qq_36816062的博客
01-11 439
RedisUtil工具类 简单写了一个RedisUtil工具类，供大家参考 package com.ssm.service; import com.alibaba.fastjson.JSON; import com.ssm.entity.LoanInfo; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; impor
mysql/redis等6大数据库,在7种java业务中的选型与调优
09-05
对于mysql/redis等6大数据库，在7种java业务中的选型与调优可以从以下角度来考虑： 1. 事务型业务：对于需要保证ACID（原子性、一致性、隔离性和持久性）特性的业务，如支付系统或订单系统，适合选择MySQL这类关系型数据库。可以通过使用InnoDB引擎来提供事务支持，并进行合理的索引设计与数据表分区来提高性能。 2. 缓存型业务：对于频繁读取的数据，如热门商品、热门文章等，可以选择使用Redis等内存数据库作为缓存，提高读取速度。可以使用Redis提供的Hash类型或Sorted Set等数据结构来存储和操作数据。 3. 日志型业务：对于需要记录用户操作日志或系统日志的业务，可以选择使用MySQL数据库。可以使用数据库的分区表或者分库分表技术来分散写入压力，使用数据库索引来提高查询效率。 4. 大数据量存储：对于需要处理大量数据的业务，如用户行为数据分析或日志分析等，可以选择使用Hadoop等大数据处理平台，将数据存储在分布式文件系统中，如HDFS，再通过Hive或HBase等工具进行查询和分析。 5. 高并发读写：对于需要处理高并发读写请求的业务，如社交网络或在线视频等，可以考虑使用分布式数据库，如TiDB或Cassandra等，以支持水平扩展和负载均衡，提高系统的并发能力。 6. 实时计算：对于需要实时计算的业务，如推荐系统或风控系统，可以选择使用流式处理框架，如Flink或Spark Streaming等，结合类似Kafka等高吞吐量消息队列，对数据进行实时处理和计算。 在选型和调优时，需要根据具体业务需求和系统性能要求来选择合适的数据库，并进行合理的设计和配置。同时，还需要进行性能测试和监控，根据实际情况进行优化，如合理调整数据库参数、优化SQL查询语句、缓存数据等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

有时间指导毕业设计

觉得写的好的话可以给我打赏

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值