动态代理

代理的解释: 为其他对象提供一种代理来控制这个对象的访问,增强一个类中的某个方法,对程序进行扩展
比如,现在存在一个类

  1. public class UserService {
  2.     public void test() {
  3.         System.out.println("test...");
  4.     }
  5. }

如果我们现在想在不修改UserService类的源码前提下,给test增加额外逻辑,那么就可以使用动态代理机制来创建UserService对象了,如下

@Test
public void cglibProxy() {
    UserService target = new UserService();
    // 通过cglib技术
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(UserService.class);
    // 定义额外逻辑,也就是代理逻辑
    enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            System.out.println("before....");
            Object invoke = method.invoke(target, objects);
            System.out.println("after...");
            return invoke;
        }
    }});
    UserService userService = (UserService) enhancer.create();
    userService.test();
}

得到的都是UserService对象,但是执行test方法时的效果却不一样了,这就是代理所带来的效果.
上面是通过cglib来实现的代理独享的创建,是基于父子类的,被代理UserService是父类,代理类是子类,代理对象就是代理类的实例对象,代理类是由cglib创建的,对于开发人员来说不用关心.
除了cglib,jdb本身也提供了一种创建代理对象的动态代理机制,但是它只能代理接口,也就是UserService得先有一个接口才能利用jdk动态代理机制来生成一个代理对象

public interface AInterface {
    void test();
}
public class AService implements AInterface{
    @Override
    public void test() {
        System.out.println("test...");
    }
}

利用jdk动态代理来生成一个代理对象

@Test
public void jdkProxy() {
    AService target = new AService();
    // AInterface接口的代理对象
    Object proxy = Proxy.newProxyInstance(AService.class.getClassLoader(), new Class[]{AInterface.class}, new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("before....");
            Object invoke = method.invoke(target, args);
            System.out.println("after...");
            return invoke;
        }
    });
    AInterface aInterface = (AInterface) proxy;
    aInterface.test();
}

如果你把 new Class[]{AInterface.class},替换成 new Class[]{AService.class},运行代码会直接报错,表示一定要是个接口,由于这个限制,所以产生的代理对象的类型是AInterface,而不是AService,这是需要注意的

linc.fun.service.AService is not an interface
java.lang.IllegalArgumentException: linc.fun.service.AService is not an interface

ProxyFactory

上面我们介绍了两种动态代理技术,那么在Spring中进行了封装,封装出来的类叫做ProxyFactory,表示是创建代理对象的一个工厂,使用起来会比上面的更加方便

@Test
public void proxyFactory() {
    AService target = new AService();
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setTarget(target);
    proxyFactory.addAdvice(new org.aopalliance.intercept.MethodInterceptor() {
        @Nullable
        @Override
        public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
            System.out.println("before....");
            Object proceed = invocation.proceed();
            System.out.println("after...");
            return proceed;
        }
    });
    AInterface aInterface = (AInterface) proxyFactory.getProxy();
    aInterface.test();
}

通过ProxyFactory,我们可以不再关注到底是cglib还是jdk动态代理了,ProxyFactory会帮助我们判断,如果AService实现了接口,那么ProxyFactory底层就会用jdk动态代理,如果没有实现,就会用cglib

Advice的分类

  1. Before Advice：方法之前执行
  2. After returning advice：方法return后执行
  3. After throwing advice：方法抛异常后执行
  4. After (finally) advice：方法执行完finally之后执行，这是最后的，比return更后
  5. Around advice：这是功能最强大的Advice，可以自定义执行顺序

Spring-Aop提供

  1. MethodBeforeAdvice: 方法之前执行
  2. AfterReturningAdvice: 方法return后执行
  3. ThrowsAdvice: 方法抛出异常时执行

  4. MethodInterceptor: 这是功能最强大的Advice,可以自定义执行顺序

    Advisor的理解

    跟Advice类似的还有一个Advisor的概念,一个Advisor是有一个Pointcut和一个Advice组成的,通过Pointcut可以指定要需要被代理的逻辑,
    比如一个AService类中有两个方法,按照前面的例子,这两个方法都会被代理,被增强,那么我们现在可以通过Advisor,来控制到具体代理哪一个方法.

    @Test
public void advisor() {
 AService target = new AService();
 ProxyFactory proxyFactory = new ProxyFactory();
 proxyFactory.setTarget(target);
 proxyFactory.addAdvisor(new PointcutAdvisor() {
     @Override
     public Pointcut getPointcut() {
         return new StaticMethodMatcherPointcut() {
             @Override
             public boolean matches(Method method, Class<?> targetClass) {
                 return "test2".equals(method.getName());
             }
         };
     }
     @Override
     public Advice getAdvice() {
         return new org.aopalliance.intercept.MethodInterceptor() {
             @Nullable
             @Override
             public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
                 System.out.println("before....");
                 Object proceed = invocation.proceed();
                 System.out.println("after...");
                 return proceed;
             }
         };
     }
     @Override
     public boolean isPerInstance() {
         return false;
     }
 });
 AInterface aInterface = (AInterface) proxyFactory.getProxy();
 aInterface.test2();
}

    创建代理对象的方式

    上面介绍了Spring中所提供了ProxyFactory、Advisor、Advice、PointCut等技术来实现代理对象的创建,但是我们在使用Spring时,我们并不会直接这么去使用ProxyFactory,比如说我们希望ProxyFactory所产生的代理对象能直接就是Bean,能直接从Spring容器中得到UserSerivce的代理对象,而这些Spring都是支持的,只不过作为开发者的我们肯定得告诉Spring,哪些类需要被代理,代理逻辑是什么.
    通过这种方法来定义一个UserService的Bean,并且是经过了AOP的.但是这种方式只能针对某一个Bean,它是一个FactoryBean,所以利用的就是FactoryBean技术,间接的将UserService的代理对象作为了Bean

    ProxyFactoryBean

    @Bean
public ProxyFactoryBean userServiceProxy() {
 UserService userService = new UserService();
 ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
 proxyFactoryBean.setTarget(userService);
 proxyFactoryBean.addAdvice(new MethodInterceptor() {
     @Nullable
     @Override
     public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
         System.out.println("before...");
         Object proceed = invocation.proceed();
         System.out.println("after...");
         return proceed;
     }
 });
 return proxyFactoryBean;
}

    @Test
public void proxyFactoryBean() {
 AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
 UserService bean = (UserService) ctx.getBean("userServiceProxy");
 bean.test();
}

    ProxyFactoryBean还有额外的功能,比如可以把某个Advise或Advisor定义成为Bean,然后在ProxyFactoryBean中进行设置

    @Bean
public MethodInterceptor myAroundAdvise() {
 return new MethodInterceptor() {
     @Override
     public Object invoke(MethodInvocation invocation) throws Throwable {
         System.out.println("before...");
         Object proceed = invocation.proceed();
         System.out.println("after...");
         return proceed;
     }
 };
}
@Bean
public ProxyFactoryBean userServiceProxy() {
 UserService userService = new UserService();
 ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
 proxyFactoryBean.setTarget(userService);
 proxyFactoryBean.setInterceptorNames("myAroundAdvise");
 return proxyFactoryBean;
}

    @Test
public void proxyFactoryBean() {
 AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
 UserService bean = (UserService) ctx.getBean("userServiceProxy");
 bean.test();
}

    BeanNameAutoProxyCreator

    ProxyFactoryBean得自己指定被代理的对象,那么我们可以通过BeanNameAutoProxyCreator来通过指定某个bean的名字,来对该bean进行代理
    通过BeanNameAutoProxyCreator可以对批量的Bean进行AOP,并且指定了代理逻辑,指定了一个InterceptorName,也就是一个Advise,前提条件是这个Advise也得是一个Bean,这样Spring才能找到的,但是BeanNameAutoProxyCreator的缺点很明显,它只能根据beanName来指定想要代理的Bean

    @Bean
public MethodInterceptor myAroundAdvise() {
 return new MethodInterceptor() {
     @Override
     public Object invoke(MethodInvocation invocation) throws Throwable {
         System.out.println("before...");
         Object proceed = invocation.proceed();
         System.out.println("after...");
         return proceed;
     }
 };
}
@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
 BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
 beanNameAutoProxyCreator.setBeanNames("userSe*");
 beanNameAutoProxyCreator.setInterceptorNames("myAroundAdvise");
 beanNameAutoProxyCreator.setProxyTargetClass(true);
 return beanNameAutoProxyCreator;
}

    @Test
public void beanNameAutoProxyCreator() {
 AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
 UserService bean = (UserService) ctx.getBean("userService");
 bean.test();
}

    DefaultAdvisorAutoProxyCreator

    public class MyAfterReturningAdvise implements AfterReturningAdvice {
 @Override
 public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
     System.out.println("方法return后执行");
 }
}

    @Bean
public DefaultPointcutAdvisor defaultPointcutAdvisor(){
 NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
 pointcut.addMethodName("test");
 DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
 defaultPointcutAdvisor.setPointcut(pointcut);
 defaultPointcutAdvisor.setAdvice(new MyAfterReturningAdvise());
 return defaultPointcutAdvisor;
}
@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
 return new DefaultAdvisorAutoProxyCreator();
}

    @Test
public void defaultAdvisorAutoProxyCreator() {
 AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
 AInterface bean = (AInterface) ctx.getBean("AService");
 bean.test();
}

    通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean,根据Advisor中的PointCut和Advice信息,确定要代理的Bean以及代理逻辑。
    但是我们发现,通过这种方式,我们得依靠某一个类来实现定义我们的Advisor或者Advise或者Pointcut,那么这个步骤能不能更加简化一点呢?
    我们可以采用注解的方式进行,比如我们能不能只定义一个类,然后通过在类中的方法上通过某些注解,来定义PointCut以及Advice

    @Aspect
@Component
public class MyAspect {
 @Before("execution(public void linc.fun.service.UserService.test())")
 public void before(JoinPoint joinPoint) {
     System.out.println("MyAspect---Before");
 }
}

    @Test
public void aspect() {
 AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
 UserService bean = (UserService) ctx.getBean("userService");
 bean.test();
}

    通过上面这个类,我们就直接定义好了所要代理的方法(通过一个表达式)以及代理逻辑(被@Before修饰的方法),简单明了,这样对于Spring来说
    它要做的就是来解析这些注解了,解析之后得到对应的Pointcut对象、Advice对象,生成Advisor对象,扔进ProxyFactory中,进而产生对应的代理对象,具体怎么解析这些注解就是@EnableAspectJAutoProxy注解所要做的事情了

    对Spring AOP的理解

    OOP表示面向对象编程,是一种编程思想,AOP表示面向切面编程,也是一种编程思想,而我们上面所描述的就是Spring为了让程序员更加方便的做到面向切面编程所提供的技术支持,换句话说,就是Spring提供了一套机制,可以让我们更加容易的来进行AOP,所以这套机制我们也可以称之为Spring AOP.
    但是值得注意的是,上面所提供的注解的方式来定义Pointcut和Advice,Spring并不是首创,首创是AspectJ,而且也不仅仅只有Spring提供了一套机制来支持AOP,还有比如 JBoss 4.0,aspectwerkz等技术都提供了对于AOP的支持
    而刚刚说的注解的方式,Spring是依赖了AspectJ的,或者说Spring是直接把AspectJ中所定义的那些注解直接拿过来用,自己没有再重复定义了,不过也仅仅只是把注解的定义赋值过来了,每个注解具体底层是怎么解析的还是Spring自己做的,所以我们在用Spring时,如果你想用@Before、@Around等注解,是需要单独引入aspecj相关jar包的.
    值得注意的是: AspectJ是在编译时对字节码进行了修改,是直接在类对应的字节码中进行增强的,也就是可以理解为是在编译时就会去解析@Before这些注解,然后得到代理逻辑,加入到被代理的类中的字节码中去的,所以如果想用AspectJ技术来生成代理对象,是需要用单独的AspectJ编译器的.我们在项目中很少这么用,我们仅仅只是用了@Before这些注解,而我们在启动Spring的过程中,Spring会去解析这些注解,然后利用动态代理机制生成代理对象的

    AOP中的概念

    上面我们已经提到Advisor、Advice、PointCut等概念了,还有一些其他的概念,首先关于AOP中的概念本身是比较难理解的,Spring官网上是这么说的: AOP中的这些概念不是Spring特有的,不幸的是,AOP中的概念不是特别直观的,但是如果Spring重新定义自己的那可能会导致更加混乱

  5. Aspect：表示切面，比如被@Aspect注解的类就是切面，可以在切面中去定义Pointcut、Advice等等

  6. Join point：表示连接点，表示一个程序在执行过程中的一个点，比如一个方法的执行，比如一个异常的处理，在Spring AOP中，一个连接点通常表示一个方法的执行。
  7. Advice：表示通知，表示在一个特定连接点上所采取的动作。Advice分为不同的类型，后面详细讨论，在很多AOP框架中，包括Spring，会用Interceptor拦截器来实现Advice，并且在连接点周围维护一个Interceptor链
  8. Pointcut：表示切点，用来匹配一个或多个连接点，Advice与切点表达式是关联在一起的，Advice将会执行在和切点表达式所匹配的连接点上
  9. Introduction：可以使用@DeclareParents来给所匹配的类添加一个接口，并指定一个默认实现
  10. Target object：目标对象，被代理对象
  11. AOP proxy：表示代理工厂，用来创建代理对象的，在Spring Framework中，要么是JDK动态代理，要么是CGLIB代理

  12. Weaving：表示织入，表示创建代理对象的动作，这个动作可以发生在编译时期（比如Aspejctj），或者运行时，比如Spring AOP

    Advice在Spring AOP中对应API

    上面说到的Aspject中的注解,其中有五个是用来定义Advice的,表示代理逻辑,以及执行时机

  13. @Before

  14. @AfterReturning
  15. @AfterThrowing
  16. @After
  17. @Around

Spring自己也提供了类似的执行实际的实现类:

  1. 接口MethodBeforeAdvice，继承了接口BeforeAdvice
  2. 接口AfterReturningAdvice
  3. 接口ThrowsAdvice
  4. 接口AfterAdvice
  5. 接口MethodInterceptor

Spring会把五个注解解析为对应的Advice类:

  1. @Before：AspectJMethodBeforeAdvice，实际上就是一个MethodBeforeAdvice
  2. @AfterReturning：AspectJAfterReturningAdvice，实际上就是一个AfterReturningAdvice
  3. @AfterThrowing：AspectJAfterThrowingAdvice，实际上就是一个MethodInterceptor
  4. @After：AspectJAfterAdvice，实际上就是一个MethodInterceptor

  5. @Around：AspectJAroundAdvice，实际上就是一个MethodInterceptor

    TargetSource的使用

    在我们日常的AOP中,被代理对象就是Bean对象,是由BeanFactory给我们创建出来的,但是Spring AOP中提供了TargetSource机制,可以让我们用来自定义逻辑来创建被代理对象
    比如之前所提到的@Lazy注解,当加在属性上时,会产生一个代理对象赋值给这个属性,产生代理对象的代码,这段代码就利用了ProxyFactory来生成代理对象,以及使用了TargetSource,以达到代理对象在执行某个方法时,调用TargetSource的getTarget()方法实时得到一个被代理对象

    protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
 BeanFactory beanFactory = getBeanFactory();
 Assert.state(beanFactory instanceof DefaultListableBeanFactory,
         "BeanFactory needs to be a DefaultListableBeanFactory");
 final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;
 TargetSource ts = new TargetSource() {
     @Override
     public Class<?> getTargetClass() {
         return descriptor.getDependencyType();
     }
     @Override
     public boolean isStatic() {
         return false;
     }
     @Override
     public Object getTarget() {
         Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);
         Object target = dlbf.doResolveDependency(descriptor, beanName, autowiredBeanNames, null);
         if (target == null) {
             Class<?> type = getTargetClass();
             if (Map.class == type) {
                 return Collections.emptyMap();
             }
             else if (List.class == type) {
                 return Collections.emptyList();
             }
             else if (Set.class == type || Collection.class == type) {
                 return Collections.emptySet();
             }
             throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
                     "Optional dependency not present for lazy injection point");
         }
         if (autowiredBeanNames != null) {
             for (String autowiredBeanName : autowiredBeanNames) {
                 if (dlbf.containsBean(autowiredBeanName)) {
                     dlbf.registerDependentBean(autowiredBeanName, beanName);
                 }
             }
         }
         return target;
     }
     @Override
     public void releaseTarget(Object target) {
     }
 };
 ProxyFactory pf = new ProxyFactory();
 pf.setTargetSource(ts);
 Class<?> dependencyType = descriptor.getDependencyType();
 if (dependencyType.isInterface()) {
     pf.addInterface(dependencyType);
 }
 return pf.getProxy(dlbf.getBeanClassLoader());
}

    Introduction

    对于Introduction这个词,个人认为理解成引入是最合适的,其目标是对于一个已有的类引入新的接口
    有人可能会问,有什么用呢？
    简单的说,你可以把当前对象转型成另一个对象,那么很显然,你就可以调用另一个对象的方法了.
    假设已经有一个UserService类提供了保存User对象的服务,但是现在想增加对User进行验证的功能,只对通过验证的User提供保存服务,在不修改UserService类代码的前提下就可以通过Introduction来解决
    首先定义一个Verifier接口,里面定义了进行验证的方法validate()

    public interface Verifier {
 public boolean validate(User user);
}

    接下来给出该接口的一个实现类BasicVerifier

    public class BasicVerifier implements Verifier {
 @Override
 public boolean validate(User user) {
     if(user.getUsername().equals("jack") && user.getPassword().equals("1234")) {
         return true;
     }
     return false;
 }
}

    如何才能为UserService类增加验证User的功能呢

    @Aspect
@Component
public class MyAspect {
 @DeclareParents(value="linc.fun.service.UserService", 
         defaultImpl=com.tsinghuait.aop.BasicVerifier.class)
 public Verifier verifer;
}

    接下来就可以将UserService对象转型为Verifier对象并对用户进行验证了

     @Test
 public void introduction() {
     User user = new User();
     user.setUsername("abc");
     user.setPassword("def"); 
     AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
     UserService userService = (UserService) ctx.getBean("userService");
     Verifier v = (Verifier) s;
     if(v.validate(user) {
         System.out.println("验证成功");
         userService.save(user1);
     }

 }

    ProxyFactory选择cglib或jdk动态代理原理

    ProxyFactory在生成代理对象之前需要决定到底是使用JDK动态代理还是CGLIB技术
    DefaultAopProxyFactory#createAopProxy

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
 // 如果ProxyFactory的isOptimize为true，Spring认为cglib比jdk动态代理要快
 // 或者isProxyTargetClass为true，
 // 或者被代理对象没有实现接口，
 // 或者只实现了SpringProxy这个接口
 // 那么则利用Cglib进行动态代理，但如果被代理类是接口，或者被代理类已经是进行过JDK动态代理而生成的代理类了则只能进行JDK动态代理
 // 其他情况都会进行JDK动态代理，比如被代理类实现了除SpringProxy接口之外的其他接口
 // 是不是在GraalVM虚拟机上运行
 if (!NativeDetector.inNativeImage() &&
         // isOptimize：以前的cglib效率比较高 开启这个会选择cglib
         // optimize为true,或proxyTargetClass为true,或用户没有给ProxyFactory对象添加interface
         (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
     // targetClass是接口，直接使用Jdk动态代理
     Class<?> targetClass = config.getTargetClass();
     if (targetClass == null) {
         throw new AopConfigException("TargetSource cannot determine target class: " +
                 "Either an interface or a target is required for proxy creation.");
     }
     if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
         return new JdkDynamicAopProxy(config);
     }
     return new ObjenesisCglibAopProxy(config);
 }
 else {
     return new JdkDynamicAopProxy(config);
 }
}

    如果ProxyFactory的isOptimize为true,Spring认为cglib比jdk动态代理要快,或者isProxyTargetClass为true,或者被代理对象没有实现接口，
    或者只实现了SpringProxy这个接口, 那么则利用Cglib进行动态代理，
    但如果被代理类是接口,或者被代理类已经是进行过JDK动态代理而生成的代理类了则只能进行JDK动态代理
    其他情况都会进行JDK动态代理,比如被代理类实现了除SpringProxy接口之外的其他接口

    代理对象创建过程

    JdkDynamicAopProxy

    public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
 Assert.notNull(config, "AdvisedSupport must not be null");
 if (config.getAdvisorCount() == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
     throw new AopConfigException("No advisors and no TargetSource specified");
 }
 this.advised = config;
 // 设置JDK动态代理所要代理的接口
 this.proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
 findDefinedEqualsAndHashCodeMethods(this.proxiedInterfaces);
}

    static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised, boolean decoratingProxy) {
 // 被代理对象自己所实现的接口
 Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
 // 如果被代理对象没有实现接口，则判断被代理类是不是接口，或者被代理类是不是已经经过JDK动态代理之后的类从而获取想对应的接口
 if (specifiedInterfaces.length == 0) {
     // No user-specified interfaces: check whether target class is an interface.
     Class<?> targetClass = advised.getTargetClass();
     if (targetClass != null) {
         if (targetClass.isInterface()) {
             advised.setInterfaces(targetClass);
         }
         else if (Proxy.isProxyClass(targetClass)) {
             advised.setInterfaces(targetClass.getInterfaces());
         }
         specifiedInterfaces = advised.getProxiedInterfaces();
     }
 }
 // 添加三个Spring内置接口：SpringProxy、Advised、DecoratingProxy
 List<Class<?>> proxiedInterfaces = new ArrayList<>(specifiedInterfaces.length + 3);
 for (Class<?> ifc : specifiedInterfaces) {
     // Only non-sealed interfaces are actually eligible for JDK proxying (on JDK 17)
     if (isSealedMethod == null || Boolean.FALSE.equals(ReflectionUtils.invokeMethod(isSealedMethod, ifc))) {
         proxiedInterfaces.add(ifc);
     }
 }
 if (!advised.isInterfaceProxied(SpringProxy.class)) {
     proxiedInterfaces.add(SpringProxy.class);
 }
 if (!advised.isOpaque() && !advised.isInterfaceProxied(Advised.class)) {
     proxiedInterfaces.add(Advised.class);
 }
 if (decoratingProxy && !advised.isInterfaceProxied(DecoratingProxy.class)) {
     proxiedInterfaces.add(DecoratingProxy.class);
 }
 return ClassUtils.toClassArray(proxiedInterfaces);
}

    private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) {
 // 判断被代理的接口中是否定义了equals()、hashCode()方法，如果程序员在接口中手动定义了这两个方法，则也会进行代理
 // 否则这两个方法是不会走代理逻辑的
 for (Class<?> proxiedInterface : proxiedInterfaces) {
     Method[] methods = proxiedInterface.getDeclaredMethods();
     for (Method method : methods) {
         if (AopUtils.isEqualsMethod(method)) {
             this.equalsDefined = true;
         }
         if (AopUtils.isHashCodeMethod(method)) {
             this.hashCodeDefined = true;
         }
         if (this.equalsDefined && this.hashCodeDefined) {
             return;
         }
     }
 }
}

  6. 在构造JdkDynamicAopProxy对象时,会先拿到被代理对象自己所实现的接口,并且额外的增加SpringProxy、Advised、DecoratingProxy三个接口,组合成一个Class[],并赋值给proxiedInterfaces属性

  7. 并且检查这些接口中是否定义了equals()、hashcode()方法

  8. 执行Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this),得到代理对象,dkDynamicAopProxy作为InvocationHandler,代理对象在执行某个方法时,会进入到JdkDynamicAopProxy的invoke方法中

    ObjenesisCglibAopProxy

  9. 创建Enhancer对象

  10. 设置Enhancer的superClass为通过ProxyFactory.setTarget()所设置的对象的类
  11. 设置Enhancer的interfaces为通过ProxyFactory.addInterface()所添加的接口,以及SpringProxy、Advised、DecoratingProxy接口
  12. 设置Enhancer的Callbacks为DynamicAdvisedInterceptor

  13. 最后创建一个代理对象,代理对象在执行某个方法时,会进入到DynamicAdvisedInterceptor的intercept()方法中

    代理对象执行过程

  14. 在使用ProxyFactory创建代理对象之前,需要往ProxyFactory先添加Advisor

  15. 代理对象在执行某个方法时,会把ProxyFactory中的Advisor拿出来和当前正在执行的方法进行匹配筛选
  16. 把和方法所匹配的Advisor适配成MethodInterceptor
  17. 把和当前方法匹配的MethodInterceptor链,以及被代理对象、代理对象、代理类、当前Method对象、方法参数封装为MethodInvocation对象
  18. 调用MethodInvocation的proceed()方法,开始执行各个MethodInterceptor以及被代理对象的对应方法
  19. 按顺序调用每个MethodInterceptor的invoke()方法,并且会把MethodInvocation对象传入invoke()方法
  20. 直到执行完最后一个MethodInterceptor了,就会调用invokeJoinpoint()方法,从而执行被代理对象的当前方法

    各注解对应的MethodInterceptor

  • @Before对应的是AspectJMethodBeforeAdvice,在进行动态代理时会把AspectJMethodBeforeAdvice转成MethodBeforeAdviceInterceptor
    • 先执行advice对应的方法
    • 再执行MethodInvocation的proceed(),会执行下一个Interceptor,如果没有下一个Interceptor了,会执行target对应的方法
  • @After对应的是AspectJAfterAdvice,直接实现了MethodInterceptor
    • 直接执行advice对应的方法,由@Around自己决定要不要继续往后面调用
  • @Around对应的是AspectJAroundAdvice,直接实现了MethodInterceptor
    • 直接执行advice对应的方法,由@Around自己决定要不要继续往后面调用
  • @AfterThrowing对应的是AspectJAfterThrowingAdvice,直接实现了MethodInterceptor
    • 先执行MethodInvocation的proceed(),会执行下一个Interceptor,如果没有下一个Interceptor了,会执行target对应的方法
    • 如果上面抛了Throwable,那么则会执行advice对应的方法
  • @AfterReturning对应的是AspectJAfterReturningAdvice,在进行动态代理时会把AspectJAfterReturningAdvice转成AfterReturningAdviceInterceptor
    • 先执行MethodInvocation的proceed(),会执行下一个Interceptor,如果没有下一个Interceptor了,会执行target对应的方法
    • 执行上面的方法后得到最终的方法的返回值
    • 再执行Advice对应的方法

      AbstractAdvisorAutoProxyCreator

      DefaultAdvisorAutoProxyCreator的父类是AbstractAdvisorAutoProxyCreator
      AbstractAdvisorAutoProxyCreator非常强大以及重要,只要Spring容器中存在这个类型的Bean,就相当于开启了AOP
      AbstractAdvisorAutoProxyCreator实际上就是一个BeanPostProcessor,所以在创建某个Bean时,就会进入到它对应的生命周期方法中,比如：在某个Bean初始化之后,会调用wrapIfNecessary()方法进行AOP.
      底层逻辑是:
      AbstractAdvisorAutoProxyCreator会找到所有的Advisor,然后判断当前这个Bean是否存在某个Advisor与之匹配(根据Pointcut),
      如果匹配就表示当前这个Bean有对应的切面逻辑，需要进行AOP，需要产生一个代理对象。

      @EnableAspectJAutoProxy

      这个注解主要就是往Spring容器中添加了一个AnnotationAwareAspectJAutoProxyCreator类型的Bean
      Spring之AOP底层源码解析 - 图1
      AspectJAwareAdvisorAutoProxyCreator继承了AbstractAdvisorAutoProxyCreator,重写了findCandidateAdvisors()方法,AbstractAdvisorAutoProxyCreator只能找到所有Advisor类型的Bean对象,但是AspectJAwareAdvisorAutoProxyCreator除开可以找到所有Advisor类型的Bean对象,还能把@Aspect注解所标注的Bean中的@Before等注解及方法进行解析，并生成对应的Advisor对象
      所以,我们可以理解@EnableAspectJAutoProxy,其实就是像Spring容器中添加了一个AbstractAdvisorAutoProxyCreator类型的Bean,从而开启了AOP,并且还会解析@Before等注解生成Advisor

      Spring中AOP底层原理

      Spring之AOP底层源码解析 - 图2