Spring AOP源码解析(上)

最新推荐文章于 2023-06-05 16:57:07 发布

sermonlizhi

最新推荐文章于 2023-06-05 16:57:07 发布

阅读量432

点赞数 1

分类专栏： Spring的那些事儿文章标签： spring java aop

本文链接：https://blog.csdn.net/sermonlizhi/article/details/121860990

版权

Spring的那些事儿专栏收录该内容

24 篇文章 8 订阅

订阅专栏

一、动态代理

Spring AOP技术底层采用动态代理来实现，其中Java本身提供了JDK的动态，而Spring提供了CGLIB的的动态，下面简单介绍一下这种动态代理的使用。

1.1 JDK动态代理

public interface OrderInterface {

   void test();
}

public class OrderService implements OrderInterface {

	@Override
	public void test(){
		System.out.println("orderService");
	}

}

通过JDK的动态代理生成代理对象时，需要指定一个接口，所以生成的代理对象也是接口类型的对象，被代理对象需要实现接口的方法，然后在调用代理对象的方法时，会进入到InvocationHandler的invoke()方法，执行一些额外添加的逻辑，然后调用method对象的invoke()方法，第一个参数需要指定被代理对象，这样，就可以在可以调用到被代理对象的方法

OrderService orderService = new OrderService();

OrderInterface orderInterface = (OrderInterface) Proxy.newProxyInstance(orderService.getClass().getClassLoader(), new Class[]{OrderInterface.class}, new InvocationHandler() {
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println("before");
      method.invoke(orderService,args);
      return null;
   }
});

orderInterface.test();

1.2 CGLIB的动态代理

public class OrderService{
   
   public void test(){
      System.out.println("orderService");
   }

}

CGLIB通过Enhancer来创建一个代理类，首先需要指定代理类的父类，然后添加一个方法拦截器，在intercept()方法中，使用方法同JDK的动态代理，但相比invoke()方法，intercept()方法多了一个methodProxy对象，下面代码中展示的三种方法调用，效果都是一样。

如果在method的invoke()方法里面第一个参数给的是proxy代理对象，将会导致循环调用，但是通过methodProxy的invokeSuper()就可以直接调用到被代理类的方法

OrderService orderService = new OrderService();

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(OrderService.class);

enhancer.setCallback(new MethodInterceptor() {
    @Override
    public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before");
        method.invoke(orderService,objects);
        methodProxy.invoke(orderService,objects);
        methodProxy.invokeSuper(proxy,objects);
        return null;
    }
});

OrderService orderService1 = (OrderService) enhancer.create();
orderService1.test();

注：JDK和CGLIB的动态代理，最大的区别在于，JDK生成代理对象时，需要指定接口，生成的代理对象也是接口类型。而CGLIB通过父子类来生成代理对象，CGLIB会生成一个被代理类的子类作为代理类，然后通过子类进行实例化得到代理对象

1.3 Spring的动态代理

1.3.1 AOP中的Advice

在Spring中，将上面两种动态代理的方式进行了封装，封装出来的类叫做ProxyFactory，表示一个创建代理类的工厂，开发人员不需要再去关注使用哪种方式来进行动态代理，ProxyFactory会根据被代理类是否实现了接口来动态选择代理方式

以下面代码为例，如果被代理对象实现了接口，那么ProxyFactory就会使用JDK的动态代理，如果没有实现接口，就是使用CGLIB的动态代理

OrderService orderService = new OrderService();

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(orderService);
proxyFactory.addAdvice(new MethodInterceptor() {
   @Override
   public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
      System.out.println("before");
      Object proceed = invocation.proceed();
      return proceed;
   }
});
OrderService proxy = (OrderService) proxyFactory.getProxy();
proxy.test();

在下面定义的两个Advice方法中，只需要编写方法中自定义的逻辑，无需去手动调用原始对象的方法，Spring会自动调用，开发人员只需要关注额外添加的逻辑即可

//方法执行前执行
proxyFactory.addAdvice(new MethodBeforeAdvice() {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("before");
    }
});

//方法返回后执行
proxyFactory.addAdvice(new AfterReturningAdvice() {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("after return");
    }
});

Advice的分类：

BeforeAdvice：方法之前执行
AfterReturnningAdvice：方法return后执行
After ThrowsAdvice：方法抛出异常后执行
After Advice：最后执行，比return更后执行
Around Advice：这是功能最强大的Advice，可以自定义执行顺序

1.3.2 Advisor的概念

与Advice类似的还有一个Advisor的概念，一个Advisor由一个Pointcut和一个Advice组成。Pointcut用于定义匹配逻辑，只有与Pointcut中逻辑匹配的方法，才能执行Advice中增强的代码

以下面的例子为例，OrderService有两个方法，但定义了一个Advisor，它的getPointcut()方法中，定义了只有与"order"相等的方法名才能进行增强，如果此时再次调用test()方法，则不会输出"before"，调用order()方法时，会先输出"before"

public class OrderService{

	public void test(){
		System.out.println("orderService");
	}

	public void order(){
		System.out.println("order");
	}
}

OrderService orderService = new OrderService();

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(orderService);
proxyFactory.addAdvisor(new PointcutAdvisor() {
    @Override
    public Pointcut getPointcut() {
        // 定义匹配逻辑,只有方法名为order,才能执行下面Advice的逻辑
        return new StaticMethodMatcherPointcut() {
            @Override
            public boolean matches(Method method, Class<?> targetClass) {
                return method.getName().equals("order");
            }
        };
    }

    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Nullable
            @Override
            public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
                System.out.println("before");
                Object proceed = invocation.proceed();
                return proceed;
            }
        };
    }
    @Override
    public boolean isPerInstance() {
        return false;
    }
});
OrderService proxy = (OrderService) proxyFactory.getProxy();
proxy.order();

二、Spring创建代理对象

上面介绍了Spring中提供了ProxyFactory、Advisor、Advice、Pointcut等技术来实现代理对象的创建，但是我们在使用Spring时并不会直接使用ProxyFactory来创建代理对象，我们更希望创建出来的代理对象是一个Bean实例，使用的时候可以直接从Spring容器中获取

由Spring来将代理对象生成Bean实例，需要指定哪些类需要被代理，以及代理逻辑是什么

2.1 ProxyFactoryBean

可以通过这种方式来定义一个UserService的Bean，并且是经过了AOP的。但这种方式的只能针对某一个Bean。它是一个FactoryBean，利用的就是FactoryBean的技术，间接的将UserService的代理对象当作Bean

@Bean
ProxyFactoryBean proxyFactoryBean(){
   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");
         invocation.proceed();
         return null;
      }
   });
   return proxyFactoryBean;
}

ProxyFactoryBean还提供了其他的功能，比如可以把某个Advice或Advisor定义成Bean，然后在ProxyFactoryBean中设置

@Bean
MethodInterceptor lizhiBeforeAdvice(){
   return new MethodInterceptor() {
      @Nullable
      @Override
      public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
         System.out.println("before");
         invocation.proceed();
         return null;
      }
   };
}

@Bean
ProxyFactoryBean proxyFactoryBean(){
   UserService userService = new UserService();
   ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
   proxyFactoryBean.setTarget(userService);
   proxyFactoryBean.setInterceptorNames("lizhiBeforeAdvice");
   return proxyFactoryBean;
}

2.2 BeanNameAutoProxyCreator

我们可以通过BeanNameAutoProxyCreator来通过指定某个bean的名字，来对该bean进行代理。BeanNameAutoProxyCreator是一个BeanPostProcessor，所以可以对Bean进行增强，通过指定BeanName的来对匹配的Bean进行增强，进行AOP

@Bean
MethodInterceptor lizhiBeforeAdvice(){
   return new MethodInterceptor() {
      @Nullable
      @Override
      public Object invoke(@NotNull MethodInvocation invocation) throws Throwable {
         System.out.println("before");
         invocation.proceed();
         return null;
      }
   };
}

@Bean
BeanNameAutoProxyCreator beanNameAutoProxyCreator(){
   BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
   beanNameAutoProxyCreator.setBeanNames("user*");
   beanNameAutoProxyCreator.setInterceptorNames("lizhiBeforeAdvice");
   beanNameAutoProxyCreator.setProxyTargetClass(true);
   return beanNameAutoProxyCreator;
}

通过BeanNameAutoProxyCreator可以对批量的Bean进行AOP，并且指定了代理逻辑，指定了一个InterceptorName，也就是一个Advise，前提条件是这个Advise也得是一个Bean，这样Spring才能找到的，但是BeanNameAutoProxyCreator的缺点很明显，它只能根据beanName来指定想要代理的Bean。

2.3 DefaultAdvisorAutoProxyCreator

DefaultAdvisorAutoProxyCreator也是一个BeanPostProcessor，在该类创建Bean实例的初始化后时，会直接去找所有Advisor类型的Bean，根据Advisor中的PointCut和Advice信息，确定要代理的Bean以及代理逻辑。

public class LizhiBeforeAdvice implements MethodBeforeAdvice {
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("before");
	}
}

@Bean
DefaultPointcutAdvisor defaultPointcutAdvisor(){
   NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
   pointcut.addMethodName("test");

   DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
   advisor.setPointcut(pointcut);
   advisor.setAdvice(new LizhiBeforeAdvice());
   return advisor;
}

@Bean
DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
   DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
   return defaultAdvisorAutoProxyCreator;
}

但是，通过这种方式，我们得依靠某一个类来实现定义我们的Advisor，或者Advise，或者Pointcut，而通过注解的方式，可以在同一个类里面，去定义Pointcut和Advice

@Aspect
@Component
public class LizhiAspect {

    @Before("execution(public void com.lizhi.service.UserService.test())")
    public void lizhiBefore(JoinPoint joinPoint) {
        System.out.println("lizhiBefore");
    }

    @AfterReturning("execution(public void com.lizhi.service.UserService.test())")
    public void lizhiAfterReturnning(JoinPoint joinPoint){
        System.out.println("lizhiAfterReturnning");
    }

    @After("execution(public void com.lizhi.service.UserService.test())")
    public void lizhiAfter(JoinPoint joinPoint){
        System.out.println("lizhiAfter");
    }


}

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

@EnableAspectJAutoProxy注解就通过@Import来加载DefaultAdvisorAutoProxyCreator类成为一个Bean实例

三、对Spring AOP的理解

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是在编译时对字节码进行了修改，是直接在UserService类对应的字节码中进行增强的，也就是可以理解为是在编译时就会去解析@Before这些注解，然后得到代理逻辑，加入到被代理的类中的字节码中去的，所以如果想用AspectJ技术来生成代理对象，是需要用单独的AspectJ编译器的。我们在项目中很少这么用，我们仅仅只是用了@Before这些注解，而我们在启动Spring的过程中，Spring会去解析这些注解，然后利用动态代理机制生成代理对象的。

3.1 AOP中的概念

Aspect：表示切面，比如被@Aspect注解的类就是一个切面，可以在切面中去定义Pointcut、Advice等等
Join point：表示连接点，表示一个程序在执行过程中的一个点，比如一个方法的执行或者一个异常的处理，在Spring AOP中，一个连接点通常表示一个方法的执行，每个连接点对应一个Advice
Advice：表示通知，表示一个连接点上所采取的动作，Advice分为不同的类型，在许多AOP框架，包括Spring，通常用interceptor拦截器来实现Advice，并且在连接点周围维护一个interceptor链
Pointcut：表示切点，用来匹配一个或多个连接点，Advice和切点表达式是关联在一起的，Advice将会执行在与切点匹配的连接点上

Introduction：可以使用@DeclareParents来给所匹配的类添加一个接口，并指定一个默认实现

@DeclareParents(value = "com.zhouyu.service.UserService", defaultImpl = UserImplement.class)
private UserInterface userInterface;

Target object：目标对象，被代理对象
AOP proxy：表示代理工厂，用来创建代理对象的，在Spring Framework中，要么是JDK动态代理，要么是CGLIB代理
Weaving：表示织入，表示创建代理对象的动作，这个动作可以发生在编译时期（比如Aspejctj），或者运行时，比如Spring AOP

3.2 Advice在Spring AOP中对应的API

Spring也提供了类似的实际执行的实现类：

接口MethodBeforeAdvice，继承了接口BeforeAdvice
接口AfterReturningAdvice
接口ThrowAdvice
接口AfterAdvice
接口MethodInterceptor

上面说到的Aspect中的注解，其中有五个是用来定义Advice的，表示代理逻辑，以及执行时机，Spring提供了把这些注解解析为对应的Advice的能力

@Before：AspectJMethodBeforeAdvice，实际上就是一个MethodBeforeAdvice
@AfterReturnning：AspectJAfterReturningAdvice，实际上就是一个AfterReturningAdvice
@AfterThrowing：AspectJAfterThrowingAdvice，实际上就是一个MethodInterceptor
@After：AspectJAfterAdvice，实际上就是一个MethodInterceptor
@Around：AspectJAroundAdvice，实际上就是一个MethodInterceptor

3.3 TargetSource的使用

Spring通过ProxyFactroy创建代理对象时，需要指定一个原始对象，但在ProxyFactory中，并不是直接保存原始对象，而是保存了一个TargetSource对象，直接调用setTarget()方法，也会把原始对象包装成一个TargetSource对象

public void setTarget(Object target) {
   setTargetSource(new SingletonTargetSource(target));
}

那么使用TargetSource有什么好处呢？最大的用处就是可以自行指定生成原始对象的逻辑，下面以@Lazy注解为例，在属性注入时，如果属性有@Lazy注解，会产生一个代理对象作为属性值，在调用代理对象的方法时，才会调用原始对象的方法

下面是为@Lazy注解的属性生成一个代理对象，在TargetSource接口的getTarget()方法中，指定了获取原始对象的方法，@Lazy注解获取原始对象通过doResolveDependency()方法解析查找满足条件的Bean实例，该方法是属性注入的核心方法

在调用代理对象的方法时，会通过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());
}

sermonlizhi

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring AOP源码解析(上)

一、动态代理Spring AOP技术底层采用动态代理来实现，其中Java本身提供了JDK的动态，而Spring提供了CGLIB的的动态，下面简单介绍一下这种动态代理的使用。1.1 JDK动态代理public interface OrderInterface { void test();}public class OrderService implements OrderInterface { @Override public void test(){ System.out.pr
复制链接

扫一扫