aop详情介绍

lilang001

已于 2022-03-09 22:47:26 修改

阅读量190

点赞数

文章标签： java 开发语言

于 2022-03-09 22:46:46 首次发布

原文链接：https://harrylyj.blog.csdn.net/article/details/123040094#comments_20217634

版权

AOP知识

1.1 切入点表达式四种方法

1.1.1 bean表达式

根据bean的ID拦截指定的对象.

 @Pointcut("bean(userServiceImpl)") id为类名小写
    public void pointcut(){
  
    }

1.1.2 within表达式

说明: 按照类型匹配. 可以使用通配符*号
语法:

		1. @Pointcut("within(com.jt.service.UserServiceImpl)")
  			   只拦截UserServiceImpl的类
  		2.  @Pointcut("within(com.jt.service.*)")
  			   拦截com.jt.service下的一级的类.
  		3.  @Pointcut("within(com.jt.service..*)")
  				拦截com.jt.service下所有包下的所有类
  		4.  @Pointcut("within(com.*.service..*)")
  				拦截com.任意包.service下所有包下的所有类

说明: 上述的2种操作方法粒度较粗, 一般情况下不用

1.1.3 execution表达式

作用: 粒度比较细,可以按照方法参数进行匹配.

语法：@Pointcut(“execution(返回值类型包名.类名.方法名(参数列表))”)

语法:  @Pointcut("execution(返回值类型 包名.类名.方法名(参数列表))")
1. 按照类型方法匹配
@Pointcut("execution(* com.jt.service.UserServiceImpl.addUser())")
2. 要求返回值任意, com.jt.service包下的所有的子孙类中的任意方法的任意参数要求拦截.
@Pointcut("execution(* com.jt.service..*.*(..))")
3. 要求返回值任意, com.jt.service包下的所有的子孙类中的add开头的方法并且参数1个是int类型 进行拦截
@Pointcut("execution(* com.jt.service..*.add*(int))")

1.1.4 @annotation表达式

作用: 可以根据用户的自定义注解进行拦截

1.1.4.1 完成自定义注解Lyj

主要就是起到标记的作用。


@Retention(RetentionPolicy.RUNTIME) //注解运行期有效
@Target(ElementType.METHOD)         //注解标识 方法
public @interface Lyj {
    
}

1.1.4.2 标记注解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M3O7nrWx-1646837128311)(C:\Users\86131\Desktop\学习图库\自定义注解.png)]

  @Pointcut("@annotation(com.jt.annotation.Ll)")  //拦截指定自定义注解；
     public void pointCut(){

      }

1.2 关于通知的讲解

1.2.1 关于AOP 通知的用法

第一类:可以记录程序执行的各个过程. 为日志提供记录.

注意:只能记录,不能起到更改的作用;

@Before(“pointcut()”)
@AfterReturning(“pointcut()”)
@AfterThrowing(“pointcut()”)
@After(“pointcut()”)

第二类:

@around环绕通知

可以控制目标方法是否执行. 环绕通知可以控制业务流转的过程!!!

Joint Point

JointPoint是程序运行过程中可识别的点，这个点可以用来作为AOP切入点。JointPoint对象则包含了和切入相关的很多信息。比如切入点的对象，方法，属性等。我们可以通过反射的方式获取这些点的状态和信息，用于追踪tracing和记录logging应用信息。

Pointcut

pointcut 是一种程序结构和规则，它用于选取join point并收集这些point的上下文信息。
pointcut通常包含了一系列的Joint Point，我们可以通过pointcut来同时操作jointpoint。单从概念上，可以把Pointcut当做jointpoint的集合。

JointPoint和ProceedingJoinPoint区别

通过JpointPoint对象可以获取到下面信息

# 返回目标对象，即被代理的对象
Object getTarget();

# 返回切入点的参数
Object[] getArgs();

# 返回切入点的Signature
Signature getSignature();

# 返回切入的类型，比如method-call，field-get等等，感觉不重要 
 String getKind();

Proceedingjoinpoint 继承了 JoinPoint。是在JoinPoint的基础上暴露出 proceed 这个方法。proceed很重要，这个是aop代理链执行的方法。
环绕通知=前置+目标方法执行+后置通知，proceed方法就是用于启动目标方法执行的

暴露出这个方法，就能支持 aop:around 这种切面（而其他的几种切面只需要用到JoinPoint，，这也是环绕通知和前置、后置通知方法的一个最大区别。这跟切面类型有关）

例子:
\1. 权限的校验
\2. 缓存系统
\3. 异常的处理等

1.2.2 通知中常用API

需求:
\1. 获取当前的目标对象的类型.
\2. 获取当前的方法名称
\3. 获取当前传递的参数.

常见报错: ProceedingJoinPoint is only supported for around advice ProceedingJoinPoint 只能用到环绕通知中.

获取切入点所在目标对象

Object targetObj =joinPoint.getTarget();

# 可以发挥反射的功能获取关于类的任何信息，例如获取类名如下
  String className = joinPoint.getTarget().getClass().getName();

获取切入点方法的名字
getSignature());是获取到这样的信息 :修饰符+ 包名+类名+方法名

只获取方法名
String methodName = joinPoint.getSignature().getName()

获取方法的参数
- 这里返回的是切入点方法的参数列表
- ```
Object[] args = joinPoint.getArgs();
```

前置通知

JoinPoint 连接点
getSignature().getName() 获取目标方法类型
getName() 获取方法名
getArgs() 获取方法中的参数  
getSignature().getDeclaringTypeName() 获取类的名称

//1.前置通知: 在目标方法执行之前执行.
    @Before("pointcut()")
    public void before(JoinPoint joinPoint){//连接点:获取方法中的数据
        Class targetClass = joinPoint.getTarget().getClass();
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getSignature().getDeclaringTypeName();
        Object[] objs = joinPoint.getArgs();
        System.out.println("我是前置通知!!!!");
        System.out.println("类型:"+ targetClass);
            打印结果:class com.jt.service.UserServiceImpl
        System.out.println("方法名称:"+methodName);
        System.out.println("类的名称:"+className);
            打印结果  com.jt.service.UserServiceImpl
        System.out.println("方法中携带的参数:"+ Arrays.toString(objs));
    }

1.2.3 后置通知用法

需求: 记录一下用户目标方法的返回值
说明: 通过属性returning 获取方法的返回值,值无法更改

 //2.后置通知: 在目标方法执行之后执行
    // 通过returning = "result"属性,获取目标方法的返回值,当作参数传递给result
    @AfterReturning(value = "pointcut()",returning = "result")
    public void afterReturn(Object result){
        System.out.println("我是后置通知!!!!");
        System.out.println("用户的返回值为:"+result);
    }

1.2.4 异常通知用法

说明: 如果用户执行业务方法时,报错了,则可以使用异常通知记录日志.

//3.异常通知: 目标方法执行报错时,执行该通知
    @AfterThrowing(value = "pointcut()",throwing = "exception")
    public void afterThrowing(Exception exception){
        System.out.println("我是异常通知!!!!");
        System.out.println("获取异常信息:"+exception.getMessage());
        exception.printStackTrace();
    }

环绕

proceed() 如果有下一个通知，则执行通知方法，没有通知 执行目标方法
joinpoint中没有proceed()方法 所以需要使用joinpiont的子接口proceedjoinpoint
实现环绕通知的方法;


@Component
@Aspect
public class SpringAOP2 {
    @Around("@annotation(com.jt.annotation.Ll)") 切面表达式
      通知方法
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //如果有下一个通知，则执行通知方法，没有通知 执行目标方法
        System.out.println("环绕B开始");
        //proceed()只能在环绕通知内使用 执行目标方法或者通知方法
        Object proceed = joinPoint.proceed();
        System.out.println("环绕B结束");
        return proceed;
    }
}

1.3 切面排序

说明: 根据@Order注解实现切面的排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uA2aG014-1646837128313)(C:\Users\86131\Desktop\学习图库\切面排序.png)]


@Component  //将类交给spring容器管理
@Aspect     //标识切面类
@Order(1)   //AOP第一个执行  数字越小越靠前
public class SpringAOP2 {

    //通过环绕通知 指定切入点表达式.
    @Around("@annotation(com.jt.anno.Lyj)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.如果有下一个通知,则执行通知方法,没有通知,则执行目标方法
        System.out.println("执行环绕通知B开始");
        Object result = joinPoint.proceed();
        System.out.println("执行环绕通知B结束");
        return result;
    }
}

1.4 关于代理对象生成策略说明

默认策略:
1. Spring中默认采用的动态代理的规则是JDK代理,如果被代理者没有接口.则自动使用CGLIB

如果需要修改为cglib代理,则添加如下代码

@Configuration
@ComponentScan("com.jt") //包扫描
//开启AOP 默认JDK代理 (proxyTargetClass = true) 改为CGlib代理
@EnableAspectJAutoProxy(proxyTargetClass = true)  
public class SpringConfig {
}

SpringBoot中默认代理模式采用CGLIB代理.如果需要修改为JDK代理则需要修改配置文件即可

1.5 关于Spring总结

为什么学习spring框架让程序设计实现松耦合.
什么是面向接口编程以后对象中的属性一般写接口. java中多态的体现. 属性类型更加的灵活松耦合.
什么是IOC Ioc全称Inversion of Control，即“控制反转”，这是一种设计思想。对象创建的权利由Spring框架完成.由容器管理对象的生命周期.
Spring容器启动方式 1. xml方式 2.注解方式
什么时候使用工厂模式: 1.对象不能直接实例化的时候. 2.spring框架整合其它第三方框架时使用. FactoryBean
单例多例问题: 默认条件下是单例模式多例:@Scope(“prototype”)
懒加载规则: 1. 默认条件下懒加载无效添加注解@Lazy 有效. 只对单例模式有效.
spring生命周期管理 4个过程: 1.对象创建 2. 对象初始化 @PostConstruct 3. 业务调用 4.对象销毁 @PreDestroy
Spring中依赖注入的注解@Autowired 1.默认按照类型注入 2.可以按照名称注入 @Qualifier(“cat”) @Resource java中的注解.
10.MVC 设计思想 View 视图层 Model业务层 Control 控制层
根据MVC设计思想: 层级代码结构 Controller/Service/Mapper|Dao
@Value spring为属性动态赋值基本类型和String和集合(几乎不用)
动态代理 JDK动态代理/CGLib动态代理
AOP 面向切面编程在不改变源码的条件下对方法进行扩展.
AOP常见注解
1. @Aspect 标识切面
2. @Pointcut 标识切入点表达式 4种写法 2种常用
3. 五个通知注解
4. @EnableAspectJAutoProxy(proxyTargetClass = true) //开启AOP
5. 排序注解 @Order
  Model业务层 Control 控制层
根据MVC设计思想: 层级代码结构 Controller/Service/Mapper|Dao
@Value spring为属性动态赋值基本类型和String和集合(几乎不用)
动态代理 JDK动态代理/CGLib动态代理
AOP 面向切面编程在不改变源码的条件下对方法进行扩展.
AOP常见注解
1. @Aspect 标识切面
2. @Pointcut 标识切入点表达式 4种写法 2种常用
3. 五个通知注解
4. @EnableAspectJAutoProxy(proxyTargetClass = true) //开启AOP
5. 排序注解 @Order

lilang001

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
aop详情介绍

AOP知识1.1 切入点表达式四种方法1.1.1 bean表达式根据bean的ID拦截指定的对象. @Pointcut("bean(userServiceImpl)") id为类名小写 public void pointcut(){ }1.1.2 within表达式说明: 按照类型匹配. 可以使用通配符*号语法: 1. @Pointcut("within(com.jt.service.UserServiceImpl)") 只
复制链接

扫一扫