首页 / REDIS / AOP结合redis实现自动存取

AOP结合redis实现自动存取

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了AOP结合redis实现自动存取，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7570字，纯文字阅读大概需要11分钟。

内容图文

Redis自定义注解@RedisSimpleCache

注解的作用

在使用过程中，不需要进行Redis中是否有数据的判断，就如同正常的查询数据库一般，当内容在数据库中不存在的情况下，会执行代码，在得到结果之后，再将数据存储中Redis中

注解的实现

使用Aop的技术，在方法中执行前查询数据，发现数据没有存在于数据库中，执行方法后，将数据存储中Redis的

具体的实现步骤

AOP拦截注解过的方法后，先去校验中key是否存在，
存在的话，执行后续方法，判断方法返回的类型，来确定序列化以及反序列化的规则
将Redis的key组装起来
去redis中查询数据，判断数据有无
在没有数据的情况下，就执行方法，将数据得到后，将结果保存到redis中
在有数据的情况下，就直接返回Redis中数据即可。

具体实现

自定义注解

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

    /**
     * 过期时间 单位为秒
     * @return
     */
    int expire() default 86400;

    /**
     * redis 的key
     * @return
     */
    String redisKey() default "";

    /**
     * 在请求后是否刷新过期时间  true为刷新 false 为不刷新
     * @return
     */
    boolean reCalFlag() default false;
}

/**只用来标记Key*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface RedisParamKey {

}

AOP实现

@Aspect
@Slf4j
@Component
public class SimpleCacheAopAdvice extends RedisBaseService {

    public static final String BLAKE = ":";

    public Random random;
    
    @Pointcut(value = "@annotation(com.xixi.myredis.tool.annotation.RedisSimpleCache)")
    public void test(){

    }

    public SimpleCacheAopAdvice() {
        this.random = new Random();
    }

    /**
     * 需要注意的问题 为了防止缓存雪崩，在设置过期时间的时候，要添加一个随机时间
     * 为了防止 两个请求参数相同，都没有在redis中找到数据，同时去执行查询，
     * 在查询之后，需要再次判断是否存在缓存 存在就不将数据加入缓存中
     * 后续需要考虑为了防止缓存穿透的问题 要进行一个setnx的 互斥锁
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "test()")
    public Object invoke(ProceedingJoinPoint joinPoint) throws Throwable {
        //1. 先去校验注解 RedisKey 是否存在 是否只有一个
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        Method method = signature.getMethod();
        log.info("执行方法：{}",method.getName());
        List paramKey = getParamKey(method, joinPoint);
        if(paramKey.size()>1){
            log.error("{} 不支持多个RedisParamKey注解，将直接执行方法",method);
            return joinPoint.proceed();
        }
        RedisSimpleCache annotation = method.getAnnotation(RedisSimpleCache.class);
        int expire = annotation.expire();
        String redisKey = annotation.redisKey();
        boolean reCalFlag = annotation.reCalFlag();
        //2.得到返回类型 来确定 序列化的规则 对于 List 与Map 要进行特别的数据，
        Type genericReturnType = method.getGenericReturnType();
        boolean assignableFrom = genericReturnType.getClass().isAssignableFrom(Class.class);
        MyRedisSerializer myRedisSerializer = null;
        if(!assignableFrom){
            ResolvableType resolvableType = ResolvableType.forMethodReturnType(method);
            //可能为List 或者 map
            if(genericReturnType.getClass().isAssignableFrom(List.class)){
                Class<?> aClass = resolvableType.resolveGeneric(0);
                myRedisSerializer = new MyRedisSerializer(List.class);
                myRedisSerializer.setClassList(Lists.newArrayList(aClass));
            }else if(genericReturnType.getClass().isAssignableFrom(Map.class)){
                myRedisSerializer = new MyRedisSerializer(Map.class, CommonConstants.MAP);
                Class<?> keyClass = resolvableType.resolveGeneric(0);
                Class<?> valueClass = resolvableType.resolveGeneric(0);
                myRedisSerializer.setClassList(Lists.newArrayList(keyClass,valueClass));
            }else {
                myRedisSerializer = new MyRedisSerializer(resolvableType.resolve());

            }
        }else {
            String typeName = genericReturnType.getTypeName();
            myRedisSerializer = new MyRedisSerializer(Class.forName(typeName));
        }
        //3. 组装去redis 查询的key
        StringBuffer sb = new StringBuffer();
        sb.append(redisKey).append(BLAKE);
        if(!paramKey.isEmpty() && paramKey.get(0)!=null){
            sb.append(paramKey.get(0));
        }
        log.info("查询的key为 {}",sb.toString());

        try {
            return read(joinPoint,sb.toString(),expire+random.nextInt(1000),reCalFlag,myRedisSerializer);
        } catch (Exception e) {
            log.error("查询 key：{} ,出错了",sb.toString(),e.getMessage());
            return joinPoint.proceed();
        }

    }


    /**
     * 得到带有RedisParamKey 注解的参数
     * @param method
     * @param joinPoint
     * @return
     */
    private List getParamKey(Method method,ProceedingJoinPoint joinPoint) {
        List list = new ArrayList();
        Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        for (int i=0; i<parameterAnnotations.length;i++){
            for (int j =0;j< parameterAnnotations[i].length;j++){
                if(parameterAnnotations[i][j] instanceof RedisParamKey){
                    Object[] args = joinPoint.getArgs();
                    list.add(args[i]);
                }
            }
        }
        return list;
    }
}

 /**
     * 去redis中查询数据，没有数据的话，将结果查询出来，再放入到redis中。
     * @description:
     * @author: shengchengchao
     * @date 2021/3/24
     * @return
     */
    public Object read(ProceedingJoinPoint joinPoint, String key, int expire, boolean reCalFlag, MyRedisSerializer myRedisSerializer) throws Throwable {
        //先去redis中去查询
        //使用Pipeline可以批量执行redis命令，防止多个命令建立多个连接
        byte[] serialKey = RedisSerialUtils.serial(key);
        List redisResult = redisTemplate.executePipelined((RedisCallback) conn -> {
            byte[] bytes = conn.get(serialKey);
            return null;
        }, null);
        Random random =new Random();
        byte[] bytes = (byte[]) redisResult.get(0);
        //没有缓存
        if(bytes ==null ){
            log.info("没有找到缓存，执行方法");
            Object resultSave = getResultSave(joinPoint, serialKey, expire, reCalFlag, myRedisSerializer);
            log.info("已得到结果并存入redis中");
            return resultSave;
        }else if(bytes.length==1 && bytes[0] ==0 ){
            //缓存为null
            return null;
        }else {
            //有缓存 将数据反序列化
            try {
                Object result = deserializeResult(myRedisSerializer, bytes);
                if(reCalFlag){
                    redisTemplate.expire(serialKey,expire+random.nextInt(100), TimeUnit.SECONDS);
                }
                return result;
            } catch (Exception e) {
                log.error("从redis中反序列化出错",e);
                return joinPoint.proceed();
            }
        }
    }

    /**
     *  执行数据 并将结果保存到redis中
     * @param joinPoint
     * @param key
     * @param expire
     * @param reCalFlag
     * @param myRedisSerializer
     * @return
     */
    private Object getResultSave(ProceedingJoinPoint joinPoint, byte[] serialKey, int expire, boolean reCalFlag, MyRedisSerializer myRedisSerializer) {
        try {
            Object proceed = joinPoint.proceed();
            if(proceed  !=null){
                //再次查找redis 确定结果
                List redisResult = redisTemplate.executePipelined((RedisCallback) conn -> {
                    byte[] bytes = conn.get(serialKey);
                    return null;
                }, null);
                byte[] bytes = (byte[]) redisResult.get(0);
                //找到结果的话 进行反序列化
                if(bytes !=null){
                    Object deserialize = deserializeResult(myRedisSerializer,bytes);
                    return deserialize;
                }else {
                    //将数据存储到redis中
                    saveRedis(proceed,myRedisSerializer,serialKey,expire);
                }
            }
            return proceed;
        } catch (Throwable throwable) {
            log.error("出现错误",throwable.getMessage());
        }
        return null;
    }

    /**
     * 保存数据到redis
     * @param result
     * @param myRedisSerializer
     */
    private void saveRedis(Object result, MyRedisSerializer myRedisSerializer,byte[] serialKey,int expire) {
        if(result!=null){
            //判断数据的类型 是否为null
            byte[] serialize = myRedisSerializer.serialize(result);
            redisTemplate.executePipelined((RedisCallback)con->{
                con.set(serialKey,serialize);
                if(expire!=CommonConstants.permanent){
                    con.expire(serialKey,expire);
                }
                return null;
            });

        }
    }

    /**
     * 反序列化 数据
     * @param myRedisSerializer 自定义的序列化
     * @param bytes 结果
     * @return
     */
    private Object deserializeResult(MyRedisSerializer myRedisSerializer,byte[] bytes){
        if(CommonConstants.MAP.equals(myRedisSerializer.getTypeName())){
            List<Class> classList = myRedisSerializer.getClassList();
            return MyFastJsonUtil.json2Map(new String(bytes), classList.get(0),classList.get(1));
        }else {
            return myRedisSerializer.deserialize(bytes);
        }

    }

具体使用

只需要在方法中添加上两个注解就可以完成，将数据存储到Redis，再次访问后，将先去查询数据库中数据。

@Service
public class TestService {

    @RedisSimpleCache(redisKey = "test",expire = 100)
    public String test(@RedisParamKey String k1 ){
        System.out.println("进入查询");
        return "aaa";
    }
}

内容总结

以上是互联网集市为您收集整理的AOP结合redis实现自动存取全部内容，希望文章能够帮你解决AOP结合redis实现自动存取所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/860932.html

来源：【匿名】

【上一篇】Redis笔记【下一篇】redis可以做什么？

更多 ►

【AOP结合redis实现自动存取】教程文章相关的互联网学习教程文章

使用Redisson实现分布式锁，Spring AOP简化之【代码】【图】

源码Redisson概述Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object se...

Spring AOP + Redis缓存数据库查询【代码】

<aop:aspectj-autoproxy proxy-target-class="false" />然后定义两个标注在接口方法上的注解，用于传递类型参数：@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Documented public @interface RedisCache {Class type(); }@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface RedisEvict {Class type(); }注解的...

java学习day75-JT项目13(AOP实现redis缓存/Redis缓存)【代码】【图】

目录1.利用Redis缓存实现商品分类查询1.1 编辑ItemCatController1.2 编辑ItemCatService2.利用AOP实现redis缓存2.1 传统项目弊端2.2 AOP的核心理念2.3 切入点表达式2.4 通知方法2.5 AOP入门案例2.6 AOP实现缓存业务2.6.1 自定义注解@CacheFind2.6.2 使用自定义注解2.6.3 切换代码执行2.7 利用AOP实现缓存业务2.8 AOP缓存注解--商品列表->商品分类名称显示2.8.1 业务描述2.8.2 代码优化3. redis常见面试题3.1 缓存穿透3.2 缓存击穿3...

AOP结合redis实现自动存取【代码】

Redis自定义注解@RedisSimpleCache 注解的作用在使用过程中，不需要进行Redis中是否有数据的判断，就如同正常的查询数据库一般，当内容在数据库中不存在的情况下，会执行代码，在得到结果之后，再将数据存储中Redis中注解的实现使用Aop的技术，在方法中执行前查询数据，发现数据没有存在于数据库中，执行方法后，将数据存储中Redis的具体的实现步骤 AOP拦截注解过的方法后，先去校验中key是否存在，存在的话，执行后续方法，判...

Spring AOP + Redis 实现针对用户的接口访问频率限制【代码】

根据请求参数中的关键字段实现对单位时间内某特定用户的单接口访问频率限制。如果是请求头中携带 Token 稍微修改一下即可。频率注解： package com.seliote.fr.annotation;import java.lang.annotation.*; import java.util.concurrent.TimeUnit;/*** API 调用频率限制注解，配合切面使用* 要求注解的方法有且只能有一个参数** @author seliote*/ @Documented @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME...

基于Spring Aop + Redis实现分布式多维度前置后置限流【代码】

基于Spring Aop + Redis实现分布式多维度前置后置限流说明配置Maven依赖配置Redis定义限流注解创建Aop类使用说明在实际场景，比如发送短信验证码、刷评论是需要一定限流控制的，其中限流又可以分为前置限流，后置限流。所谓前置限流即为调用目标接口前校验，无论被调用的接口是否发生异常或者是否返回预期值；后置限流是调用接口后，可以根据指定的Condtion判断是否记录次数，Condtion支持EL表达式。本文通过Spring Aop + 自...

@interface [SpringMVC+redis]自定义aop注解实现控制器访问次数限制【代码】

我们需要根据IP去限制用户单位时间的访问次数，防止刷手机验证码,屏蔽注册机等，使用注解就非常灵活了 1 定义注解@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Documented//最高优先级 @Order(Ordered.HIGHEST_PRECEDENCE) public @interface RequestLimit {/*** * 允许访问的次数，默认值MAX_VALUE*/int count() default Integer.MAX_VALUE;/*** * 时间段，单位为毫秒，默认值一分钟*/long time() default ...

阿里巴巴蚂蚁金服2020金融核心部门实习面经（Redis+Memcache+TCP+IOC+AOP+【图】

一面（个人感觉回答得还不错） 1. 自我介绍2. 说项目，项目问的非常深（本人提到之前做过的一篇关于FULL GC的问题定位和优化的项目以及一个多并发的项目）2.1 对于自己产于过项目的系统定位是否清楚？2.2 对于系统的各个模块是否清楚？2.3 每个接口的tps？2.4 对于上下游系统的依赖？2.5 对于使用到的中间件、框架是否清楚？3. 你觉得你做的项目中最有亮点的事情？4. memcache redis同类中间的差异、优缺点？使用注意点有哪些？...

REDIS - 技术教程分类

Redis 教程 Redis 简介 Redis 安装 Redis 配置 Redis 数据类型 Redis 命令 Redis 键(key) Redis 字符串(String) Redis 哈希(Hash) Redis 列表(List) Redis 集合(Set) Redis 有序集合(sorted set) Redis HyperLogLog Redis 发布订阅 Redis 事务 Redis 脚本 Redis 连接 Redis 服务器 Redis GEO Redis Stream Redis 数据备份与恢复 Redis 安全 Redis 性能测试 Redis 客户端连接 Redis 分区 Redis 全部

REDIS - 最热教程

redis中批量删除key的方法 redis设置密码，取消密码 node.js利用redis数据库缓存数据 PHP swoole和redis异步任务实现方法分析 Laravel使用Redis共享Session步骤详解 mac下卸载干净redis 如何通过命令行修改redis的配置使用Port Forwarding连接k8s集群的pod（...Redis入门（七）——Redis发布订阅 Redis学习笔记2-常用数据类型

首页 / REDIS / AOP结合redis实现自动存取

AOP结合redis实现自动存取

内容导读

内容图文

Redis自定义注解@RedisSimpleCache

注解的作用

注解的实现

具体的实现步骤

具体实现

自定义注解

AOP实现

具体使用

内容总结

内容备注

内容手机端

【AOP结合redis实现自动存取】教程文章相关的互联网学习教程文章

使用Redisson实现分布式锁，Spring AOP简化之【代码】【图】

Spring AOP + Redis缓存数据库查询【代码】

java学习day75-JT项目13(AOP实现redis缓存/Redis缓存)【代码】【图】

AOP结合redis实现自动存取【代码】

Spring AOP + Redis 实现针对用户的接口访问频率限制【代码】

基于Spring Aop + Redis实现分布式多维度前置后置限流【代码】

@interface [SpringMVC+redis]自定义aop注解实现控制器访问次数限制【代码】

阿里巴巴蚂蚁金服2020金融核心部门实习面经（Redis+Memcache+TCP+IOC+AOP+【图】

REDIS - 相关标签

自动 - 相关标签

REDIS - 技术教程分类

REDIS - 最新教程

REDIS - 最热教程