SSM+自定义注解+AOP完成定制Redis缓存结构

最新推荐文章于 2022-11-02 18:30:02 发布
最新推荐文章于 2022-11-02 18:30:02 发布
阅读量311 收藏
点赞数 1
文章标签： Redis 自定义注解 缓存 SSM AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43041241/article/details/89345139
版权

上一篇博客说到虽然使用Spring注解来指定缓存非常方便，但是想要进行非常详细、系统的设计缓存数据结构，仅仅使用自带注解还是完全不够的。
https://blog.csdn.net/weixin_43041241/article/details/89338076
本博客就是之前的博客进行的拓展：使用自定义注解+AOP完成定制Redis缓存结构。
·---------------------------------------------------------------------------------------------
首先，介绍一个数据结构：
NewsDetail是一条新闻，每条新闻都有新闻评论NewsComment。下面正式开始：

一、自定义注解：
1、@RedisSelect用来标记需要缓存查询

package com.cod4man.fakenews.annotation.redis;

import java.lang.annotation.*;

/**
 * Created with IntelliJ IDEA.
 *
 * @author 张鸿杰
 * Date：2019-04-17
 * Time:9:58
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface RedisSelect {
    String group() ;
    String key() ;
    String returnType() default "Object";
    boolean isCollection() default false;
    String comment() default "";
}

2、@RedisDelete 用来标注需要缓存删除

package com.cod4man.fakenews.annotation.redis;

import java.lang.annotation.*;

/**
 * Created with IntelliJ IDEA.
 *
 * @author 张鸿杰
 * Date：2019-04-17
 * Time:10:03
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface RedisDelete {
    String group() ;
    String key() ;
    String returnType() default "Object";
    boolean isCollection() default false;
    String comment() default "";
}

二、使用AOP设计缓存：
jar依赖：

      <dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
          <version>2.7.3</version>
      </dependency>

Redis提供的java操作工具Jedis

    <bean id="jedis" class="redis.clients.jedis.Jedis">
        <constructor-arg name="host" value="127.0.0.1"/>
        <constructor-arg name="port" value="6379"/>
    </bean>

package com.cod4man.fakenews.redisaop;

import com.alibaba.fastjson.JSON;
import com.cod4man.fakenews.annotation.redis.RedisDelete;
import com.cod4man.fakenews.annotation.redis.RedisSelect;
import com.cod4man.fakenews.pojo.NewsComment;
import com.cod4man.fakenews.pojo.NewsDetail;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;

import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * Created with IntelliJ IDEA.
 *
 * @author 张鸿杰
 * Date：2019-04-16
 * Time:20:39
 */
@Aspect
public class FindAllNewsDetailAop {
    private static final Logger log = Logger.getLogger(FindAllNewsDetailAop.class);
    //Redis提供的java操作工具
    @Autowired
    private Jedis jedis ;
    
    //AOP拦截RedisSelect注解，查询缓存操作
    @Around("@annotation(com.cod4man.fakenews.annotation.redis.RedisSelect)")
    public Object aroundLogger_SetAll(ProceedingJoinPoint jp) throws Throwable {
        log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName() + "方法！方法参数为" + Arrays.toString(jp.getArgs()));
        try {
            //拿到方法
            Method method= getMethod(jp);
            //拿到注解的group属性值
            String redisKey = method.getAnnotation(RedisSelect.class).group();
            //判断是新闻还是评论，这里是将新闻列表和评论列表集合到同一个AOP方法进行处理
            if ("CommentsByNewsId".equals(redisKey)) {
                //Redis的键拼上评论id
                redisKey += jp.getArgs()[0].toString();
            }
            //AOP拦截到查询后先不查主数据库，而是先从Redis缓存中查找
            Map<String, String> mapNews =  jedis.hgetAll(redisKey);
            if (mapNews != null && !"{}".equals(mapNews.toString())) {
                List<Object> list = new ArrayList<>();
                for (String value : mapNews.values()) {
                    list.add(JSON.parse(value));
                }
                //缓存中有数据，则进行数据处理后，直接return结束方法，那么就不会再查询主数据库，从而减轻压力
                return list;
            }
            //如果查询不到，说明是第一次查询，就需要查询数据库
            //使用反射拿到返回值类型
            Type returnType = method.getGenericReturnType();
            Object result = jp.proceed();
            System.out.println("returnType" + returnType.toString());
            //将查询到的数据按一定数据结构存入Redis缓存
            if ("java.util.List<com.cod4man.fakenews.pojo.NewsDetail>".equals(returnType.toString())) {
                List<NewsDetail> list = (List<NewsDetail>) result;
                for (NewsDetail newsDetail : list) {
                    //存入数据格式：大Key==》NewsDetail；
                    // 小Key ==》新闻id(可以保证唯一)NewsDetail.getId();
                    // Value==》新闻详情NewsDetail
                    jedis.hset(redisKey, newsDetail.getId().toString(), JSON.toJSONString(newsDetail));
                }
            } else if ("java.util.List<com.cod4man.fakenews.pojo.NewsComment>".equals(returnType.toString())) {
                List<NewsComment> list = (List<NewsComment>) result;
                for (NewsComment newsComment : list) {
                    //存入数据格式：大Key==》NewsComment+(新闻编号NewsDetail.getId())；
                    // 小Key ==》新闻评论id(可以保证唯一)NewsComment.getId();
                    // Value==》评论详情NewsComment
                    jedis.hset(redisKey, newsComment.getId().toString(), JSON.toJSONString(newsComment));
                }
            }
            log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName()
                    + "方法！方法参数为" + Arrays.toString(jp.getArgs()) + "。方法的返回值为:" + result);
            return result;
        }  catch (Throwable throwable) {
            log.error(jp.getSignature().getName() + "方法发生了异常，" + throwable);
            throwable.printStackTrace();
            throw throwable;
        } finally {
            log.info(jp.getSignature().getName() + "方法执行结束！");
        }
    }
    
    //拦截@RedisDelete，删除缓存操作
    @Around("@annotation(com.cod4man.fakenews.annotation.redis.RedisDelete)")
    public Object around_DeleteById(ProceedingJoinPoint jp) throws Throwable {
        log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName() + "方法！方法参数为" + Arrays.toString(jp.getArgs()));
        try {
            Method method = getMethod(jp);
            // 获取注解对象
            RedisDelete redisDelete = method.getAnnotation(RedisDelete.class);
            //获取注解的group属性
            String redisKey = redisDelete.group();
            boolean mark = true;
            //该删除也是集成了评论删除和新闻删除，如果是评论删除，则拼接上新闻的id来组成大Key
            if ("CommentsByNewsId".equals(redisKey)) {
                redisKey += jp.getArgs()[0].toString();
            }
            //查询Redis中是否有缓存
            Map<String, String> mapNews =  jedis.hgetAll(redisKey);
            //直接查缓存
            if ( mapNews == null || "{}".equals(mapNews.toString())) {
                if (!"CommentsByNewsId".equals(redisKey)) {
                    //判断缓存中是否有该键，没有说明数据也没有，就无需访问数据库了
                    mark = mapNews.containsKey(jp.getArgs()[0].toString());
                }
                if (mark) {
                    System.out.println("缓存中没有key");
                    //缓存中没有该Key，直接return，
                    return -1;
                }
            }
            //否则，缓存中有该Key即数据库有数据，需要删除
            Object result = jp.proceed();
            if (!redisKey.contains("CommentsByNewsId")) {
                //删除缓存
                jedis.hdel(redisKey, jp.getArgs()[0].toString());
            } else {
                System.out.println("评论Id" + redisKey);
                System.out.println("是否删除评论：" + jedis.del(redisKey));
            }
            log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName()
                    + "方法！方法参数为" + Arrays.toString(jp.getArgs()) + "。方法的返回值为:" + result);
            //删除数据库
            return result;
        }  catch (Throwable throwable) {
            log.error(jp.getSignature().getName() + "方法发生了异常，" + throwable);
            throwable.printStackTrace();
            throw throwable;
        } finally {
            log.info(jp.getSignature().getName() + "方法执行结束！");
        }
    }
    //同理可以写增加、修改数据的AOP
    /**
     * 获取被注释方法
     * @Title: getMethod
     * @Description: 获取被拦截方法对象
     * @param joinPoint
     * @return
     */
    protected Method getMethod(JoinPoint joinPoint) throws Exception {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        Method realMethod = joinPoint.getTarget().getClass().getDeclaredMethod(methodSignature.getName(), method.getParameterTypes());
        return realMethod;
    }
}

三、测试：
1、新闻详情业务处理NewsDetailServiceImpl.java

	@Override	
    @RedisSelect(group = "NewsDetail", key = "", comment = "查询全部")
    public List<NewsDetail> findAllNews(int startPage, int pageSize) {
        System.out.println("查询全部");
        return newsDetailMapper.findAllNews((startPage-1)*pageSize,pageSize);
    }
    @Override
    @RedisDelete(group = "NewsDetail", key = "")
    public int deleteNewsById(long newsId) {
        if (newsDetailMapper.deleteNewsById(newsId) >0) {
            return newsCommentService.deleteCommentByNewsId(newsId);
        }
        return -1;
    }

2、新闻评论业务处理NewsCommentServiceImpl.java

    @Override
    @RedisDelete(group = "CommentsByNewsId", key = "")
    public int deleteCommentByNewsId(long newsId) {
        return newsCommentMapper.deleteCommentByNewsId(newsId);
    }

    @Override
    @RedisSelect(group = "CommentsByNewsId", key = "")
    public List<NewsComment> findCommentsByNewsId(long newsId) {
        System.out.println("查看什么");
        return newsCommentMapper.findCommentsByNewsId(newsId);
    }

3、运行结果：新闻以及评论按AOP中所设计的数据结构进行存储，这样在更新操作的时候，就可以指定更新数据内部的一行小数据，虽然更新操作也是需要更新主数据库，但是查询操作就不必再查询数据库了，只需要查询Redis缓存。
在这里插入图片描述有什么不妥的欢迎大家指正！需要源码的可以留言联系我。

那么代价是什么呢
关注
Redis+自定义注解+AOP实现缓存
weixin_45417573的博客
12-13 652
Redis+自定义注解+AOP实现缓存 闲着没事研究aop实现查询缓存，闷头敲代码，敲出了以下东西，希望看到的大神指正！ 一、自定义注解 通过自定义注解，在修饰的方法上添加该注解，在aop中切入，为该方法添加缓存到redis中 package com.wwy.annotation; import java.lang.annotation.ElementType; import java.lang...
Spring AOP结合Redis利用自定义注解实现通用缓存
Orangesss_的博客
09-09 1999
Spring AOP结合Redis利用自定义注解实现通用缓存 1.目的 1. 缓存: 减少与数据库的交互, 提升查询性能; 2. 降低代码的侵入性 3. 提高代码的复用性 2.业务逻辑 1. 去缓存查询; 2. 如果缓存中没有数据, 则代表缓存穿透, 则去数据库查询, 再将数据存入缓存; 3. 如果缓存中有数据, 则直接返回; 3.技术点 1. spring A...
ssm+redis 如何更简洁的利用自定义注解+AOP实现redis缓存
weixin_33759269的博客
10-23 149
基于 ssm + maven + redis 使用自定义注解 利用aop基于AspectJ方式 实现redis缓存 　　如何能更简洁的利用aop实现redis缓存，话不多说，上demo 　　需求： 　　　　数据查询时每次都需要从数据库查询数据，数据库压力很大，查询速度慢， 　　　　因此设置缓存层，查询数据时先从redis中查询，如果查询不到，则到数据库中查询 　　　　然后将数据库中查询的数据...
AOP+自定义注解，实现redis缓存
qq_40267044的博客
08-12 204
添加如下依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.springframew
redis结合ssm框架中的使用，以AOP原理做一个redis缓存管理
dengdaip的博客
06-16 930
本来想模仿声明式事物管理写一个声明式缓存管理出来的，但是最后发现自己对xml文件里面的标签一无所知，没有像事务管理一样提供类似的缓存管理标签，自己也不会写，故退而求其次，再以AOP原理写了一个切面缓存后，对dao层了一次封装，事物层调用的实际是自己封装类，再由自己的封装类去调用dao层的方法，在调用dao层方法前判断redis库里是否存在缓存，若存在，则从缓存里取出数据，若不存在，则调用方法从数据
ssm+mysql+Redis实现简易的高并发模拟
06-26
SSM是Spring、Spring MVC和MyBatis的缩写，这是一种流行的Java Web开发框架组合，而MySQL是常用的开源关系型数据库，Redis则是一种高性能的键值对内存数据库，常用于缓存和高速数据访问。 首先，**Spring框架** 是...
SSM+shiro+redis
04-13
5. 缓存策略：设计合理的缓存策略，比如使用Redis缓存Shiro的权限信息，提高系统性能。 以上内容概述了SSM+Shiro+Redis技术栈的主要组件及其作用。在实际开发中，还需要深入理解各个框架的原理，灵活运用，以适应...
ssm+redis 实现session共享
03-18
SSM是指Spring、Spring MVC和MyBatis这三大Java Web开发框架的组合，而Redis则是一种高性能的键值存储数据库，常被用于缓存和分布式数据共享。 首先，让我们深入理解一下SSM框架。Spring是一个全面的后端应用程序...
maven+ssm+redis增删改查小demo
05-16
在现代Java Web开发中，SSM（Spring、Spring MVC、MyBatis）框架组合与Redis缓存系统的集成应用非常广泛。本项目“maven+ssm+redis增删改查小demo”提供了一个基本的示例，展示了如何在SSM基础上利用Redis进行数据的...
自定义SpringAop+Reids注解实现缓存存储
就是这么菜
01-07 893
SpringAop      Spring作为沉淀了许久的框架，在开发上带给的便利性不言而喻，主要是IOC+AOP关于这这两者的介绍请自行百度。看了AOP的实现：XML实现和注解实现，个人比较倾向于注解实现，不用写过多的配置比较方便。      Redis一种缓存技术提供了丰富的数据结构，下面就利用SpringAop+Redis实现热数据查询时首先在Redis中查询，不存在时再去数据库中查...
spring aop 做redis缓存
热门推荐
cai_chinasoft的专栏
06-15 1万+
spring aop 做redis缓存
aop切面和redis实现自定义缓存注解
zhangxiaomin1992的专栏
10-20 2780
自定义缓存注解
AOP+自定义注解+Redis实现分布式缓存
最新发布
小学生波波
11-02 1480
AOP+自定义注解+Redis实现分布式缓存
AOP+Redis实现缓存
weixin_44188129的博客
03-16 951
今天早上用AOP+redis实现缓存，记录一下 配置文件：spring配置文件：记得开启注解 &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.sprin...
SSM---Spring aop 自定义注解做redis缓存
guokezhongdeyuzhou的博客
06-25 643
实际开发中我们不需要统一的去加 缓存处理，只需要 部分功能去加缓存处理，而且还是在 后期的开发中需要添加，在此提供一个 利用spring aop做切点 去加入缓存处理。只需要在需要加入缓存的地方 以注解的方式添加即可1.SpringRedis 配置文件spring-redis.xml   &lt;beans xmlns="http://www.springframework.org/schema/...
使用自定义注解+AOP实现存放HASH类型的Redis缓存
叁金Coder
03-26 373
使用自定义注解+AOP实现存放HASH类型的Redis缓存1.自定义的Redis方法2.自定义注解3.自定义Aspect 1.自定义的Redis方法 /** * @description 获取返回值 * @param key - 键 不能为null * @param hashKey - 项 不能为null * @return Object - ...
AOP+自定义注解实现redis缓存自动更新
weixin_44689397的博客
03-13 2538
前台数据查询时，缓存注解还是使用原来的@Cacheable，然后仿照这个注解增加个自定义注解，也能传入key，value的值，这样的话可以拼接出需要自动更新的缓存的key值，然后直接清除这个缓存，利用aop切面对标注了这个注解的类中所有方法中的增删改操作都会去清除缓存，该注解适合直接加在后台控制类上
SSM 整合redis，使用AOP实现缓存过滤器
默默不代表沉默
08-05 771
前段时间写了一篇SSM三大框架的整合教程， https://blog.csdn.net/qq_35387940/article/details/97911104 今天就顺便在这个基础上继续整合下redis吧。 第一步，加入相关依赖包，pom.xml： <!--redis--> <dependency> ...
JSP音乐网站设计与实现：SSM+MySQL源码解析
9. **缓存机制**：为了提高性能，可能引入缓存技术（如Spring Cache或Redis），缓存热门音乐列表、用户信息等，减少数据库访问压力。 10. **安全性考虑**：网站需要考虑数据安全，如防止SQL注入、XSS攻击，以及保护...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值