15AOP从 @Aspect 到 Advisor

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量775 收藏 10
点赞数 25
分类专栏： spring 文章标签： java 开发语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48254383/article/details/139975877
版权

两种切面的实现

package com.butch.a17;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultIntroductionAdvisor;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

public class A17 {


    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("aspect1",Aspect1.class);
        context.registerBean("config",config.class);
        //加后置处理器
        context.registerBean(ConfigurationClassPostProcessor.class);
        context.refresh();
        for (String beanDefinitionName : context.getBeanDefinitionNames()) {
            System.out.println("beanDefinitionName = " + beanDefinitionName);
        }

    }

    static class Targer1{
        public void foo(){
            System.out.println("target1 foo");
        }
    }
    static class Targer2{
        public void bar(){
            System.out.println("target2 bar");
        }
    }


    //aspect切面
    @Aspect
    static class Aspect1{

        @Before("execution(* foo())")
        public void before(){
            System.out.println("aspect1 before.....");
        }

        @After("execution(* foo())")
        public void after(){
            System.out.println("aspect1 after.....");
        }

    }

    //advisor切面
    @Configuration
    static class config{

        @Bean
        public Advisor advisor3(MethodInterceptor advice3){
            AspectJExpressionPointcut aspectJExpressionPointcut = new AspectJExpressionPointcut();
            aspectJExpressionPointcut.setExpression("execution(* foo())");
            //第一个参数是切点 第二个参数是通知
            return new DefaultPointcutAdvisor(aspectJExpressionPointcut,advice3);
        }

        @Bean
        public MethodInterceptor advice3(){
            return new MethodInterceptor() {
                @Override
                public Object invoke(MethodInvocation methodInvocation) throws Throwable {
                    System.out.println("advisor3 before.....");
                    Object proceed = methodInvocation.proceed();
                    System.out.println("advisor3 after.....");
                    return proceed;
                }
            };
        }

    }

}

代理创建器实现原理

AnnotationAwareAspectJAutoProxyCreator

这是一个bean后置处理器，即为AOP的实现原理

  1. 发现切面对象

  2. 高级切面转低级切面，创建代理

findEligibleAdvisors

  • 有【资格】的 Advisor 一部分是低级的, 可以由自己编写, 如本例 A17 中的 advisor3

  • 有【资格】的 Advisor 另一部分是高级的, 由解析 @Aspect 后获得

wrapIfNecessary

  • 是否有必要创建的代理，它内部调用 findEligibleAdvisors, 只要返回集合不空, 则表示需要创建代理

  • 它的调用时机通常在原始对象初始化后执行, 但碰到循环依赖会提前至依赖注入之前执行

总结

  1. 在容器中寻找目标类是否有匹配的切面，高级切面转化为低级

  2. 根据1返回的集合，不为空则创建代理对象

package org.springframework.aop.framework.autoproxy;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
import org.springframework.aop.support.DefaultIntroductionAdvisor;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

import java.util.List;

public class A17 {


    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean("aspect1",Aspect1.class);
        context.registerBean("config",config.class);
        //加后置处理器
        context.registerBean(ConfigurationClassPostProcessor.class);
        //bean后处理器
        //位置  bean 创建-> (*) 依赖注入 -> (*) 初始化
        context.registerBean(AnnotationAwareAspectJAutoProxyCreator.class);
        context.refresh();
        for (String beanDefinitionName : context.getBeanDefinitionNames()) {
            System.out.println("beanDefinitionName = " + beanDefinitionName);
        }

        AnnotationAwareAspectJAutoProxyCreator creator = context.getBean(AnnotationAwareAspectJAutoProxyCreator.class);
//        A17_1 a17_1 = new A17_1();
        //第一个参数为目标类 找出目标类中有能使用增强的切面
        List<Advisor> target1 = creator.findEligibleAdvisors(Targer1.class, "target1");
//        List<Advisor> target1 = a17_1.findCandidateAdvisors(Targer1.class, "target1");
        System.out.println("================================");
//        for (Advisor advisor : target1) {
//            System.out.println("advisor = " + advisor);
//        }
        Object o1 = creator.wrapIfNecessary(new Targer1(), "target1", "target1");
        //o1为代理
        System.out.println("o1.getClass() = " + o1.getClass());
        //o2非代理
        Object o2 = creator.wrapIfNecessary(new Targer2(), "target2", "target2");
        System.out.println("o2.getClass() = " + o2.getClass());
    }

    static class Targer1{
        public void foo(){
            System.out.println("target1 foo");
        }
        
    }
    static class Targer2{
        public void bar(){
            System.out.println("target2 bar");
        }
    }


    //aspect切面
    @Aspect
    static class Aspect1{

        @Before("execution(* foo())")
        public void before(){
            System.out.println("aspect1 before.....");
        }

        @After("execution(* foo())")
        public void after(){
            System.out.println("aspect1 after.....");
        }

    }

    //advisor切面
    @Configuration
    static class config{

        @Bean
        public Advisor advisor3(MethodInterceptor advice3){
            AspectJExpressionPointcut aspectJExpressionPointcut = new AspectJExpressionPointcut();
            aspectJExpressionPointcut.setExpression("execution(* foo())");
            //第一个参数是切点 第二个参数是通知
            return new DefaultPointcutAdvisor(aspectJExpressionPointcut,advice3);
        }

        @Bean
        public MethodInterceptor advice3(){
            return new MethodInterceptor() {
                @Override
                public Object invoke(MethodInvocation methodInvocation) throws Throwable {
                    System.out.println("advisor3 before.....");
                    Object proceed = methodInvocation.proceed();
                    System.out.println("advisor3 after.....");
                    return proceed;
                }
            };
        }

    }

}

代理创建的时机

package org.springframework.aop.framework.autoproxy;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.CommonAnnotationBeanPostProcessor;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

import javax.annotation.PostConstruct;

public class A17_1 {
    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();
        context.registerBean(Config.class);
        //加后置处理器
        context.registerBean(ConfigurationClassPostProcessor.class);
        context.refresh();
        context.close();
    }


    @Configuration
    static class Config{

        @Bean//代理创建器
        public AnnotationAwareAspectJAutoProxyCreator annotationAwareAspectJAutoProxyCreator(){
            return new AnnotationAwareAspectJAutoProxyCreator();
        }

        @Bean//处理@autowired注解
        public AutowiredAnnotationBeanPostProcessor autowiredAnnotationBeanPostProcessor(){
            return new AutowiredAnnotationBeanPostProcessor();
        }

        @Bean//处理@postconstruct、
        public CommonAnnotationBeanPostProcessor commonAnnotationBeanPostProcessor(){
            return new CommonAnnotationBeanPostProcessor();
        }


        @Bean//切面
        public Advisor advisor(MethodInterceptor advice3){
            AspectJExpressionPointcut aspectJExpressionPointcut = new AspectJExpressionPointcut();
            aspectJExpressionPointcut.setExpression("execution(* foo())");
            //第一个参数是切点 第二个参数是通知
            return new DefaultPointcutAdvisor(aspectJExpressionPointcut,advice3);
        }

        @Bean//通知
        public MethodInterceptor advice3(){
            return new MethodInterceptor() {
                @Override
                public Object invoke(MethodInvocation methodInvocation) throws Throwable {
                    System.out.println("advisor3 before.....");
                    Object proceed = methodInvocation.proceed();
                    System.out.println("advisor3 after.....");
                    return proceed;
                }
            };
        }


        @Bean
        public Bean1 bean1(){
            return new Bean1();
        }
        @Bean
        public Bean2 bean2(){
            return new Bean2();
        }

    }

    static class Bean1 {
        public void foo() {
        }

        public Bean1() {
            System.out.println("bean1实例化构造方法........");
        }

        @PostConstruct
        public void init() {
            System.out.println("bean1的初始化init方法................");
        }
    }



    static class Bean2 {
        @Autowired
        public void setBean1(Bean1 bean1){
            System.out.println("bean2依赖注入bean1..................." + bean1.getClass());
        }

        public Bean2() {
            System.out.println("bean2实例化构造方法........");
        }

        @PostConstruct
        public void init() {
            System.out.println("bean2的初始化init方法................");
        }
    }

}

bean2依赖bean1的时候，并且bean1也依赖于bean2，即为循环依赖，bean1中有需要增强的方法，代理对象则是在bean1初始化之后创建，bea2则注入bea1的代理对象

  1. bean1构造

  2. 注入bean2，bean2没有，暂停进入bean2生命周期

  3. bean2实例化方法

  4. bean2依赖注入bean1，由于bean1中的方法需要增强，因此需要注入代理对象，在bean实例化后，创建bean1的代理对象

  5. bean2的初始化

  6. bean1的依赖注入

  7. bean1的初始化

总结

  1. 无循环依赖代理创建在初始化之后

  2. 有循环依赖时 创建于的实例化之后依赖注入之前，并且存于二级缓存中

  3. 依赖注入及初始化阶段不应增强，如set方法应该调用原始方法的set

高级切面转低级切面

共五种通知类型，在findEligibleAdvisors 方法中，转换为对应低级切面

  1. @Before 前置通知会被转换为原始的 AspectJMethodBeforeAdvice 形式, 该对象包含了如下信息

    1. 通知代码从哪儿来

    2. 切点是什么

    3. 通知对象如何创建, 本例共用同一个 Aspect 对象

  2. 类似的还有

    1. AspectJAroundAdvice (环绕通知)

    2. AspectJAfterReturningAdvice

    3. AspectJAfterThrowingAdvice (环绕通知)

    4. AspectJAfterAdvice (环绕通知)

package org.springframework.aop.framework.autoproxy;

import org.aspectj.lang.annotation.Before;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectInstanceFactory;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.aspectj.AspectJMethodBeforeAdvice;
import org.springframework.aop.aspectj.SingletonAspectInstanceFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class A18 {
    public static void main(String[] args) {
        AspectInstanceFactory factory = new SingletonAspectInstanceFactory(new Aspect());
        List<Advisor> list = new ArrayList<>();
        for (Method declaredMethod : Aspect.class.getDeclaredMethods()) {
            if (declaredMethod.isAnnotationPresent(Before.class)) {
                //解析切点
                String value = declaredMethod.getAnnotation(Before.class).value();
                AspectJExpressionPointcut aspectJExpressionPointcut = new AspectJExpressionPointcut();
                aspectJExpressionPointcut.setExpression(value);
                //转为对应底层通知类
                AspectJMethodBeforeAdvice aspectJMethodBeforeAdvice = new AspectJMethodBeforeAdvice(declaredMethod,aspectJExpressionPointcut,factory);
                //转为低级切面
                DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor(aspectJExpressionPointcut, aspectJMethodBeforeAdvice);
                list.add(defaultPointcutAdvisor);

            }
        }
        for (Advisor advisor : list) {
            System.out.println("advisor = " + advisor);
        }
    }

    static class Aspect{
        @Before("execution(* foo")
        public void before1() {
            System.out.println("===========before1========");
        }
        @Before("execution(* foo")
        public void before2() {
            System.out.println("===========before2========");
        }
    }
    static class Target{
        public void foo(){
            System.out.println("target foo===============");
        }
    }
}

总结：

  1. 拿到高级切面类，通过反射获取所有的方法

  2. 检查方法上是否包含通知类型的注解

  3. 解析注解的切点表达式，设置底层的切点对象

  4. 根据不同通知类型注解实现对应底层通知的实现，最终都是转化为环绕通知类型

  5. 通过通知和切点实现底层切面

李卫公的开平方机
关注
专栏目录
Spring AOP(四)基于@Aspect
liyuan0323的博客
07-23 432
一、简述--是什么 1、spring 使用jdk动态代理或cglib动态代理，没错是或。 2、 Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。当然，可以通过配置指定代理方式。&lt...
SpringAOP专题之6、Spring AOP中@Pointcut 12种用法
CSDN_KONGlX的博客
04-26 1313
本文主要内容：掌握@Pointcut的12种用法。 Aop相关阅读 阅读本文之前，需要先掌握下面几篇篇文章内容，不然会比较吃力。 代理详解(java动态代理&CGLIB代理) jdk动态代理和cglib代理 Aop概念详解 AOP核心源码、原理详解 ProxyFactoryBean创建AOP代理 本文继续AOP，目前手动Aop中三种方式已经介绍2种了，本文将介绍另外一种：Aspe...
高级Spring之从 @Aspect 到 Advisor
qq_61313896的博客
01-31 935
高级Spring之从 @Aspect 到 Advisor
Spring5 底层原理 从@AspectJ到Advisor（黑马）
weixin_53184944的博客
05-29 462
Spring5 底层原理 从@AspectJ到Advisor（黑马）
<aop:aspect>与<aop:advisor>的区别
热门推荐
根号三
04-23 2万+
在开发过程中，不少有Spring Aop的使用，大多数情况下我们用的是< aop:aspect>，只有在进行事务管理时才用到< aop:advisor>。但是，一直没弄清楚< aop:aspect>与< aop:advisor>的区别。
第三章 AOP 基于@Aspect的AOP
笨笨个人笔记
07-08 5297
在前面，我们分别使用Pointcut、Advice、Advisor接口来描述切点、增强、切面。而现在我们使用@AdpectJ注解来描述。 在下面的例子中，我们是使用Spring自动扫描和管理Bean（http://blog.csdn.net/p_3er/article/details/9239605）。 3.6.1一个简单的例子 a、目标类 @Repository public class
Spring声明式事务和@Aspect的拦截顺序问题的解决
08-27
其中，@Aspect 声明的 AOP 是通过 AnnotationAwareAspectJAutoProxyCreator 进行代理的，而声明式事务是 BeanNameAutoProxyCreator 方式进行代理的。由于这两种代理方式的拦截顺序不同，会导致拦截顺序问题。 解决...
xml中的 「aop:aspect」 与 「aop:advisor」
a683540819的博客
07-11 430
xml中的 <aop:aspect> 与 <aop:advisor> 在xml中配置 <aop:aspect> 先定义Bean对象 public interface ISleepable { public void sleep(); } public class Human implements ISleepable{ @Override public void sleep() { System.out.println(" 小主启动睡
Spring源码浅析之AOP、Aspect、Advice
DaHuangXiao的博客
06-15 1215
前言 理一理AOP与切面（Aspect）、通知（Advisor）的关系 概念 通知（Advice）: AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理。 连接点（join point）: 连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在 Spring AOP 中，连接点总是方法的调用。 切点（PointCut）: 可以插入增强处理的连接点。 切面（Aspect）: 切面是通知和切点的结合。 做了张图 PointCut：指的是具体
Spring中Adivisor和Aspect的区别（自我理解）
huitoukest的专栏
06-12 6541
在AOP中有几个概念：  — 方/切 面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的Advisor或拦截器实现。  — 连接点/织入点（Joinpoint）：程序执行过程中明确的点，如方法的调用或特定的异常被抛出。  — 通知（Advice）：在特定的连接点，AOP框架执行的动作。各种类型的通
spring的aop:advisor和aop:aspect
梅老板的博客
03-23 2128
概念:上网找关于这两个概念区别: 第一种说法 : 1、Adivisor是一种特殊的Aspect，Advisor代表spring中的Aspect 2、区别：advisor只持有一个Pointcut和一个advice，而aspect可以多个pointcut和多个advice 第二种说法: aop:aspect实际上是定义横切逻辑，就是在连接点上做什么，aop:advisor则定义了在哪些连接点应
关于spring中AOP的aspect和advisor的理解
sdx1237的博客
12-04 1089
在开发过程中，不少有Spring Aop的使用，在面向切面编程时，我们会使用< aop:aspect>；在进行事务管理时，我们会使用< aop:advisor>。那么，对于< aop:aspect>与< aop:advisor>的区别，具体是怎样的呢？ 至于两者的区别，网上有很多资料，但是似乎都不能说清楚。 首先，我们需要明确两者的概念。 < aop:aspect>：定义切面（切面包括通知和切点） < aop:advisor>：定义通知
spring Aop中aop:advisor 与 aop:aspect的区别
有志者一定行
10-21 2万+
在spring的配置中,会用到这两个标签.那么他们的区别是什么呢?      //切面代码     使用配置时,     如果切面代码是自动注入的bean,那么的ref属性直接写bean的注入名字就可以了!                                                                           
advisor和aspect有什么区别，为什么在代理类生成之前会将全部的aspect和通用拦截器（MethodInterceptor）适配成advisor？
yangxiaofei_java的博客
01-02 1064
aspect是切面是由advice（通知=连接点JoinPoint+衡器逻辑）和切点（pointCut）组成一个切面可以有多个通知；advisor也是一种切面但是只包含一个通知；将aspect适配成advisor是为了方便SpringAOP创建代理类的时候进行横切逻辑执行的管理。可以里理解为aspect是面向开发者的一种切面，支持在一个类里创建多个通知方便使用，advisor是面向SpringAOP的一种切面把多个aspect按通知拆分出来方便管理。通用拦截器适配成advisor也是为了方便统一管理，通用拦
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 606
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 250
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 563
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
aop:advisor和aop:aspect
04-06
AOP:Advisor和AOP:Aspect都是AOP（面向切面编程）的重要概念。AOP:Advisor是指一个通知的集合，是对一个特定的切入点所生效的通知的集合；而AOP:Aspect则是一个更大范围的抽象，包含了切入点、通知、切点等等的所有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值