Spring---AOP

总结 

　　基于代理模式。

　　Spring AOP支持两种类型的代理机制：JDK动态代理和CGLIB代理。这两种代理机制在不同情况下会被使用，具体取决于目标对象的类型。

1. JDK动态代理

• 适用情况：当目标对象实现了至少一个接口时，Spring会默认使用JDK动态代理。
• 实现原理：
  • JDK动态代理是Java标准库提供的功能，位于java.lang.reflect包中。
  • 允许 在运行时 创建 一个实现了一组给定接口的新类。这个新类可以用来作为代理，拦截对这些接口方法的调用，并可以在实际调用前后执行额外的逻辑。
  • Spring会为 每个目标对象 创建 一个实现了相同接口的代理类。这个 代理类内部 持有一个目标对象的引用，并且重写了接口中的方法。
  • 当调用代理对象的方法时，实际执行的是代理类中的方法。在这个方法中，Spring可以插入切面逻辑（如前置通知、后置通知等），然后再调用目标对象的实际方法。

示例

 

2. CGLIB代理

• 适用情况：当目标对象没有实现任何接口时，Spring会使用CGLIB代理。
• 实现原理：
  • CGLIB是一个开源库，它可以在运行时动态生成一个子类来扩展目标类。
  • Spring会为每个目标对象创建一个继承自该目标类的子类。这个子类重写了父类的方法。
  • 当调用代理对象的方法时，实际执行的是子类中的方法。同样，在这个方法中，Spring可以插入切面逻辑，然后再调用父类的实际方法。

 

/**
     *  【Spring-AOP实现】
     *      org.springframework.aop.framework.AopProxy
     *          Delegate interface for a configured AOP proxy, allowing for the creation of actual proxy objects.
     *          Out-of-the-box implementations are available for JDK dynamic proxies and for CGLIB proxies, as applied by DefaultAopProxyFactory.
     *
     *          public interface AopProxy {
     *              Object getProxy();
     *              Object getProxy(@Nullable ClassLoader classLoader);
     *          }
     *
     *
     *          org.springframework.aop.framework.JdkDynamicAopProxy
     *              JDK-based AopProxy implementation for the Spring AOP framework, based on JDK java.lang.reflect.Proxy dynamic proxies. 基于JDK动态代理实现；
     *              Objects of this type should be obtained through proxy factories, configured by an  AdvisedSupport class. 该类型的代理对象 应该由工厂提供，工厂由AdvisedSupport提供支持；
     *
     *              final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
     *
     *                  private final AdvisedSupport advised;
     *
     *                  public Object getProxy() {
     *                      return getProxy(ClassUtils.getDefaultClassLoader());
     *                  }
     *                  public Object getProxy(@Nullable ClassLoader classLoader) {
     *                      ...
     *                      return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
     *                  }
     *
     *                  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {}
     *              }
     *
     *
     *          org.springframework.aop.framework.CglibAopProxy
     *              CGLIB-based AopProxy implementation for the Spring AOP framework. 基于CGLB的AOP代理实现；
     *              Objects of this type should be obtained through proxy factories, configured by an AdvisedSupport object. 该类型的代理对象 应该由工厂提供，工厂由AdvisedSupport提供支持；
     *              DefaultAopProxyFactory will automatically create CGLIB-based proxies if necessary, for example in case of proxying a target class. 如果需要创建代理对象，DefaultAopProxyFactory将会创建CGLB代理对象；
     *
     *              class CglibAopProxy implements AopProxy, Serializable {
     *
     *                  protected final AdvisedSupport advised;
     *
     *                  public Object getProxy() {
     *                      return getProxy(null);
     *                  }
     *                  public Object getProxy(@Nullable ClassLoader classLoader) {
     *
     *                  }
     *
     *                  private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
     *                      public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {}
     *                  }
     *                  ...
     *              }
     *
     *
     *
     *      org.springframework.aop.framework.AopProxyFactory
     *          Interface to be implemented by factories that are able to create AOP proxies based on {@link AdvisedSupport} configuration objects. 被代理工厂类实现 能够 基于AdvisedSupport  创建AOP代理类；
     *
     *          public interface AopProxyFactory {
     *              AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException;
     *          }
     *
     *      org.springframework.aop.framework.DefaultAopProxyFactory
     *          Default {@link AopProxyFactory} implementation, creating either a CGLIB proxy or a JDK dynamic proxy. 默认的AopProxyFactory实现；
     *
     *          public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
     *              public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
     *                  if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
     *                      Class<?> targetClass = config.getTargetClass();
     *                      if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
     * 				            return new JdkDynamicAopProxy(config);
     *                      }
     * 			            return new ObjenesisCglibAopProxy(config);
     *                  }
     *                  else{
     *                      return new JdkDynamicAopProxy(config);
     *                  }
     *              }
     *          }
     *
     *      org.springframework.aop.framework.ProxyCreatorSupport
     *          Base class for proxy factories. 代理工厂的基类；
     *          Provides convenient access to a configurable AopProxyFactory. 提供便捷的方式访问AopProxyFactory；
     *
     *          public class ProxyCreatorSupport extends AdvisedSupport {
     *
     *              private AopProxyFactory aopProxyFactory;
     *
     *              public AopProxyFactory getAopProxyFactory() {
     * 		            return this.aopProxyFactory;
     *              }
     *
     *              protected final synchronized AopProxy createAopProxy() {
     *                  ...
     *                  return getAopProxyFactory().createAopProxy(this);
     *              }
     *          }
     *
     *      org.springframework.aop.framework.ProxyFactory
     *          public class ProxyFactory extends ProxyCreatorSupport {
     *
     *              public Object getProxy(@Nullable ClassLoader classLoader) {
     * 		            return createAopProxy().getProxy(classLoader);                ---createAopProxy() ：使用DefaultAopProxyFactory创建对应的AopProxy；
     * 		                                                                                                   ProxyFactory.getProxy
     * 		                                                                                                -> ProxyCreatorSupport.createAopProxy
     * 		                                                                                                -> ProxyCreatorSupport.getAopProxyFactory
     * 		                                                                                                -> AopProxyFactory.createAopProxy
     * 		                                                                                                -> DefaultAopProxyFactory.createAopProxy
     * 		                                                                          ---getProxy(classLoader) ： 不同的AopProxy创建不同的AOP代理对象；
     *
     *              }
     *          }
     *
     *
     *      实现思路：BeanPostProcessor#postProcessAfterInitialization
     *
     *      org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean
     *
     *      ->
     *
     *      org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization
     *
     *      ->
     *
     *      不同的BeanPostProcessor有不同的实现
     *          eg:
     *              BeanPostProcessor : org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
     *                  @Aspect
     *                      org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization{
     *
     *                          ...
     *                          return wrapIfNecessary(bean, beanName, cacheKey);
     *                          ...
     *
     *                      }
     *
     *                      protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
     *                          ...
     *                          if (specificInterceptors != DO_NOT_PROXY) {
     *                              ...
     *                              Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
     * 				                ...
     *                          }
     *                          ...
     *                      }
     *
     *                      protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) {
     *                          ...
     *                          ProxyFactory proxyFactory = new ProxyFactory();
     *                          ...
     *                          proxyFactory.addAdvisors(advisors);
     *                          ...
     *                          return proxyFactory.getProxy(getProxyClassLoader());
     *                      }
     *
     *                  事务
     *                      org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
     *
     *
     *              BeanPostProcessor : org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor
     *                  @Async
     *                      org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor#postProcessAfterInitialization{
     *                          ...
     *                          if (isEligible(bean, beanName)) {
     *                              ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName);
     *                              ...
     *                              proxyFactory.addAdvisor(this.advisor);
     *                              ...
     *                              return proxyFactory.getProxy(getProxyClassLoader());
     *                          }
     *                      }
     *
     *
     */