关于java:AOP实现Redis缓存

名称: 面向切面编程
作用: 升高零碎中代码的耦合性, 并且在不扭转原有代码的条件下对原有的办法进行性能的扩大.
公式: AOP = 切入点表达式 + 告诉办法

1.前置告诉指标办法执行之前执行
2. 后置告诉指标办法执行之后执行
3. 异样告诉指标办法执行过程中抛出异样时执行
4. 最终告诉无论什么时候都要执行的告诉

特点: 上述的四大告诉类型不能干涉指标办法是否执行.个别用来做程序运行状态的记录.【监控】

5.盘绕告诉在指标办法执行前后都要执行的告诉办法该办法能够控制目标办法是否运行.joinPoint.proceed(); 性能作为弱小的.

切入点表达式就是一个程序是否进入告诉的一个判断 (IF)。
作用：当程序运行过程中，满足了切入点表达式时才回去执行告诉办法，实现业务的扩大。
品种（写法）：
1.bean(bean 的名称 bean 的 ID) 只能拦挡具体的某个 bean 对象，只能匹配一个对象。
例如：bean(“itemServiceImpl”)
2.within(包名. 类名) within(“com.jt.service.*”)示意能够匹配多个对象。
3.execution(返回值类型包名. 类名. 办法名 (参数列表)) 最为弱小的用法
例如 : execution( com.jt.service...*(..))返回值类型任意 com.jt.service 包下的所有的类的所有的办法都会被拦挡.
4.@annotation(包名. 注解名称) 依照注解匹配.

package com.jt.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect // 我是一个 AOP 切面类
@Component  // 将类交给 spring 容器治理
public class CacheAOP {
    // 公式：切入点表达式 + 告诉办法

    /**
     * 对于切入点表达式的应用阐明
     *  粗粒度
     *      1.bean（bean 的 id）一个类
     *      2.within（包名. 类名）多个类
     *  细粒度
     *      1.
     */
    //@Pointcut("bean(itemCatSercviceImpl)")
    //   .* 示意以后包上面的一级目录。//   ..* 示意以后包上面的多级目录
    /*@Pointcut("within(com.jt.service..*)")
    public void pointCut(){// 定义切入点表达式，为了占位}*/

    // 定义前置告诉，与切入点进行绑定 @Before("pointCut()")
    // 或者用更简略的办法：不必定义切入点办法 pointCut()，// 间接绑定 bean：@before（“bean（itemCatSercviceImpl）”）/* 两者的区别：*       1.@Before("pointCut()")示意切入点表达式的援用，实用于多个告诉同用切入点的状况
    *       2.@before（“bean（itemCatSercviceImpl）”）实用于单个告诉，不须要复用的
    * */
    /**@Before("pointCut()")
    public void before(){System.out.println("我是前置告诉");
    }
    @AfterReturning("pointCut()")
    public void afterreturn(){System.out.println("我是后置告诉");
    }*/
    @Before("pointCut()")
    public void before(JoinPoint joinPoint){
        //JoinPoint：连接点办法

        //getStaticPart()代表连接点的办法签名
        //getName()办法的名称
        String methodName = joinPoint.getSignature().getName();
        //getDeclaringTypeName()获取类的门路全名 com.jt.service.ItemCatSercviceImpl
        String className = joinPoint.getSignature().getDeclaringTypeName();
        System.out.println(className+"."+methodName);
        //getTarget()代表指标对象
        //getTarget().getClass()获取指标对象的类型
        Class<?> targetClass = joinPoint.getTarget().getClass();
        // 获取对象的参数
        Object[] args = joinPoint.getArgs();
        // 获取执行工夫
        Long startTime= System.currentTimeMillis();

        System.out.println("指标办法类型"+targetClass);
        System.out.println("执行工夫："+startTime+"毫秒");
    }

    /**
     * 盘绕告诉阐明
     *  注意事项：*      ProceedingJoinPoint 只能用在盘绕告诉里
     *      1. 盘绕告诉必须增加参数 ProceedingJoinPoint
     *      2.ProceedingJoinPoint 只能盘绕告诉应用
     *      3.ProceedingJoinPoint 如果当做参数则必须位于参数的第一位
     */
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint){System.out.println("盘绕告诉开始！！！");
        Object result=null;
        try {result=joinPoint.proceed();// 执行下一个告诉或者指标办法
        } catch (Throwable throwable) {throwable.printStackTrace();
        }
        System.out.println("盘绕告诉完结！！！");

        return result;
    }

}

问题：如何管制，哪些办法须要应用缓存？【cacheFind（）查询方法】
解决方案：采纳自定义注解的模式进行定义，如果办法执行须要应用缓存，则标识注解即可。
对于注解的阐明：
1. 注解名称：cacheFind
2. 属性参数：

1.key: 应该由用户本人手动增加，个别增加业务名称之后动静拼接造成惟一的 key。2.seconds：用户能够指定数据的超时工夫。

// 自定义一个注解
@Target(ElementType.METHOD)// 该注解只对办法无效
@Retention(RetentionPolicy.RUNTIME)// 运行期无效
public @interface CacheFind {String preKey();// 用户标识 key 的前缀。int seconds() default 0;// 如果用户不写示意不须要超时，如果写了就以用户为准。}

package com.jt.aop;
import com.jt.anno.CacheFind;
import com.jt.util.ObjectMapperUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import java.util.Arrays;
@Aspect // 我是一个 AOP 切面类
@Component // 将类交给 spring 容器治理
public class CacheAOP {
    @Autowired
 private Jedis jedis;
    /**     AOP 实现 Redis 缓存
 * 切面 = 切入点 + 告诉办法
 * 注解相干 + 盘绕告诉        控制目标办法是否执行
 *
 * 难点：*      1. 获取注解的对象, 将注解作为参数传过来
 *      2. 动静生成 key  prekey+ 用户参数数组
 *      3. 如何获取办法的返回值类型
 */
 @Around("@annotation(cacheFind)")
    public Object around(ProceedingJoinPoint joinPoint,CacheFind cacheFind){System.out.println("注解拦挡失效");
        Object result=null;
        try {
            // 拼接 redis 存储数据的 key
 Object[] args=joinPoint.getArgs();
            String key=cacheFind.preKey()+"::"+ Arrays.toString(args);
            // 查问 redis 之后判断是否有数据
 if(jedis.exists(key)){
                // 示意 redis 中有数据，无需执行指标办法
 String json = jedis.get(key);
                // 动静获取办法的返回值类型  向上转型  向下转型
 MethodSignature methodSignature=(MethodSignature)joinPoint
 .getSignature();
                // 示意客户端传来什么类型就返回什么类型
 Class returnType = methodSignature.getReturnType();
                // 须要将 json 串转化为对象
 result=ObjectMapperUtil.toObj(json, returnType);
                System.out.println("redis 缓存中的数据");
            }else{
                // 示意数据不存在，须要在数据库中查问
 result=joinPoint.proceed();// 执行指标办法和告诉
 // 将查问的数据存储到 redis 缓存中
 String json = ObjectMapperUtil.toJson(result);
                // 判断是否须要超时工夫
 if(cacheFind.seconds()>0){jedis.setex(key, cacheFind.seconds(), json);
                }else{jedis.set(key, json);
                }
                System.out.println("aop 执行指标办法查询数据库");
            }
        } catch (Throwable throwable) {throwable.printStackTrace();
        }
        return result;
    }
}

关于java:AOP实现Redis缓存

AOP 简略介绍

告诉类型

切入点表达式

AOP 入门案例

对于 AOP 实现 Redis

自定义缓存注解

编辑 CacheAOP