* AOP【动态代理】 : 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
 *                  1.如何使用?
 *                      (1).导入AOP的依赖。
 *                      (2).定义一个业务逻辑类(MathCalculator)。在业务逻辑运行的时候将日志进行打印(方法之前，方法结束，方法异常)
 *                      (3).定义一个日志切面类(LogAspect)。切面类里面的方法需要动态的感知 业务逻辑类(MathCalculator)的运行情况
 *                              (3.1).通知方法： 前置通知@Before(在目标方法运行之前运行)，
 *                                              后置通知@After(在目标方法运行之后运行,不在意正常结束还是异常结束)，
 *                                              返回通知@AfterReturning(在目标方法正常返回之后运行)，
 *                                              异常通知@AfterThrowing(在目标方法发生异常之后运行)，
 *                                              环绕通知@Round(动态代理，手动推进目标方法运行 joinPoint.)
 *                      (4).给切面类(LogAspect)的目标方法标注何时何处地运行 (通知注解)
 *                      (5).将切面类和业务逻辑类(目标方法所在类) 都加入到容器中
 *                      (6).必须告诉Spring的IOC容器哪个类是切面类(我们需要给切面类添加一个注解 @Aspect)
 *                      (7).在配置类上开启 注解版的切面功能 ( <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  @EnableAspectJAutoProxy)
 *                      (8).测试，这个逻辑类一定要使用IOC容器的类，不能使用new

<!--    Spring切面的包    -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>

package com.jsxs.aop;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:49
 * @PackageName:com.jsxs.aop
 * @ClassName: MathCalculator
 * @Description: TODO
 * @Version 1.0
 */
public class MathCalculator {
    public int div(int x,int y){
        return x/y;
    }
}

package com.jsxs.aop;
import org.aspectj.lang.annotation.*;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:52
 * @PackageName:com.jsxs.aop
 * @ClassName: LogAspect
 * @Description: TODO
 * @Version 1.0
 */
@Aspect // 告诉IOC容器这是一个切面类 ⭐
public class LogAspect {
    // 1.抽取公共地切入点表达式  ⭐⭐
    @Pointcut("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void  pointCut(){}
    // 2.在目标方法之前运行切入:切入点表达式( public int com.jsxs.aop.MathCalculator.div(int,int))
    // *号代表这个类地所有方法, 一个.代表一个变量
    @Before("pointCut()")  ⭐⭐⭐
    public void logStart(){
        System.out.println("除法运行..... 参数列表是:{}");
    }
    // 3.在目标方法之后进行切入， 使用公共地切入点表达式
    @After("pointCut()")  ⭐⭐⭐⭐
    public void endStart(){
        System.out.println("除法运行结束....");
    }
    // 4.在目标方法返回正确地话
    @AfterReturning("pointCut()")  ⭐⭐⭐⭐⭐
    public void success(){
        System.out.println("除法正常运行... 运行结果:{}");
    }
    // 5.在目标方法出现异常地话
    @AfterThrowing("pointCut()")  ⭐⭐⭐⭐⭐⭐
    public void logError(){
        System.out.println("除法异常运行...");
    }
}

package com.jsxs.aop;
import org.aspectj.lang.annotation.*;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:52
 * @PackageName:com.jsxs.aop
 * @ClassName: LogAspect
 * @Description: TODO
 * @Version 1.0
 */
@Aspect // 告诉IOC容器这是一个切面类  ⭐
public class LogAspect {
    // 2.在目标方法之前运行切入:切入点表达式( public int com.jsxs.aop.MathCalculator.div(int,int)) 
    // *号代表这个类地所有方法, 一个.代表一个变量  ⭐⭐
    @Before("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void logStart(){
        System.out.println("除法运行..... 参数列表是:{}");
    }
    // 3.在目标方法之后进行切入， 使用公共地切入点表达式 ⭐⭐⭐
    @After("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void endStart(){
        System.out.println("除法运行结束....");
    }
    // 4.在目标方法返回正确地话  ⭐⭐⭐⭐
    @AfterReturning("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void success(){
        System.out.println("除法正常运行... 运行结果:{}");
    }
    // 5.在目标方法出现异常地话 ⭐⭐⭐⭐⭐
    @AfterThrowing("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void logError(){
        System.out.println("除法异常运行...");
    }
}

package com.jsxs.config;
import com.jsxs.aop.LogAspect;
import com.jsxs.aop.MathCalculator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:41
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAOP
 * @Description: TODO  AOP【动态代理】 : 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
 *                  1.如何使用?
 *                      (1).导入AOP的依赖。
 *                      (2).定义一个业务逻辑类(MathCalculator)。在业务逻辑运行的时候将日志进行打印(方法之前，方法结束，方法异常)
 *                      (3).定义一个日志切面类(LogAspect)。切面类里面的方法需要动态的感知 业务逻辑类(MathCalculator)的运行情况
 *                              (3.1).通知方法：  前置通知@Before(在目标方法运行之前运行)，
 *                                              后置通知@After(在目标方法运行之后运行,不在意正常结束还是异常结束)，
 *                                              返回通知@AfterReturning(在目标方法正常返回之后运行)，
 *                                              异常通知@AfterThrowing(在目标方法发生异常之后运行)，
 *                                              环绕通知@Round(动态代理，手动推进目标方法运行 joinPoint.)
 *                      (4).给切面类的目标方法标注何时何处地运行 (通知注解)⭐⭐
 *                      (5).将切面类和业务逻辑类(目标方法所在类) 都加入到容器中 ⭐⭐⭐
 *                      (6).必须告诉Spring的IOC容器哪个类是切面类(我们需要给切面类添加一个注解 @Aspect)  ⭐⭐⭐⭐
 *                      (7).在配置类上开启 注解版的切面功能 ( <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  @EnableAspectJAutoProxy)
 *                      (8).测试，这个逻辑类一定要使用IOC容器的类，不能使用new
 * @Version 1.0
 */
@Configuration  //⭐
@EnableAspectJAutoProxy //⭐⭐ 开启注解版本的依赖
public class MainConfigOfAOP {
    // 业务逻辑类  ⭐⭐⭐⭐
    @Bean
    public MathCalculator mathCalculator(){
        return new MathCalculator();
    }
    // 切面类 ⭐⭐⭐⭐⭐
    @Bean
    public LogAspect logAspect(){
        return new LogAspect();
    }
}

package com.jsxs.Test;
import com.jsxs.aop.MathCalculator;
import com.jsxs.config.MainConfigOfAOP;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/8/19 12:47
 * @PackageName:com.jsxs.Test
 * @ClassName: AOP_Test
 * @Description: TODO
 * @Version 1.0
 */
public class AOP_Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        // 1.这个对象我们不能使用new创建，我们需要使用IOC容器的组件进行调用 ⭐
        MathCalculator calculator = applicationContext.getBean(MathCalculator.class);
        calculator.div(1,3);
    }
}

package com.jsxs.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import java.util.Arrays;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:52
 * @PackageName:com.jsxs.aop
 * @ClassName: LogAspect
 * @Description: TODO
 * @Version 1.0
 */
@Aspect // 告诉IOC容器这是一个切面类  ⭐
public class LogAspect {
    // 2.在目标方法之前运行切入:切入点表达式( public int com.jsxs.aop.MathCalculator.div(int,int))
    // *号代表这个类地所有方法, 一个.代表一个变量
    @Before("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void logStart(JoinPoint joinPoint){  //⭐⭐ 切入点类可以获取名字和参数列表
        System.out.println(joinPoint.getSignature().getName()+"除法运行..... 参数列表是:{"+ Arrays.asList(joinPoint.getArgs())+"}");
    }
    // 3.在目标方法之后进行切入， 使用公共地切入点表达式
    @After("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void endStart(){
        System.out.println("除法运行结束....");
    }
    // 4.在目标方法返回正确地话  ⭐⭐⭐ 获取返回结果，注解里面的参数名要和方法里面的参数名一致
    @AfterReturning(value = "execution(public int com.jsxs.aop.MathCalculator.*(..))",returning = "result")
    public void success(JoinPoint joinPoint,Object result){
        System.out.println(joinPoint.getSignature().getName()+"除法正常运行... 运行结果:{"+result+"}");
    }
    // 5.在目标方法出现异常地话 ⭐⭐⭐⭐ 获取异常信息
    @AfterThrowing(value = "execution(public int com.jsxs.aop.MathCalculator.*(..))",throwing = "exception")
    public void logError(Exception exception){
        System.out.println("除法异常运行..."+exception);
    }
}

*                 AOP【原理】
 *                  1.@EnableAspectJAutoProxy ->核心注解
 *                      (1).@Import(AspectJAutoProxyRegistrar.class) -> 给容器中导入AspectJAutoProxyRegistrar这个组件
 *                          internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
 *                          给容器中注入了一个AnnotationAwareAspectJAutoProxyCreator ⭐

* AOP【原理】
 *                  1.@EnableAspectJAutoProxy ->核心注解
 *                      (1).@Import(AspectJAutoProxyRegistrar.class) -> 给容器中导入AspectJAutoProxyRegistrar这个组件
 *                          internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
 *                          给容器中注入了一个AnnotationAwareAspectJAutoProxyCreator
 *                  2. AnnotationAwareAspectJAutoProxyCreator
 *                      AnnotationAwareAspectJAutoProxyCreator
 *                          ->(继承) AspectJAwareAdvisorAutoProxyCreator
 *                              ->(继承) AbstractAutoProxyCreator implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
 *                                       关注后置处理器(在bean初始化前后) 和 自动装配BeanFactory
 *                                       (2.1). setBeanFactory
 *                                  ->(继承) AbstractAdvisorAutoProxyCreator
 *                                      ->(继承) ProxyConfig
 *                                          ->(继承) Object       

*  3.流程:
 *                      (1).传入配置类，创建IOC容器 -> new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
 *                      (2).注册配置类register(annotatedClasses)，重启IOC容器refresh()
 *                      (3).registerBeanPostProcessors(beanFactory); 注册bean的后置处理器来方便拦截bean的创建
 *                          (3.1).先获取IOC容器已经定义了的需要创建对象的所有 BeanPostProcessor
 *                          (3.2).给容器中添加别的BeanPostProcessor
 *                          (3.3).优先注册了priorityOrderedPostProcessors接口的BeanPostProcessor
 *                          (3.4).在给容器中注册实现了Ordered接口的BeanPostProcessor
 *                          (3.5).注册没实现优先级接口的 BeanPostProcessors
 *                          (3.6).注册BeanPostProcessors，实际上就是创建BeanPostProcessors对象，保存在容器中；
 *                              创建internalAutoProxyCreator的BeanPostProcessors【AnnotationAwareAspectJAutoProxyCreator】
 *                                  (1).创建Bean的实列
 *                                  (2).populateBean:给bean的各种属性赋值
 *                                  (3).initializeBean: 初始化bean
 *                                      (1).invokeAwareMethods() :处理Aware接口的方法回调
 *                                      (2).applyBeanPostProcessorsBeforeInitialization() 应用后置处理器
 *                                      (3).invokeInitMethods()执行自定义的初始方法
 *                                      (4).applyBeanPostProcessorsAfterInitialization() 执行后置处理器的postProcessor
 *                                  (4).BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator) 创建成功
 *                         （3.7）.把BeanPostProcessor注册到BeanFactory中 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

* 4.执行时机
 *                          1.遍历容器中所有的Bean,依次创建对象getBean(beanName)
 *                              getBean->doGetBean()->getSingleton->
 *                          2.创建bean
 *                              (1).先从缓存中获取当前bean,如果能获取到，说明bean是之前被创建过的，直接使用，否则再创建
 *                                  只要创建好的Bean都会被缓存起来。
 *
 *                              (2).CreateBean() 创建bean
 *                                  (2.1).resolveBeforeForeInstantion(beanName,mbdToUse) --> 希望后置处理器在此能返回一个代理对象，如果能返回代理对象就使用，如果不能就继续
 *                                  (2.2).doCreateBean() 真正的去创建一个bean实列
 *                           3.  AnnotationAwareAspectJAutoProxyCreator 在所有的bean创建之前会有一个拦截，InstantionAnwareBeanPostProcessor,会调用PostProcessBeforeInstantiation
 *

*  5.AOP原理
 *          1.每一个bean创建之前，调用postProcessBeforeInstantiation();
 *                              关心 普通组件 和 切面组件 的创建
 *                                  (1).判断当前bean是否在advisedBeans中(保存了所需要增强的bean)
 *                                  (2).判断是否是切面
 *                                  (3).是否需要跳过
 *                                      (3.1).获取候选的增强器(切面里面的通知方法) 每一个封装的通知方法都是一个增强器 ，返回true
 *                                      (3.2). 返回false -> 永远不跳过
 *          2.每一个bean创建之后，调用postProcessAfterInstantiation();
 *                              (1).获取当前bean的所有增强器(增强方法)
 *                                  (1.1).找到的候选的所有增强器(找那些通知方法是需要切入当前bean方法的)
 *                                  (1.2).获取能在当前bean使用的增强器
 *                                  (1.3).给增强器进行排序
 *                              (2).保存当前bean在adviseBeans中
 *                              (3).如果当前bean需要增强，创建当前bean的代理对象。
 *                                  (3.1).获取所有增强器(通知方法)
 *                                  (3.2).保存到proxyFactory
 *                                  (3.3).创建代理对象 ⭐ (两种)
 *                                      (3.3.1).JDKDynamicAopProxy(config)  ->jdk创建代理模式(有接口使用jdk)
 *                                      (3.3.2).ObjenesisCglibAopProxy(config)  ->cglib创建代理模式(无接口使用cglib)
 *                             ⭐      (3.4).给IOC容器返回当前组件使用cglib增强了的代理对象
 *                             ⭐      (3.5).以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程