Spring aop 源码（上）

动态代理

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

CGLIB动态代理

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

public class UserService  {

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

}

此时，我们new一个UserService对象，然后执行test()方法，结果是显而易见的。

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

UserService target = new UserService();

// 通过cglib技术
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);

// 定义额外逻辑，也就是代理逻辑
enhancer.setCallbacks(new Callback[]{new MethodInterceptor() {
	@Override
    // 这个o是代理对象，不是target要被代理的那个对象噢 也就是下面的userService
	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
		System.out.println("before...");
		Object result = methodProxy.invoke(target, objects);
		System.out.println("after...");
		return result;
	}
}});

// 动态代理所创建出来的UserService对象
UserService userService = (UserService) enhancer.create();

// 执行这个userService的test方法时，就会额外会执行一些其他逻辑
userService.test();

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

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

spring底层把cglib的源码copy了一份，自身使用，所以就不用关心版本问题。

可以通过设置CallbackFilter指定执行哪个方法的时候用下标为哪个的拦截器，比如这里test方法执行的就是下标为0的拦截器也就是MethodInterceptor，其他方法执行下标为1的拦截器，也就是INSTANCE【不过这个拦截器是空的无操作所以叫 NoOp啥也没实现】

JDK动态代理

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

public interface UserInterface {
	public void test();
}

public class UserService implements UserInterface {

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

}

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

注意！！！最后产生出来代理对象的类型是接口类型！！！

UserService target = new UserService();

// UserInterface接口的代理对象 用UserInterface接收也可以 就是不能用UserService接收
// 产生的代理对象只是个借口类型
Object proxy = Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class[]{UserInterface.class}, new InvocationHandler() {
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("before...");
		Object result = method.invoke(target, args);
		System.out.println("after...");
		return result;
	}
});

UserInterface userService = (UserInterface) proxy;
userService.test();

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

Exception in thread "main" java.lang.IllegalArgumentException: com.zhouyu.service.UserService is not an interface

表示一定要是个接口。

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

ProxyFactory

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

UserService target = new UserService();

ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
// 设置代理逻辑
proxyFactory.addAdvice(new MethodInterceptor() {
	@Override
    // 环绕通知 
	public Object invoke(MethodInvocation invocation) throws Throwable {
		System.out.println("before...");
		Object result = invocation.proceed();
		System.out.println("after...");
		return result;
	}
});

UserInterface userService = (UserInterface) proxyFactory.getProxy();
userService.test();

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

Advice的分类

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

看课上给的代码例子将一目了然

1.后置通知

在目标方法成功执行后（没有抛出异常时）执行的通知。
常用于修改返回值、收集统计信息、资源清理等。

可以拿到返回值 returnValue

2.前置通知

在目标方法执行之前执行的通知。
通常用于权限检查、日志记录等。

不需要再写否则会执行2次

3.异常通知（After throwing advice）【功能强大】

- 在目标方法抛出异常后执行的通知。
- 通常用于异常处理、记录异常信息等。

异常的这个Advice接口里没有任何方法，讲道理应该要有的，上面两个都有，然后实现对应接口的方法。

不定义提供了更多的灵活性

那自己写的方法Spring能调用？当然可以了！！

如果把异常换成无效参数，怎么就没执行代理逻辑？

因为异常不对

用法

使用规范：

方法名一定要叫做afterThrowing，要么只有1个参数，就是异常。

要不然就4个参数

4.环绕通知

它可以在被通知的方法调用前后执行自定义的行为，并且可以决定是否继续执行该方法或提前返回自定义的返回值。但是，使用环绕通知时需要小心，因为它需要显式调用ProceedingJoinPoint.proceed()来继续执行原方法，如果忘记了这一步骤，原方法将不会被执行。

不要引错包了，不是cglib包下的方法拦截器，是Aop联盟的

手动执行被调用逻辑

会按照添加的顺序执行。

但是执行被代理方法的时候还会去看有没有后续其他通知需要执行，如果有会先执行，再去执行被代理的方法。【递归实现的】

但是如果addAdvice换个顺序就会有影响。

举例

首先就会取出前置通知的方法拦截器

然后执行invoke方法，

然后执行before方法==》再去执行proceed方法又进入到这个方法里面来

然后取出第二个环绕通知

然后执行这个方法，这里就会走到把第三个环绕通知再取出来，直到最后都走完才会去执行被代理对象的那个方法，责任链模式。

环绕通知不手动执行是不会自动执行的

Advisor的理解【Pointcut+Advice】

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

		UserService target = new UserService();

		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 method.getName().equals("testAbc");
					}
				};
			}

			@Override
            // 返回环绕通知这里
			public Advice getAdvice() {
				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;
					}
				};
			}

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

		UserInterface userService = (UserInterface) proxyFactory.getProxy();
		userService.test();

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

创建代理对象的方式

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

ProxyFactoryBean

@Bean
public ProxyFactoryBean userServiceProxy(){
	UserService userService = new UserService();

	ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
    // 可以设置代理的对象 底层会包装成TargetSource
	proxyFactoryBean.setTarget(userService);
	proxyFactoryBean.addAdvice(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
	return proxyFactoryBean;
}

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

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

@Bean
public MethodInterceptor zhouyuAroundAdvice(){
	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 userService(){
	UserService userService = new UserService();
	
    ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
	proxyFactoryBean.setTarget(userService);
	proxyFactoryBean.setInterceptorNames("zhouyuAroundAdvice");
	return proxyFactoryBean;
}

BeanNameAutoProxyCreator

【原理是BeanPostProcessor初始化前+ProxyFactory来实现的】

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

@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
    // 根据beanName自动创建代理对象
	BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
	// bean的名字符合这个表达式 符合这个前缀都会产生代理对象
    beanNameAutoProxyCreator.setBeanNames("userSe*");
    // 都会执行这个代理逻辑
	beanNameAutoProxyCreator.setInterceptorNames("zhouyuAroundAdvice");
	beanNameAutoProxyCreator.setProxyTargetClass(true);

    return beanNameAutoProxyCreator;
}

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

这里的BeanNameAutoProxyCreator继承了AbstractAutoProxyCreator

原理用的就是BeanPostProcessor

BeanPostProcessor

DefaultAdvisorAutoProxyCreator

@Bean
public DefaultPointcutAdvisor defaultPointcutAdvisor(){
	NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
    // 设置方法名字
	pointcut.addMethodName("test");

    DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
	defaultPointcutAdvisor.setPointcut(pointcut);
    // 设置要代理的逻辑
	defaultPointcutAdvisor.setAdvice(new ZhouyuAfterReturningAdvice());

    return defaultPointcutAdvisor;
}

@Bean 
// 这里也是个BeanPostProcessor 在初始化后的方法里会找出哪些类型是Advisor的bean
// 没有这个bean上面的bean就只是个bean，无法生效
// 这里也可以直接使用@Import(DefaultAdvisorAutoProxyCreator.class)把类导入进来
// 
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
	
    DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();

	return defaultAdvisorAutoProxyCreator;
}

通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean，然后看哪个Advisor里面的pointCut和我当前正在创建的bean匹配，比如pointcut.addMethodName("test");设置了test方法，就会去看这个当前正在创建的bean有没有test方法，如果有那就需要动态代理，动态代理逻辑就是我设置的逻辑defaultPointcutAdvisor.setAdvice(new ZhouyuAfterReturningAdvice()); 这个pointCut可以写的非常复杂，方法参数个数啊，返回类型啊，只要符合pointCut就行，从而达到目的。

加了@Import，现在只需要定义一些Advisor就能实现代码增强效果【想要切哪个方法，代理逻辑是什么】

@Import 注解主要用于导入其他配置类或组件。当你想把一个或多个类作为Bean注册到Spring容器中时，可以使用 @Import 来引入这些类。这个注解通常用在配置类上，可以导入其他配置类或普通的组件类。

使用 @Import 注解时，导入的类将作为一个完整的类注册到Spring容器中，即Spring会为这些类创建Bean实例。这个注解对于模块化配置非常有用，因为它允许你将配置分散到多个配置类中，然后将它们组合到一起。

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

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

对的，通过注解！

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

@Aspect
@Component
public class ZhouyuAspect {

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

}

通过上面这个类，我们就直接定义好了所要代理的方法(通过一个表达式)，以及代理逻辑（被@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包的，比如：

compile group: 'org.aspectj', name: 'aspectjrt', version: '1.9.5'
compile group: 'org.aspectj', name: 'aspectjweaver', version: '1.9.5'

AspectJ底层不是用的动态代理

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

IDEA中使用Aspectj：AspectJ——简介以及在IntelliJ IDEA下的配置_idea aspectj-CSDN博客

这个注解其实就是会往spring注册一个bean

这个类到时候就会去解析我们定义的切面@Aspect和里面的内容@Before之类的

其实就是把@Before解析成一个pointCut，把方法整合一下解析成一个Advice【增强逻辑】

然后最终就得到一个Advisor，然后再放到spring容器中

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重新定义自己的那可能会导致更加混乱

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

Advice在Spring AOP中对应API

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

@Before
@AfterReturning
@AfterThrowing
@After
@Around

我们前面也提到过，Spring自己也提供了类似的执行实际的实现类：

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

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

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

TargetSource的使用【@Lazy注解】——被代理对象的来源是什么

在使用proxyFactory的时候，设置target底层其实会包装成TargetSource

然后在调用最后产生代理对象的方法的时候就会触发TargetSource的getTarget方法的执行

在我们日常的AOP中，被代理对象就是Bean对象，是由BeanFactory给我们创建出来的，但是Spring AOP中提供了TargetSource机制，可以让我们用来自定义逻辑来创建被代理对象。

比如之前所提到的@Lazy注解，当加在属性上时，会产生一个代理对象赋值给这个属性，产生代理对象的代码为：

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
            // 加了@Lazy注解的代理对象在执行方法的时候会调用getTarget（）方法
			public Object getTarget() {
				Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);
                // 根据当前类型去bean工厂找对象 byType byName等
				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);
						}
					}
				}
                // 返回真正的被代理对象 然后再去执行被代理对象的xxx方法
				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());
	}

这段代码就利用了ProxyFactory来生成代理对象，以及使用了TargetSource，以达到代理对象在执行某个方法时，调用TargetSource的getTarget()方法实时得到一个被代理对象。

执行完advice切面逻辑还要执行被代理对象的方法，这里就要用到target了，target哪里来的？就是TargetSource里的getTarget方法来的