mini-spring|基于JDK和Cglib动态代理，实现AOP核心功能

AOP 的核心技术实现主要是动态代理的使用
那么我们就需要先来实现一个可以代理方法的 Proxy，其实代理方法主要是使用到方法拦截器类处理方法的调用 MethodInterceptor#invoke，而不是直接使用 invoke 方法中的入参 Method method 进行 method.invoke(targetObj, args) 这块是整个使用时的差异。
除了以上的核心功能实现，还需要使用到 org.aspectj.weaver.tools.PointcutParser 处理拦截表达式 “execution(* cn.bugstack.springframework.test.bean.IUserService.*(…))”，有了方法代理和处理拦截，我们就可以完成设计出一个 AOP 的雏形了。

工程结构

src
├── main
│ └── java
│ └── cn.bugstack.springframework
│ ├── aop
│ │ ├── aspectj
│ │ │ ├──AspectJExpressionPointcut.java

切点表达式实现了 Pointcut、ClassFilter、MethodMatcher，三个接口定义方法，同时这个类主要是对 aspectj 包提供的表达式校验方法使用

│ │ │ ├──AspectJExpressionPointcutAdvisor.java
│ │ ├── framework
│ │ │ ├──adapter
│ │ │ │ └──MethodBeforeAdviceInterceptor.java
│ │ │ ├── autoproxy
│ │ │ │ └── MethodBeforeAdviceInterceptor.java
│ │ │ ├── AopProxy.java
│ │ │ ├── Cglib2AopProxy.java
│ │ │ ├──JdkDynamicAopProxy.java
│ │ │ ├──ProxyFactory.java
│ │ │ ├── ReflectiveMethodInvocation.java
│ │ ├── AdvisedSupport.java

AdvisedSupport，主要是用于把代理、拦截、匹配的各项属性包装到一个类中，方便在 Proxy 实现类进行使用。这和你的业务开发中包装入参是一个道理

│ │ ├── Advisor.java
│ │ ├── BeforeAdvice.java
│ │ ├── ClassFilter.java

定义类匹配类，用于切点找到给定的接口和目标类。

│ │ ├── MethodBeforeAdvice.java
│ │ ├── MethodMatcher.java

方法匹配，找到表达式范围内匹配下的目标类和方法。在上文的案例中有所体现：methodMatcher.matches(method, targetObj.getClass())

│ │ ├── Pointcut.java

切入点接口，定义用于获取 ClassFilter、MethodMatcher 的两个类

│ │ ├── PointcutAdvisor.java
│ │ ├── TargetSource.java
│ ├── beans
│ │ ├── factory
│ │ │ ├── factory
│ │ │ │ ├── AutowireCapableBeanFactory.java
│ │ │ │ ├── BeanDefinition.java（实体类）

初始化和销毁

│ │ │ │ ├── BeanFactoryPostProcessor.java
│ │ │ │ ├── BeanPostProcessor.java
│ │ │ │ ├── BeanReference.java
│ │ │ │ ├── ConfigurableBeanFactory.java（接口）定义了 destroySingletons 销毁方法
│ │ │ │ └── SingletonBeanRegistry.java
│ │ │ ├── support
│ │ │ │ ├── AbstractAutowireCapableBeanFactory.java（抽象类）

主要作用：
继承关系：继承AbstractBeanFactory
实现AutowireCapableBeanFactory接口
主要方法：
CreateBean():创建Bean 调用registerDisposableBeanIfNecessary
initializeBean():初始化Bean，调用PostProcessor Before 处理，执行初始化方法invokeInitMethods，执行 BeanPostProcessor After 处理

│ │ │ │ ├── AbstractBeanDefinitionReader.java
│ │ │ │ ├── AbstractBeanFactory.java
│ │ │ │ ├── BeanDefinitionReader.java
│ │ │ │ ├── BeanDefinitionRegistry.java
│ │ │ │ ├── CglibSubclassingInstantiationStrategy.java
│ │ │ │ ├── DefaultListableBeanFactory.java
│ │ │ │ ├── DefaultSingletonBeanRegistry.java

实现destroySingletons 销毁方法（ AbstractBeanFactory.java的父类）

│ │ │ │ ├── DisposableBeanAdapter.java

描述：销毁方法适配器
继承关系：实现DisposableBean接口

│ │ │ │ ├── FactoryBeanRegistrySupport.java（继承 DefaultSingletonBeanRegistry）

作用：实现一个 FactoryBean 注册服务
维护一个存放FactoryBean对象的缓存 factoryBeanObjectCache
处理的就是关于 FactoryBean 此类对象的注册操作
GetObjectFromFactoryBean() 从FactoryBean通过getObject()获取对象，先判断缓存中是否有如果有直接获取，没有则加入缓存

│ │ │ │ ├── InstantiationStrategy.java
│ │ │ │ └── SimpleInstantiationStrategy.java
│ │ │ ├── support
│ │ │ │ └── XmlBeanDefinitionReader.java
│ │ │ ├── Aware.java（接口）
│ │ │ ├── BeanClassLoaderAware.java（实现Aware接口）
│ │ │ ├── BeanFactory.java
│ │ │ ├──BeanFactoryAware.java（实现Aware接口）
│ │ │ ├── BeanNameAware.java
│ │ │ ├── ConfigurableListableBeanFactory.java
│ │ │ ├── DisposableBean.java
│ │ │ ├──FactoryBean.java（实现FactoryBean）

主要方法：
getObject()获取对象
getObjectType()对象类型
isSingleton()是否是单例对象如果是单例对象会被放到内存中

│ │ │ ├── HierarchicalBeanFactory.java
│ │ │ ├── InitializingBean.java（接口）定义初始化方法
│ │ │ └── ListableBeanFactory.java
│ │ ├── BeansException.java
│ │ ├── PropertyValue.java
│ │ └── PropertyValues.java
│ ├── context
│ │ ├── support
│ │ │ ├── AbstractApplicationEventMulticaster.java

继承 ApplicationEventMulticaster的抽象类
维护一个事件监听器的Set,一个BeanFactory的属性
addApplicationListener() removeApplicationListener 添加和删除事件监听器
getApplicationListeners 摘取符合广播事件中的监听处理器使用supportEvent判断
supportsEvent(applicationListener, ApplicationEvent event)

│ │ │ ├── ApplicationContextEvent.java (继承Application Event)

定义事件的抽象类

│ │ │ ├── ApplicationEventMulticaster.java

作用:添加监听和删除监听
接口

│ │ │ ├── ContextClosedEvent.java

定义关闭事件的抽象类(对象是ApplicationContent)

│ │ │ ├── ContextRefreshedEvent.java

定义刷新事件的抽象类(对象是ApplicationContent)

│ │ │ ├── SimpleApplicationEventMulticaster.java
│ │ ├── support
│ │ │ ├── AbstractApplicationContext.java（抽象类）

继承关系：实现 ConfigurableApplicationContext接口继承DefaultResourceLoader类

│ │ │ ├── AbstractRefreshableApplicationContext.java
│ │ │ ├── AbstractXmlApplicationContext.java
│ │ │ ├── ApplicationContextAwareProcessor.java（实现BeanPostProcessor接口）
│ │ │ └── ClassPathXmlApplicationContext.java
│ │ ├── ApplicationContext.java
│ │ ├──ApplicationContextAware.java
│ │ ├──ApplicationEvent.java

定义事件的抽象类
包含事件源对象

│ │ ├── ApplicationEventPublisher.java

事件发布接口

│ │ ├── ApplicationListener.java
│ │ └── ConfigurableApplicationContext.java（接口）

主要描述：虚拟机关闭钩子注册调用销毁，定义刷新容器，关闭应用上下文
继承关系：继承ApplicationContext
主要方法：
refresh()：
registerShutdownHook()：注册虚拟机钩子的方法
close()：手动执行关闭虚拟机钩子的方法

│ ├── core.io
│ │ ├── ClassPathResource.java
│ │ ├── DefaultResourceLoader.java(实体类)

作用：资源处理器

│ │ ├── FileSystemResource.java
│ │ ├── Resource.java
│ │ ├── ResourceLoader.java
│ │ └── UrlResource.java
│ └── utils
│ └── ClassUtils.java
└── test
结构关系
在这里插入图片描述
1.整个类关系图就是 AOP 实现核心逻辑的地方，上面部分是关于方法的匹配实现，下面从 AopProxy 开始是关于方法的代理操作。
2.AspectJExpressionPointcut 的核心功能主要依赖于 aspectj 组件并处理 Pointcut、ClassFilter,、MethodMatcher 接口实现，专门用于处理类和方法的匹配过滤操作。
3.AopProxy 是代理的抽象对象，它的实现主要是基于 JDK 的代理和 Cglib 代理。

实现

代理方法案例

@Test
public void test_proxy_method() {
   
   
    // 目标对象(可以替换成任何的目标对象)
    Object targetObj = new UserService();
    // AOP 代理->代理对象
    IUserService proxy = (IUserService) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), targetObj.getClass().getInterfaces(), new InvocationHandler() {
   
   
        // 方法匹配器
        MethodMatcher methodMatcher = new AspectJExpressionPointcut("execution(* cn.bugstack.springframework.test.bean.IUserService.*(..))");
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
   
            if (methodMatcher.matches(method, targetObj.getClass())) {
   
   //方法匹配
                // 方法拦截器->加入操作
                MethodInterceptor methodInterceptor = invocation -> {
   
   
                    long start = System.currentTimeMillis();
                    try {
   
   
                        return invocation.proceed();
                    }