通过注解方式实现Spring AOP整合Redis缓存

最新推荐文章于 2023-10-15 17:07:56 发布
最新推荐文章于 2023-10-15 17:07:56 发布
阅读量403 收藏 1
点赞数
分类专栏： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiJiVV/article/details/95496605
版权

 

1、实现自定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TsingRedisCache {

}

2、创建切面配置类

/**
 * @ClassName : AopConfig
 * @Description: 横切面配置
 * 		@Configuration 声明配置类
 * 		@ComponentScan("com.tsingsoft.common.*") 扫描包
 * 		@EnableAspectJAutoProxy //开启 Spring 对 AspectJ 的支持
 * @author : 
 * @Company :
 * @date 2019年7月11日 下午1:41:22
 */
@Configuration
@ComponentScan("com.tsingsoft.common.*")
@EnableAspectJAutoProxy
public class AspectConfig {

}

3、创建Redis缓存配置及执行器类文件

  • 创建spring-data-redis 和 jedis整合xml的配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
	
    <!-- 配置JedisPoolConfig实例 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大连接数 -->
		<property name="maxTotal" value="30" />
		<!-- 最大空闲连接数 -->
		<property name="maxIdle" value="10" />
		<!-- 每次释放连接的最大数目 -->
		<property name="numTestsPerEvictionRun" value="1024" />
		<!-- 释放连接的扫描间隔（毫秒） -->
		<property name="timeBetweenEvictionRunsMillis" value="30000" />
		<!-- 连接最小空闲时间 -->
		<property name="minEvictableIdleTimeMillis" value="1800000" />
		<!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
		<property name="softMinEvictableIdleTimeMillis" value="10000" />
		<!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
		<property name="maxWaitMillis" value="1500" />
		<!-- 在获取连接的时候检查有效性, 默认false -->
		<property name="testOnBorrow" value="true" />
		<!-- 在空闲时检查有效性, 默认false -->
		<property name="testWhileIdle" value="true" />
		<!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
		<property name="blockWhenExhausted" value="false" />
    </bean>
    
    <!-- 配置JedisConnectionFactory -->
    <bean id="jedisConnectionFactory"
          class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" 
          p:usePool="true" 
          p:poolConfig-ref="poolConfig" 
          p:hostName="192.168.0.46" 
          p:port="6379" 
          p:timeout="200" 
          p:password="123456" />
	
    <!-- 配置RedisTemplate -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
          p:connection-factory-ref="jedisConnectionFactory" >
        <!--以下针对各种数据进行序列化方式的选择-->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
    </bean>
    <!-- cache配置 -->	
    <bean id="redisCacheExecutor" class="com.tsingsoft.common.redis.RedisCacheExecutor">
        <property name="redisTemplate" ref="redisTemplate"/>
    </bean>
    
</beans>
  • 说明一下，这个基于spring-data-redis中RedisTemplate实现的常用方法。
@Component
public class RedisCacheExecutor {
    private Logger logger = LoggerFactory.getLogger(RedisCacheExecutor.class);
    
    /**
     * sping-data-redis提供的Redis模板
     */
    @Resource
    private RedisTemplate<Serializable, Object> redisTemplate;
    
    /**
     * @Description: set方式注入
     * @author 李继伟
     * @param redisTemplate
     * @date 2019年7月11日 上午11:12:29
     */
    public void setRedisTemplate(RedisTemplate<Serializable, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

	/**
	 * @Description: 批量删除对应的value
	 * @author 李继伟
	 * @param keys
	 * @date 2019年7月11日 下午3:17:27
	 */
    public void del(final String... keys) {
        for (String key : keys) {
        	del(key);
        }
    }
    /**
     * @Description: 批量删除对应的value
     * @author 李继伟
     * @param keys
     * @date 2019年7月11日 下午3:17:27
     */
    public void del(final List<String> keys) {
    	for (String key : keys) {
    		del(key);
    	}
    }

	/**
	 * @Description: 通过模糊查询的方式查找所有key，然后批量删除key。
	 *               Redis模糊查询的通配符是"*"
	 *               可以是："*","key*","*key","*key*"
	 *               192.168.0.46:6379> keys *
	 *               1) "aba"
	 *               2) "abc"
	 *               192.168.0.46:6379> keys a*
	 *               1) "aba"
	 *               2) "abc"
	 *               192.168.0.46:6379> keys *c
	 *               1) "abc"
	 *               192.168.0.46:6379> keys *b*
	 *               1) "aba"
	 *               2) "abc"
	 * @author 李继伟
	 * @param pattern
	 * @date 2019年7月11日 下午3:15:43
	 */
    public void delByPattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void del(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * @Description: 写入缓存
     * @author 李继伟
     * @param key
     * @param value
     * @return
     * @date 2019年7月11日 下午3:11:52
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            logger.error("Redis缓存异常，set方法出错：", e);
        }
        return result;
    }

    /**
     * @Description: 写入缓存，带失效时间
     * @author 李继伟
     * @param key 
     * @param value
     * @param expireTime 失效时间
     * @return
     * @date 2019年7月11日 下午3:11:25
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            logger.error("Redis缓存异常，set方法出错：", e);
        }
        return result;
    }

}

4、创建Redis缓存横切面

@Aspect
@Component
public class RedisCacheAspect {

	private Logger log = Logger.getLogger(RedisCacheAspect.class);
	
	@Autowired
	private RedisCacheExecutor redisCacheExecutor;
	
	@Autowired
	private ConfigProperties configProperties;
	
	private Long defaultCacheExpireTime; // 缓存默认的过期时间
	
	/**
	 * @Description: 创建《查询操作》切点。
	 *               对所有以select/find/get/query/search/init/append/load开头的方法，
	 *               	并且同时使用@TsingRedisCache注解的方法进行横切
	 * @author 
	 * @date 2019年7月11日 下午1:18:39
	 */
	@Pointcut(value="((execution(* com.tsingsoft.**.service.*.select*(..))) "
			+ "|| (execution(* com.tsingsoft.**.service.*.find*(..))) "
			+ "|| (execution(* com.tsingsoft.**.service.*.query*(..))) "
			+ "|| (execution(* com.tsingsoft.**.service.*.search*(..))) "
			+ "|| (execution(* com.tsingsoft.**.service.*.init*(..))) "
			+ "|| (execution(* com.tsingsoft.**.service.*.append*(..))) "
			+ "|| (execution(* com.tsingsoft.**.service.*.load*(..))) "
			+ "|| (execution(* com.tsingsoft.**.service.*.get*(..)))) "
			+ "&& @annotation(com.tsingsoft.common.annotation.TsingRedisCache)")
    public void selectPointCut(){};
    
    
    /**
     * @Description: 创建《修改操作》切点。
     *               对所有以insert/update/delete/modify/save/change/edit/remove/repair/del开头的方法，
     *               	并且同时使用@TsingRedisCache注解的方法进行横切
     * @author 
     * @date 2019年7月11日 下午1:18:39
     */
    @Pointcut(value="((execution(* com.tsingsoft.**.service.*.insert*(..))) "
    		+ "|| (execution(* com.tsingsoft.**.service.*.update*(..))) "
    		+ "|| (execution(* com.tsingsoft.**.service.*.delete*(..))) "
    		+ "|| (execution(* com.tsingsoft.**.service.*.modify*(..))) "
    		+ "|| (execution(* com.tsingsoft.**.service.*.save*(..))) "
    		+ "|| (execution(* com.tsingsoft.**.service.*.edit*(..))) "
    		+ "|| (execution(* com.tsingsoft.**.service.*.remove*(..))) "
    		+ "|| (execution(* com.tsingsoft.**.service.*.repair*(..))) "
    		+ "|| (execution(* com.tsingsoft.**.service.*.del*(..)))) "
    		+ "&& @annotation(com.tsingsoft.common.annotation.TsingRedisCache)")
    public void modifyPointCut(){};
	
	/**
	 * @Description: 《查询操作》切点操作。
	 *               存在缓存，则返回缓存值。
	 *               不存在，则从DB中获取，并放入缓存，然后返回
	 *               必须采用环绕通知方式，注意必须要有ProceedingJoinPoint参数传入。
	 * @author 
	 * @param joinPoint
	 * @date 2019年7月11日 下午2:27:31
	 */
    @Around(value="selectPointCut()")
    public Object aroundSelectPointCut(ProceedingJoinPoint joinPoint){
    	if(!configProperties.isOpenRedisCache()){
    		try {
				return joinPoint.proceed();
			}
			catch (Throwable e) {
				log.debug(e);
			}
    	}
    	//全限类名(指向父类,如果使用自动生成包的mapper方法,会指向tk包下的Mapper类)
		String clazzName = joinPoint.getSignature().getDeclaringTypeName();
		clazzName = clazzName.substring(clazzName.lastIndexOf(".")+1);
		//方法名
		String methodName = joinPoint.getSignature().getName();
		//参数
		Object[] args = joinPoint.getArgs();
		//生成KEY
		String key = generateCacheKey(clazzName, methodName, args);
		//检查是否有缓存，存在，则取出返回
        if (redisCacheExecutor.exists(key)) {
            return redisCacheExecutor.get(key);
        }
        //不存在，则正常执行相关方法，从数据库中查询数据
        Object obj = null;
        try {
			obj = joinPoint.proceed();
		}
		catch (Throwable e) {
			log.debug(e);
		}
        defaultCacheExpireTime = configProperties.defaultCacheExpireTime();
        if (obj != null) {
            final String tempKey = key;
            final Object tempValue = obj;
            new Thread(new Runnable() {
                @Override
                public void run() {
                	redisCacheExecutor.set(tempKey, tempValue, defaultCacheExpireTime);
                }
            }).start();
        }
        return obj;
    }
    
    /**
     * @Description: 在《修改操作》切点方法执行结束后，清空所有缓存
     * @author 
     * @date 2019年7月11日 下午2:58:16
     */
    @After(value="modifyPointCut()")
    public void afterModifyPointCut() {
    	if(configProperties.isOpenRedisCache()){
    		try {
        		redisCacheExecutor.delByPattern("*");
    		}
    		catch (Throwable e) {
    			log.debug(e);
    		}
    	}
	}
    
    /**
     * @Description: 创建缓存key，通过传入参数转大写，用"_"分隔
     * @author 
     * @param targetName
	 *            service实现类名称
	 * @param methodName
	 *            service实现类中方法名称
	 * @param arguments
	 *            service实现类中方法参数集合
     * @return
     * @date 2019年7月11日 下午2:33:10
     */
    private String generateCacheKey(String targetName, String methodName, Object[] arguments) {
        StringBuffer keySb = new StringBuffer();
        keySb.append(targetName.toUpperCase());
        keySb.append("_");
        keySb.append(methodName.toUpperCase());
        if ((arguments != null) && (arguments.length != 0)) {
            for (int i = 0; i < arguments.length; i++) {
            	Object arg = arguments[i];
            	if(arg instanceof String){
            		keySb.append("_").append(arg.toString().toUpperCase());
            	}else if(arg instanceof Integer){
            		keySb.append("_").append(arg.toString().toUpperCase());
            	}else if(arg instanceof Double){
            		keySb.append("_").append(arg.toString().toUpperCase());
            	}else if(arg instanceof Float){
            		keySb.append("_").append(arg.toString().toUpperCase());
            	}else if(arg instanceof Boolean){
            		keySb.append("_").append(arg.toString().toUpperCase());
            	}else if(arg instanceof Long){
            		keySb.append("_").append(arg.toString().toUpperCase());
            	}else if(arg instanceof Byte){
            		keySb.append("_").append(arg.toString().toUpperCase());
            	}else if(arg instanceof Short){
            		keySb.append("_").append(arg.toString().toUpperCase());
            	}
            }
        }
        return keySb.toString();
    }
}

ConfigProperties 是我对properties中，常量配置进行同一管理的类。

到此，整个配置完成。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Spring AOP加注解实现redis缓存
Soda_lw的博客
06-28 954
今天来做一个通过注解的形式实现redis缓存 在我们平时的redis的使用中经常会有一种写法，就是先查redis，如果redis中没有，再查数据库。 String key = KEY + "showButton"; if (redisClient.hasKey(key)) { String str = redisClient.get(key, String...
注解方式实现Spring AOP 整合Redis 缓存(亲测可用!!!)
qq_36857572的博客
07-23 3893
注解方式实现Spring AOP 整合Redis 缓存 Spring AOP整合Redis缓存的思路: 将页面频繁访问,且改动较少的数据放入redis缓存,减少后台数据访问时间,再结合前台缓存技术(cookie,storage),能实现页面加速呈现的效果. 请求进入接口之后,查询数据时先查询缓存,缓存有则直接返回缓存中数据,缓存无则查询数据库,将数据库返回数据存入缓存并返回. 在数据mod...
spring与redis集成之aop整合方案
热门推荐
冷雨夜@leon
11-13 2万+
先下载好依赖包
SpringBoot集成Redis实现缓存处理(Spring AOP技术)
weixin_34080571的博客
06-13 424
第一章 需求分析 计划在Team的开源项目里加入Redis实现缓存处理，因为业务功能已经实现了一部分，通过写Redis工具类，然后引用，改动量较大，而且不可以实现解耦合，所以想到了Spring框架的AOP(面向切面编程)。 欢迎star(收藏) 第二章 SpringBoot简介 Spring框架作为JavaEE框架领域的一款重要的开源框架，在企业应用开发中有着很重要的作用，同时Spring框架及...
AOP+自定义注解，实现redis缓存
qq_40267044的博客
08-12 217
添加如下依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.springframew
spring aop结合redis实现数据缓存
一只蜗牛的博客
08-17 712
我们项目开发过程中，在实现功能的情况之下对其进行优化是必不可少的，其中一种优化方案就是做数据缓存，对数据做缓存可以减少对数据库的访问压力，在访问量逐步增大的情况下可以分流一部分数据库的压力，对客户端而言，最直观的变化就是请求响应时间变短。 我在设想之初就想通过aop+Redis的形式来实现数据缓存，参阅借鉴了很多资料，结合自身项目需求做了这个设计。 一.设计两个注解 p...
Spring AOP如何整合redis（注解方式）实现缓存统一管理详解
08-27
Spring AOP如何整合redis（注解方式）实现缓存统一管理详解 Spring AOP是Spring框架中的一种面向方面编程（AOP）的实现，它可以将横切关注点（Cross-Cutting Concerns）与业务逻辑进行分离，从而实现更加灵活和模块...
Spring AOP整合Redis注解实现缓存管理详解
"本文将详细介绍如何利用Spring AOP和注解方式整合Redis，实现缓存的统一管理。我们将探讨在项目中遇到的问题，如不同模块间因共享同一Redis集群而导致的键冲突，以及解决方案。文章将通过具体的步骤和示例代码来...
Spring AOP整合Redis实现高效数据库缓存
"本文主要探讨了如何利用Spring AOP实现Redis缓存来优化数据库查询，旨在提高系统的性能和效率。文中提到了缓存的关键问题，包括如何避免脏读、生成查询的唯一标识以及序列化查询结果。" 在现代Web应用程序中，...
浅谈SpringBoot集成Redis实现缓存处理(Spring AOP实现)
08-28
四、Redis缓存实现 在SpringBoot项目中，需要添加Redis依赖项，并配置application.yml文件，添加Redis配置。然后，在业务逻辑中，使用Spring AOP实现缓存处理。通过使用@Cacheable注解，可以将 метод缓存到...
spring整合redis做缓存用注解实现的完整例子
11-26
spring整合redis做缓存用注解实现的完整例子,带jar包，可以直接运行
Spring与Mybatis基于注解整合Redis的方法
09-01
主要介绍了Spring与Mybatis基于注解整合Redis的方法,本文通过实例给大家介绍的非常详细，具有参考借鉴价值，需要的朋友可以参考下
使用AOP 实现Redis缓存注解，支持SPEL(转)
MassiveStars的博客
01-20 2549
源文链接：http://www.cnblogs.com/DajiangDev/p/3770894.html 原来想自己实现一个，看到网上有一个和自己思路一样的实现，经试验，完美运行，感谢原作者的分享精神。 1.applicationContext.xml，配置JedisPool
SpringAop应用二之Aop实现Redis缓存(自定义注解实现切入)
海角12138的博客
08-13 576
一.首先实现自定义注解@AutowireRedis，实现该注解的方法会自动实现切面 package com.haijiao12138.demo.spring.util; import java.lang.annotation.*; /** * @author haijiao12138 * @date 2021/8/12 20:57 * @description */ @Documented @Retention(RetentionPolicy.RUNTIME) @Target(Element
AOP+自定义注解+Redis实现分布式缓存(经典)
最新发布
gb4215287的博客
10-15 547
AOP+自定义注解+Redis实现分布式缓存
利用spring的AOP来实现Redis缓存
m0_38084895的博客
09-29 663
利用spring的AOP来实现Redis缓存为什么使用Redis这里是Redis 的相关配置配置AOP自定义注解测试你们可以自己写一个完整的测试类或者在项目中添加即可（我主要是贴上它的使用），我用的spring的jar是4.2以上，jedis的jar是2.0以上 为什么使用Redis 数据查询时每次都需要从数据库查询数据，数据库压力很大，查询速度慢，因此设置缓存层，查询数据时先从redis中查询，...
SpringBoot工程中Redis与Aop技术的整合
weixin_49143405的博客
12-13 715
SpringBoot工程中Redis与Aop技术的整合 业务描述 基于AOP与Redis技术实现mysql,redis数据库中数据操作. 项目准备工作 第一步:打开sca-template工程,添加访问MySql数据库的依赖(两个) <!--mysql依赖--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java&...
基于注解和Aop实现redis缓存
qq_42012638的博客
04-14 237
1.自定义注解 @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Documented public @interface RedisCache { //自定义key值（本文中未使用） String prefix() default ""; //设置缓存时间 int expire() default 1; //缓存时间类型 TimeUnit TIME_UNIT() default Tim
Redis缓存切面
weixin_38935483的博客
09-24 1505
@Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD}) public @interface Cache { //缓存多少秒,默认无限期 public int expire() default 0; } package ***; import com.alibaba.fastjson.JSON; *** imp...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值