AOP功能測試

先看一下這個類：

public class MathCalculator {    
    public int div(int i,int j){
        System.out.println("MathCalculator...div...");
        return i/j;    
    }
}

在這段執行邏輯中，我們想要列印一句話，但如果都這樣寫，耦合太高

所以我們寫個類，希望在呼叫目標方法之前（就是上面那個執行邏輯的類的方法），呼叫這個列印日誌的類的方法

/**
 * 切面類
 * 
 * @Aspect： 告訴Spring當前類是一個切面類
 
 
*/
@Aspect
public class LogAspects {    
    // 這個註解 抽取公共的切入點表示式
    //1、本類引用
    //2、其他的切面引用，* 表示所有方法，.. 表示不區分方法裡的什麼引數，可以任意
    @Pointcut("execution(public int com.atguigu.aop.MathCalculator.*(..))")
    public void pointCut(){};
    
    //@Before在目標方法之前切入；切入點表示式（指定在哪個方法切入）
    @Before("pointCut()")
    public
 
 void logStart(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        System.out.println(""+joinPoint.getSignature().getName()+"執行。。。@Before:引數列表是：{"+Arrays.asList(args)+"}");
    }
    
    @After("com.atguigu.aop.LogAspects.pointCut()")
    public void logEnd(JoinPoint joinPoint){
        System.out.println(
 
""+joinPoint.getSignature().getName()+"結束。。。@After");
    }
    
    //JoinPoint一定要出現在引數表的第一位，引數1 表示呼叫aop表示式，引數2 表示返回結果型別
    @AfterReturning(value="pointCut()",returning="result")
    public void logReturn(JoinPoint joinPoint,Object result){
        System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:執行結果：{"+result+"}");
    }
    
    @AfterThrowing(value="pointCut()",throwing="exception")
    public void logException(JoinPoint joinPoint,Exception exception){
        System.out.println(""+joinPoint.getSignature().getName()+"異常。。。異常資訊：{"+exception+"}");
    }
}

配置 及說明：

/**
 * AOP：【動態代理】
 *         指在程式執行期間動態的將某段程式碼切入到指定方法指定位置進行執行的程式設計方式；
 * 
 * 1、匯入aop模組；Spring AOP：(spring-aspects)
 * 2、定義一個業務邏輯類（MathCalculator）；在業務邏輯執行的時候將日誌進行列印（方法之前、方法執行結束、方法出現異常，xxx）
 * 3、定義一個日誌切面類（LogAspects）：切面類裡面的方法需要動態感知MathCalculator.div執行到哪裡然後執行；
 *         通知方法：
 *             前置通知(@Before)：logStart：在目標方法(div)執行之前執行
 *             後置通知(@After)：logEnd：在目標方法(div)執行結束之後執行（無論方法正常結束還是異常結束）
 *             返回通知(@AfterReturning)：logReturn：在目標方法(div)正常返回之後執行
 *             異常通知(@AfterThrowing)：logException：在目標方法(div)出現異常以後執行
 *             環繞通知(@Around)：動態代理，手動推進目標方法執行（joinPoint.procced()）
 * 4、給切面類的目標方法標註何時何地執行（通知註解）；
 * 5、將切面類和業務邏輯類（目標方法所在類）都加入到容器中;
 * 6、必須告訴Spring哪個類是切面類(給切面類上加一個註解：@Aspect)
 * [7]、給配置類中加 @EnableAspectJAutoProxy 【開啟基於註解的aop模式】
 *         在Spring中很多的 @EnableXXX;
 * 
 * 三步：
 *     1）、將業務邏輯元件和切面類都加入到容器中；告訴Spring哪個是切面類（@Aspect）
 *     2）、在切面類上的每一個通知方法上標註通知註解，告訴Spring何時何地執行（切入點表示式）
 *  3）、開啟基於註解的aop模式；@EnableAspectJAutoProxy
 *  
 * AOP原理：【看給容器中註冊了什麼元件，這個元件什麼時候工作，這個元件的功能是什麼？】
 *         @EnableAspectJAutoProxy；
 * 1、@EnableAspectJAutoProxy是什麼？
 *         @Import(AspectJAutoProxyRegistrar.class)：給容器中匯入AspectJAutoProxyRegistrar
 *             利用AspectJAutoProxyRegistrar自定義給容器中註冊bean；BeanDefinetion
 *             internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
 * 
 *         給容器中註冊一個AnnotationAwareAspectJAutoProxyCreator；
 * 
 * 2、 AnnotationAwareAspectJAutoProxyCreator：
 *         AnnotationAwareAspectJAutoProxyCreator
 *             ->AspectJAwareAdvisorAutoProxyCreator
 *                 ->AbstractAdvisorAutoProxyCreator
 *                     ->AbstractAutoProxyCreator
 *                             implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
 *                         關注後置處理器（在bean初始化完成前後做事情）、自動裝配BeanFactory
 * 　　分析：
 * AbstractAutoProxyCreator.setBeanFactory()
 * AbstractAutoProxyCreator.有後置處理器的邏輯；
 * 
 * AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()
 * 
 * AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()
 *
 *
 * 流程：
 *         1）、傳入配置類，建立ioc容器
 *         2）、註冊配置類，呼叫refresh（）重新整理容器；
 *         3）、registerBeanPostProcessors(beanFactory);註冊bean的後置處理器來方便攔截bean的建立；
 *             1）、先獲取ioc容器已經定義了的需要建立物件的所有BeanPostProcessor
 *             2）、給容器中加別的BeanPostProcessor
 *             3）、優先註冊實現了PriorityOrdered介面的BeanPostProcessor；
 *             4）、再給容器中註冊實現了Ordered介面的BeanPostProcessor；
 *             5）、註冊沒實現優先順序介面的BeanPostProcessor；
 *             6）、註冊BeanPostProcessor，實際上就是建立BeanPostProcessor物件，儲存在容器中；
 *                 建立internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
 *                 1）、建立Bean的例項
 *                 2）、populateBean；給bean的各種屬性賦值
 *                 3）、initializeBean：初始化bean；
 *                         1）、invokeAwareMethods()：處理Aware介面的方法回撥
 *                         2）、applyBeanPostProcessorsBeforeInitialization()：應用後置處理器的postProcessBeforeInitialization（）
 *                         3）、invokeInitMethods()；執行自定義的初始化方法
 *                         4）、applyBeanPostProcessorsAfterInitialization()；執行後置處理器的postProcessAfterInitialization（）；
 *                 4）、BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)建立成功；--》aspectJAdvisorsBuilder
 *             7）、把BeanPostProcessor註冊到BeanFactory中；
 *                 beanFactory.addBeanPostProcessor(postProcessor);
 * =======以上是建立和註冊AnnotationAwareAspectJAutoProxyCreator的過程========
 * 
 *             AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor
 *         4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；建立剩下的單例項bean
 *             1）、遍歷獲取容器中所有的Bean，依次建立物件getBean(beanName);
 *                 getBean->doGetBean()->getSingleton()->
 *             2）、建立bean
 *                 【AnnotationAwareAspectJAutoProxyCreator在所有bean建立之前會有一個攔截，InstantiationAwareBeanPostProcessor，會呼叫postProcessBeforeInstantiation()】
 *                 1）、先從快取中獲取當前bean，如果能獲取到，說明bean是之前被建立過的，直接使用，否則再建立；
 *                     只要建立好的Bean都會被快取起來
 *                 2）、createBean（）;建立bean；
 *                     AnnotationAwareAspectJAutoProxyCreator 會在任何bean建立之前先嚐試返回bean的例項
 *                     【BeanPostProcessor是在Bean物件建立完成初始化前後呼叫的】
 *                     【InstantiationAwareBeanPostProcessor是在建立Bean例項之前先嚐試用後置處理器返回物件的】
 *                     1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation
 *                         希望後置處理器在此能返回一個代理物件；如果能返回代理物件就使用，如果不能就繼續
 *                         1）、後置處理器先嚐試返回物件；
 *                             bean = applyBeanPostProcessorsBeforeInstantiation（）：
 *                                 拿到所有後置處理器，如果是InstantiationAwareBeanPostProcessor;
 *                                 就執行postProcessBeforeInstantiation
 *                             if (bean != null) {
                                bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                            }
 * 
 *                     2）、doCreateBean(beanName, mbdToUse, args);真正的去建立一個bean例項；和3.6流程一樣；
 *                     3）、
 *             
 * 建立AOP 代理        
 * AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】    的作用：
 * 1）、每一個bean建立之前，呼叫postProcessBeforeInstantiation()；
 *         關心MathCalculator和LogAspect的建立
 *         1）、判斷當前bean是否在advisedBeans中（儲存了所有需要增強bean）
 *         2）、判斷當前bean是否是基礎型別的Advice、Pointcut、Advisor、AopInfrastructureBean，
 *             或者是否是切面（@Aspect）
 *         3）、是否需要跳過
 *             1）、獲取候選的增強器（切面裡面的通知方法）【List<Advisor> candidateAdvisors】
 *                 每一個封裝的通知方法的增強器是 InstantiationModelAwarePointcutAdvisor；
 *                 判斷每一個增強器是否是 AspectJPointcutAdvisor 型別的；返回true
 *             2）、永遠返回false
 * 
 * 2）、建立物件
 * postProcessAfterInitialization；
 *         return wrapIfNecessary(bean, beanName, cacheKey);//包裝如果需要的情況下
 *         1）、獲取當前bean的所有增強器（通知方法）  Object[]  specificInterceptors
 *             1、找到候選的所有的增強器（找哪些通知方法是需要切入當前bean方法的）
 *             2、獲取到能在bean使用的增強器。
 *             3、給增強器排序
 *         2）、儲存當前bean在advisedBeans中；
 *         3）、如果當前bean需要增強，建立當前bean的代理物件；
 *             1）、獲取所有增強器（通知方法）
 *             2）、儲存到proxyFactory
 *             3）、建立代理物件：Spring自動決定
 *                 JdkDynamicAopProxy(config);jdk動態代理；
 *                 ObjenesisCglibAopProxy(config);cglib的動態代理；
 *         4）、給容器中返回當前元件使用cglib增強了的代理物件；
 *         5）、以後容器中獲取到的就是這個元件的代理物件，執行目標方法的時候，代理物件就會執行通知方法的流程；
 *         
 *     
 *     3）、目標方法執行    ；
 *         容器中儲存了元件的代理物件（cglib增強後的物件），這個物件裡面儲存了詳細資訊（比如增強器，目標物件，xxx）；
 *         1）、CglibAopProxy.intercept();攔截目標方法的執行
 *         2）、根據ProxyFactory物件獲取將要執行的目標方法攔截器鏈；
 *             List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
 *             1）、List<Object> interceptorList儲存所有攔截器 5
 *                 一個預設的ExposeInvocationInterceptor 和 4個增強器；
 *             2）、遍歷所有的增強器，將其轉為Interceptor；
 *                 registry.getInterceptors(advisor);
 *             3）、將增強器轉為List<MethodInterceptor>；
 *                 如果是MethodInterceptor，直接加入到集合中
 *                 如果不是，使用AdvisorAdapter將增強器轉為MethodInterceptor；
 *                 轉換完成返回MethodInterceptor陣列；
 * 
 *         3）、如果沒有攔截器鏈，直接執行目標方法;
 *             攔截器鏈（每一個通知方法又被包裝為方法攔截器，利用MethodInterceptor機制）
 *         4）、如果有攔截器鏈，把需要執行的目標物件，目標方法，
 *             攔截器鏈等資訊傳入建立一個 CglibMethodInvocation 物件，
 *             並呼叫 Object retVal =  mi.proceed();
 *         5）、攔截器鏈的觸發過程;
 *             1)、如果沒有攔截器執行執行目標方法，或者攔截器的索引和攔截器陣列-1大小一樣（指定到了最後一個攔截器）執行目標方法；
 *             2)、鏈式獲取每一個攔截器，攔截器執行invoke方法，每一個攔截器等待下一個攔截器執行完成返回以後再來執行；
 *                 攔截器鏈的機制，保證通知方法與目標方法的執行順序；
 *         
 *     總結：
 *         1）、  @EnableAspectJAutoProxy 開啟AOP功能
 *         2）、 @EnableAspectJAutoProxy 會給容器中註冊一個元件 AnnotationAwareAspectJAutoProxyCreator
 *         3）、AnnotationAwareAspectJAutoProxyCreator是一個後置處理器；
 *         4）、容器的建立流程：
 *             1）、registerBeanPostProcessors（）註冊後置處理器；建立AnnotationAwareAspectJAutoProxyCreator物件
 *             2）、finishBeanFactoryInitialization（）初始化剩下的單例項bean
 *                 1）、建立業務邏輯元件和切面元件
 *                 2）、AnnotationAwareAspectJAutoProxyCreator攔截元件的建立過程
 *                 3）、元件建立完之後，判斷元件是否需要增強
 *                     是：切面的通知方法，包裝成增強器（Advisor）;給業務邏輯元件建立一個代理物件（cglib）；
 *         5）、執行目標方法：
 *             1）、代理物件執行目標方法
 *             2）、CglibAopProxy.intercept()；
 *                 1）、得到目標方法的攔截器鏈（增強器包裝成攔截器MethodInterceptor）
 *                 2）、利用攔截器的鏈式機制，依次進入每一個攔截器進行執行；
 *                 3）、效果：
 *                     正常執行：前置通知-》目標方法-》後置通知-》返回通知
 *                     出現異常：前置通知-》目標方法-》後置通知-》異常通知
 */
@EnableAspectJAutoProxy　　　　
@Configuration
public class MainConfigOfAOP {
     
    //業務邏輯類加入容器中
    @Bean
    public MathCalculator calculator(){
        return new MathCalculator();
    }

    //切面類加入到容器中
    @Bean
    public LogAspects logAspects(){
        return new LogAspects();
    }
}

測試

public class IOCTest_AOP {  
    @Test
    public void test01(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
        
        //1、不要自己建立物件，自己new 的物件不具備spring 的aop功能，所以是不會列印的，所以要去spring容器裡面拿
//        MathCalculator mathCalculator = new MathCalculator();
//        mathCalculator.div(1, 1);
        MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);
        
        mathCalculator.div(1, 0);
        
        applicationContext.close();
    }
}