[Java知识库]Spring之Aop底层剖析（上）

Spring之Aop底层源码剖析（上）

随着笔者变得越来越懒【好久没有更新博文了】，已经抽不住来时间去单独针对某些技术点去单独记录或者长编大论的分析，因为博文还是短点才能让读者从心里上愿意去看。

一、Aop的应用

动态代理

代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。

比如，现在存在一个ItemService类：

@Component
public class ItemService{
public  void  testAop(){
    
     System.out.println("testAop");

	}
}

此时，我们new一个ItemService对象，然后执行testAop（）方法，结果是显而易见的。

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

1.1 使用Cglib代理方式

		Enhancer enhancer = new Enhancer();

		ItemService target = new ItemService();

		enhancer.setSuperclass(ItemService.class);
        // 定义代理逻辑
		enhancer.setCallback(new MethodInterceptor() {
			@Override
			public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
              // o 是代理对象
				System.out.println("cglib");
			    // 一共有四种写法,第三种会出现栈溢出
				//Object o1 = method.invoke(target, objects);
				// Object o1 = method.invoke(o, objects);
				// Object o1 = methodProxy.invoke(target, objects);
				Object o1 = methodProxy.invokeSuper(o, objects);
				return o1;
			}
		});
        // 动态代理所创建出来的itemService对象
		Object o = enhancer.create();
		return o;
        // 执行这个itemService的test方法时，就会额外会执行一些其他逻辑
		ItemService itemService = (ItemService) CglibUtil.getProxy();
		itemService.test();

结果如下：

得到的都是itemService对象，但是执行testAop()方法时的效果却不一样了，这就是代理所带来的效果。

上面是通过cglib来实现的代理对象的创建，是基于父子类的，被代理类（ItemService）是父类，代理类是子类，代理对象就是代理类的实例对象，代理类是由cglib创建的，对于程序员来说不用关心。
?

那么使用上述cglib代理可以发现一个问题，如果目标类中有多个方法，那么产生的代理对象会对被代理对象的所有方法都进行代理。比如，我们只想对目标对象中的某些方法进行不同代理的话，该怎么办呢？我们还可以继续改造，比如：

         Enhancer enhancer = new Enhancer();
		enhancer.setSuperclass(ItemService.class);
		enhancer.setUseFactory(false);
         // 传递一个数组，存放我们多个代理逻辑
	    enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
			@Override
			public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
				System.out.println("cglib----before");
				//Object o1 = methodProxy.invokeSuper(o, objects);
				Object o1 = methodProxy.invokeSuper(o, objects);
				System.out.println("cglib----after");
                return o1;
			}
		},NoOp.INSTANCE});
        // 设置一个拦截器 针对程序员想要的需求 去做针性代理
	    enhancer.setCallbackFilter(new CallbackFilter() {
			@Override
			public int accept(Method method) {
                // 对目标方法是test的 才代理
				if(method.getName().equals("test")){
					return 0;
				}
                // 目标方法为其它的不代理
				return 1;
			}
		});
		Object o = enhancer.create();
		return o;

1.2 使用Jdk代理方式

除开cglib技术，jdk本身也提供了一种创建代理对象的动态代理机制，但是它只能代理接口，也就是itemService得先有一个接口才能利用jdk动态代理机制来生成一个代理对象，比如：

public interface ItemServices {

	public  void  testAop();

	public  void  test();


	public  int  index();
}

public class ItemService implements  ItemServices{

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

		System.out.println("test");

	}
	@Override
	public int index() {
		return 0;
	}

}

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

        
         ItemService target =new ItemService();

         // ItemServices接口的代理对象 注意这里面一定是一个接口类型 因为你是对接口进行代理，而不能用某个实现这个接口的实现类。因为未来实现这个接口的可能有很多类型的实现类。不一定一定是ItemServices类型。
		ItemServices itemServices = (ItemServices) Proxy.newProxyInstance(JdkUtil.class.getClassLoader(), new Class[]{ItemServices.class}, new InvocationHandler() {
			@Override
			public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
				System.out.println("jdk  before");
				Object invoke = method.invoke(target, objects);
				System.out.println("jdk  after");
				return invoke;
			}
		});


		return itemServices;

		ItemServices proxy = JdkUtil.getProxy();
		proxy.test();

如果你把new Class[]{ItemServices.class}，替换成new Class[]{ItemService.class}，允许代码会直接报错：

Exception in thread “main” java.lang.IllegalArgumentException: com.hzk.test.CircleService.Aop.service.ItemService is not an interface

表示一定要是个接口。

由于这个限制，所以产生的代理对象的类型是ItemServices，而不是ItemService，这是需要注意的。

1.3 ProxyFactory

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

	    ItemService target = new ItemService();

		ProxyFactory proxyFactory = new ProxyFactory();
        
        // 被代理对象
		proxyFactory.setTarget(target);
        //设置接口 代理模式采用jdk动态代理 
        //proxyFactory.setInterfaces(ItemServices.class);
        // 代理逻辑
        proxyFactory.addAdvice(new MethodBeforeAdvice() {
			@Override
			public void before(Method method, Object[] args, Object target) throws Throwable {
				System.out.println("before-----");
			}
		});
         //生成代理对象
         ItemService itemService = (ItemService) proxyFactory.getProxy();
		itemService.test();

测试结果如下：

通过ProxyFactory，我们可以不再关系到底是用cglib还是jdk动态代理了，ProxyFactory会帮我们去判断，如果ItemService实现了接口，那么ProxyFactory底层就会用jdk动态代理，如果没有实现接口，就会用cglib技术，上面的代码，就是由于ItemService没有实现了ItemServices接口，所以最后产生的代理对象是ItemService类型。

打开 //proxyFactory.setInterfaces(ItemServices.class);注释

Advice的分类

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

Advisor的理解

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

 proxyFactory.addAdvisor(new PointcutAdvisor() {
		  @Override
		  public Pointcut getPointcut() {
			  return new StaticMethodMatcherPointcut() {
				  @Override
				  public boolean matches(Method method, Class<?> targetClass) {
					if(method.getName().equals("test")){
						return true;
					}
				  	return false;
				  }
			  };
		  }

	  @Override
		  public Advice getAdvice() {
			  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;
				  }
			  };
		  }

		  @Override
		  public boolean isPerInstance() {
			  return false;
		  }
	  });

上面代码表示，产生的代理对象，只有在执行test这个方法时才会被增强，会执行额外的逻辑，而在执行其他方法时是不会增强的。

创建代理对象的方式

上面介绍了Spring中所提供了ProxyFactory、Advisor、Advice、PointCut等技术来实现代理对象的创建，但是我们在使用Spring时，我们并不会直接这么去使用ProxyFactory，比如说，我们希望ProxyFactory所产生的代理对象能直接就是Bean，能直接从Spring容器中得到UserSerivce的代理对象，而这些，Spring都是支持的，只不过，作为开发者的我们肯定得告诉Spring，那些类需要被代理，代理逻辑是什么。

2.1 ProxyFactoryBean

	@Bean
	public  ProxyFactoryBean itemService(){

		ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
		proxyFactoryBean.setTarget(new ItemService());
	    proxyFactoryBean.addAdvice(new HzkBeforeAdvice());
		return proxyFactoryBean;
	}
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
		System.out.println(context.getBean("itemService"));

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

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

@Bean
public MethodInterceptor hzkAroundAdvise(){
 return new MethodInterceptor() {
  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {
			System.out.println("before...");
   Object result = invocation.proceed();
			System.out.println("after...");
   return result;
		}
	};
}

@Bean
public ProxyFactoryBean itemService(){
     ItemService itemService = new ItemService();
     ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
	 proxyFactoryBean.setTarget(itemService);
	 proxyFactoryBean.setInterceptorNames("hzkAroundAdvise");
     return proxyFactoryBean;
}

2.2 BeanNameAutoProxyCreator

ProxyFactoryBean得自己指定被代理的对象，那么我们可以通过BeanNameAutoProxyCreator来通过指定某个bean的名字，来对该bean进行代理

	@Bean
	public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
		BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
		beanNameAutoProxyCreator.setBeanNames("itemSer*");
		beanNameAutoProxyCreator.setInterceptorNames("hzkBeforeAdvice");
		return beanNameAutoProxyCreator;
	}

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

2.3 DefaultAdvisorAutoProxyCreator

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

		DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
		defaultPointcutAdvisor.setPointcut(pointcut);
		defaultPointcutAdvisor.setAdvice(new HzkBeforeAdvice());

		return defaultPointcutAdvisor;
	}

	// 在某个Bean在创建过程中的初始化后DefaultAdvisorAutoProxyCreator后置处理器里面 会把所有Advisor的bean全部找出来 然后在和我当前创建的这个bean
	//匹配 看有没有一个方法是test的 然后执行代理逻辑
	@Bean
	public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {

		DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();

		return defaultAdvisorAutoProxyCreator;
	}

通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean，根据Advisor中的PointCut和Advice信息，确定要代理的Bean以及代理逻辑。

由于这个是后置器帮我们实现的，因此多有的bean走自己的生命周期的时候，都会执行这个后置处理器的逻辑。完成代理

但是，我们发现，通过这种方式，我们得依靠某一个类来实现定义我们的Advisor，或者Advise，或者Pointcut，那么这个步骤能不能更加简化一点呢？
?

对的，通过注解！

比如我们能不能只定义一个类，然后通过在类中的方法上通过某些注解，来定义PointCut以及Advice，可以的，比如：

@Aspect
@Component
public class HzkAop {
@Before("execution(  * com.hzk.test.CircleService.Aop.ItemService.*(..))")
	public  void  hzkBefore(){
		System.out.println("tx-----");
}
}

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

【这个注解也可以使用 @Import(AnnotationAwareAspectJAutoProxyCreator.class)】

二、AOP中的概念

上面我们已经提到Advisor、Advice、PointCut等概念了，还有一些其他的概念，首先关于AOP中的概念本身是比较难理解的，Spring官网上是这么说的：

Let us begin by defining some central AOP concepts and terminology. These terms are not Spring-specific. Unfortunately, AOP terminology is not particularly intuitive. However, it would be even more confusing if Spring used its own terminology

意思是，AOP中的这些概念不是Spring特有的，不幸的是，AOP中的概念不是特别直观的，但是，如果Spring重新定义自己的那可能会导致更加混乱

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

Advice在Spring AOP中对应API

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

1. @Before
2. @AfterReturning
3. @AfterThrowing
4. @After
5. @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

6. 接口AfterReturningAdvice

7. 接口ThrowsAdvice

8. 接口AfterAdvice

9. 接口MethodInterceptor

这篇博文你可以学到创建代理的几种方式以及SpringAop和Aspect的区别在哪【这两个概念一定要搞清】，在下章会结合源码进行深入分析。