筛选好advisor之后，就可以创建aop了
protected Object org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator.createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
//如果BeanFactory是ConfigurableListableBeanFactory，暴露被代理的对象class
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
//创建代理工厂
ProxyFactory proxyFactory = new ProxyFactory();
//代理工厂与当前类继承相同ProxyConfig类
//将当前类的一些配置属性copy到代理工厂
proxyFactory.copyFrom(this);
//是否已指定为代理目标类
if (!proxyFactory.isProxyTargetClass()) {
//检查BeanDefinition的属性org.springframework.aop.framework.autoproxy.AutoProxyUtils.preserveTargetClass
//如果为true，就设置cglib代理
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
//获取接口，如果没有接口，就proxyFactory.setProxyTargetClass(true)
//（*1*）
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
//(*2*)
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
for (Advisor advisor : advisors) {
//将advisor设置到代理工厂中
proxyFactory.addAdvisor(advisor);
}
//设置需要代理的目标对象包装
proxyFactory.setTargetSource(targetSource);
//自定义代理工厂，由子类实现
customizeProxyFactory(proxyFactory);
//设置代理配置是否被冻结，被冻结后，代理配置不能被改变
proxyFactory.setFrozen(this.freezeProxy);
//是否返回预过滤advisor
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
//获取代理对象
return proxyFactory.getProxy(getProxyClassLoader());
}
//（*1*）
protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
//获取当前bean的接口
Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
boolean hasReasonableProxyInterface = false;
//排除一些spring用于配置的接口，比如InitializingBean，DisposableBean，DisposableBean
//groovy.lang.GroovyObject
for (Class<?> ifc : targetInterfaces) {
if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
ifc.getMethods().length > 0) {
//表示有接口
hasReasonableProxyInterface = true;
break;
}
}
//如果有接口，那么添加接口，用于代理
if (hasReasonableProxyInterface) {
// Must allow for introductions; can't just set interfaces to the target's interfaces only.
for (Class<?> ifc : targetInterfaces) {
proxyFactory.addInterface(ifc);
}
}
else {
//如果么有接口，那么设置为cglib代理
proxyFactory.setProxyTargetClass(true);
}
}
//(*2*)
protected Advisor[] buildAdvisors(String beanName, Object[] specificInterceptors) {
// Handle prototypes correctly...
//获取程序设置的advice，如果没有实现MethodInterceptor的，会使用适配器适配
Advisor[] commonInterceptors = resolveInterceptorNames();
List<Object> allInterceptors = new ArrayList<Object>();
if (specificInterceptors != null) {
allInterceptors.addAll(Arrays.asList(specificInterceptors));
if (commonInterceptors.length > 0) {
//是否首先使用通用拦截
if (this.applyCommonInterceptorsFirst) {
allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
}
else {
allInterceptors.addAll(Arrays.asList(commonInterceptors));
}
}
}
if (logger.isDebugEnabled()) {
int nrOfCommonInterceptors = commonInterceptors.length;
int nrOfSpecificInterceptors = (specificInterceptors != null ? specificInterceptors.length : 0);
logger.debug("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
" common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
}
Advisor[] advisors = new Advisor[allInterceptors.size()];
for (int i = 0; i < allInterceptors.size(); i++) {
//循环检查advisor，如果是advisor直接返回，如果是Advice并且是MethodInterceptor，那么创建DefaultPointcutAdvisor
//这个默认的advisor的切点是Pointcut.TRUE,表示来者不拒，如果不是MethodInterceptor，那么查看下是否是
//public DefaultAdvisorAdapterRegistry() {
// registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
// registerAdvisorAdapter(new AfterReturningAdviceAdapter());
// registerAdvisorAdapter(new ThrowsAdviceAdapter());
//}
//MethodBeforeAdvice，AfterReturningAdvice，ThrowsAdvice具有对应的适配器，advisor类型依然使用默认的advisor进行包装
advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
}
return advisors;
}
代理工厂创建代理
public Object org.springframework.aop.framework.ProxyFactory.getProxy(ClassLoader classLoader) {
//(*1*)(*3*)
return createAopProxy().getProxy(classLoader);
}
//(*1*)
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
//(*2*)
//getAopProxyFactory() 返回的对象为DefaultAopProxyFactory对象
return getAopProxyFactory().createAopProxy(this);
}
//(*2*)
public AopProxy org.springframework.aop.framework.DefaultAopProxyFactory.createAopProxy(AdvisedSupport config) throws AopConfigException {
//如果有接口或者设置成代理目标对象或者使用优化策略，那么使用cglib代理
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
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);
}
//cglib代理
return new ObjenesisCglibAopProxy(config);
}
else {
//jdk动态代理
return new JdkDynamicAopProxy(config);
}
}
//(*3*)我们调个动态代理来看看
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
//(*4*)
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
//寻找equals和hashCode方法，如果找到标记this.equalsDefined = true;，this.hashCodeDefined = true;
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
//使用JDK动态代理创建
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) {
//从配置中获取类的接口
Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
//如果没有接口
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();
}
}
//接口中是否存在SpringProxy接口，用于标记某个类是否由spring生成的代理，如果没有设置，那么
//spring会自动加入这个接口，以便标记某个类是由spring生成的代理类
boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
//如果没有定义Advised接口，并且没有阻止代理类被转换成Advised，那么spring会自动添加这个接口
boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
int nonUserIfcCount = 0;
//扩展代理接口个数
if (addSpringProxy) {
nonUserIfcCount++;
}
//扩展代理接口个数
if (addAdvised) {
nonUserIfcCount++;
}
Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
//添加SpringProxy接口
if (addSpringProxy) {
proxiedInterfaces[specifiedInterfaces.length] = SpringProxy.class;
}
//添加Advised接口
if (addAdvised) {
proxiedInterfaces[proxiedInterfaces.length - 1] = Advised.class;
}
return proxiedInterfaces;
}
好了，如果创建代理，我们已经看到过了，我现在再来看看实现JDK动态代理的JdkDynamicAopProxy 这个类实现了jdk的InvocationHandler接口，所以我们重点研究一下它的invoke方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Class<?> targetClass = null;
Object target = null;
try {
//处理equals方法
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
//处理hashCode方法
if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
//this.advised.opaque如果为false，spring会自动添加Advised接口让代理类实现
//判断当前方法是否被定义在接口中，并且这个接口是Advised的父接口或者是它本身
//那么反射调用以this.advised为目标对象的方法，这个this.advised是实现了Advised的对象
if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
//反射调用，反射的目标对象是this.advised，这个advised对象是ProxyFactory对象，它实现了Advised对象
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
//判断是否需要暴露代理类，如果需要，那么将当前代理类保存到当前线程中去
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// May be null. Get as late as possible to minimize the time we "own" the target,
// in case it comes from a pool.
//获取被代理目标对象
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
// Get the interception chain for this method.
//获取当前方法的拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// Check whether we have any advice. If we don't, we can fallback on direct
// reflective invocation of the target, and avoid creating a MethodInvocation.
//如果没有适合对应方法的拦截器链，那么直接反射调用
if (chain.isEmpty()) {
// We can skip creating a MethodInvocation: just invoke the target directly
// Note that the final invoker must be an InvokerInterceptor so we know it does
// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
}
else {
// We need to create a method invocation...
//创建一个方法调用驱动，用于驱动链条的执行
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
//驱动链条的执行
retVal = invocation.proceed();
}
// Massage return value if necessary.
//获取方法的返回值
Class<?> returnType = method.getReturnType();
if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this" and the return type of the method
// is type-compatible. Note that we can't help if the target sets
// a reference to itself in another returned object.
retVal = proxy;
}
//如果方法返回为null又不是void类型的，还他娘的是基本类型的，那么抛错
else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
finally {
//一般单例的对象就是静态，那么会重新创建的对象，比如原型声明周期的就不是静态的
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
//释放目标对象
targetSource.releaseTarget(target);
}
//如果暴露了代理对象，那么将原来的值设置回去，恢复现场
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
拦截器链条的构建
public List<Object> org.springframework.aop.framework.DefaultAdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, Class<?> targetClass) {
// This is somewhat tricky... We have to process introductions first,
// but we need to preserve order in the ultimate list.
List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
//获取类的class对象
Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
//首先进行引介增强匹配，循环所有的advisor的，如果有引介增强的advisor，那么进行类匹配，如果匹配返回true
//否则false
boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
//获取Advisor适配注册器，前面我们看到过有些Advice没有实现MethodInterceptor，被包装成了DefaultPointcut，
//所以需要进行适配成MethodInterceptor
AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
for (Advisor advisor : config.getAdvisors()) {
//切点通知者，使用切点进行aop拦截
if (advisor instanceof PointcutAdvisor) {
// Add it conditionally.
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
//如果已经进行了预先过滤，那么无需再进行切点匹配，否则再次进行切点匹配
if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
//获取MethodInterceptor，一般直接从advisor中获取advice即可，但是并不是所有的advice都是已经实现了
//MethodInterceptor接口的，比如MethodBeforeAdvice，AfterReturningAdvice，ThrowsAdvice
//所以要对这些没有实现MethodInterceptor的advice进行适配（适配器模式）
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
//获取方法匹配器，用于匹配方法
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
//判断当前调用的方法是否符合切点表达式
if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
if (mm.isRuntime()) {
// Creating a new object instance in the getInterceptors() method
// isn't a problem as we normally cache created chains.
for (MethodInterceptor interceptor : interceptors) {
interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
}
}
else {
interceptorList.addAll(Arrays.asList(interceptors));
}
}
}
}
//如果是引介增强Advisor，那么只需进行类匹配就行
else if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
else {
//其他类型的advisor，和上面后去方法拦截是一样的操作，只是不需要进行匹配，因为这类advisor一般就是
//DefaultPointcut，他们是没有进行和任何切点表达式绑定的，默认都是Pointcut.TRUE
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
return interceptorList;
}
准备好拦截器之后，spring构建了一个驱动器，这个驱动器就是我们在上面invoke方法中看到的ReflectiveMethodInvocation，我们来看下它的proceed方法
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
//spring使用一个下标currentInterceptorIndex来表示当前执行到的位置，如果所有的拦截器都被执行了
//那么可以调用连接点方法了
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
//获取对应下标拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
我们挑其中一个拦截器来看看spring是怎么进行拦截的，比如AspectJAroundAdvice，这是一个环绕通知
public Object org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(MethodInvocation mi) throws Throwable {
if (!(mi instanceof ProxyMethodInvocation)) {
throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
}
//包装方法调用信息
ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
//用于作为参数传递给连接点，内部关联ProxyMethodInvocation，我们在连接点方法中
//调用它的process方法，即可继续下一个通知的调用
//用户获取连接点信息，比如获取kind类型，this（代理对象），target（被代理对象）等
ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
//JoinPointMatch用于储存匹配信息，参数绑定信息
JoinPointMatch jpm = getJoinPointMatch(pmi);
//调用通知方法
return invokeAdviceMethod(pjp, jpm, null, null);
}
调用通知方法
protected Object invokeAdviceMethod(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable t)
throws Throwable {
return invokeAdviceMethodWithGivenArgs(argBinding(jp, jpMatch, returnValue, t));
}
protected Object[] argBinding(JoinPoint jp, JoinPointMatch jpMatch, Object returnValue, Throwable ex) {
//参数绑定，这个方法我们在分析注解advice获取的时候分析过，此处不再赘述
calculateArgumentBindings();
// AMC start
Object[] adviceInvocationArgs = new Object[this.adviceInvocationArgumentCount];
int numBound = 0;
//如果存在joinPoint参数，那么将jp设置到指定参数位置
if (this.joinPointArgumentIndex != -1) {
adviceInvocationArgs[this.joinPointArgumentIndex] = jp;
numBound++;
}
//StaticPart参数，用于是静态方法（静态连接点）
else if (this.joinPointStaticPartArgumentIndex != -1) {
adviceInvocationArgs[this.joinPointStaticPartArgumentIndex] = jp.getStaticPart();
numBound++;
}
//如果参数绑定不为空，说明进行了参数绑定，比如我们指定了方法变量名，返回值变量名，异常方法名
if (!CollectionUtils.isEmpty(this.argumentBindings)) {
// binding from pointcut match
//如果连接点匹配信息存在，那么获取从切点中解析的绑定参数信息 execution(public com.zhipin.service.*.*(..) && args(a,b,c))
if (jpMatch != null) {
//获取切点参数
PointcutParameter[] parameterBindings = jpMatch.getParameterBindings();
for (PointcutParameter parameter : parameterBindings) {
//获取参数名
String name = parameter.getName();
//从参数绑定中获取参数的位置
Integer index = this.argumentBindings.get(name);
//将绑定的参数值设置到对应方法参数位置
adviceInvocationArgs[index] = parameter.getBinding();
numBound++;
}
}
// binding from returning clause
//设置返回值
if (this.returningName != null) {
//获取返回值变量下标
Integer index = this.argumentBindings.get(this.returningName);
//将返回值设置到对应下标位置
adviceInvocationArgs[index] = returnValue;
numBound++;
}
// binding from thrown exception
if (this.throwingName != null) {
//绑定抛出异常参数值
Integer index = this.argumentBindings.get(this.throwingName);
adviceInvocationArgs[index] = ex;
numBound++;
}
}
//如果绑定的参数的个数和实际的参数个数不相符，那么抛出异常
if (numBound != this.adviceInvocationArgumentCount) {
throw new IllegalStateException("Required to bind " + this.adviceInvocationArgumentCount +
" arguments, but only bound " + numBound + " (JoinPointMatch " +
(jpMatch == null ? "was NOT" : "WAS") + " bound in invocation)");
}
//返回参数列表
return adviceInvocationArgs;
}
参数准备好，那么就可以调用对应的通知方法了
protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
Object[] actualArgs = args;
//处理没有参数的情况
if (this.aspectJAdviceMethod.getParameterTypes().length == 0) {
actualArgs = null;
}
try {
//你懂的
ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
// TODO AopUtils.invokeJoinpointUsingReflection
//还记的这个切面实例工厂吗？这个实例工厂我们前面分析过，其实它内部就是调用BeanFactory的getBean方法获取切面对象
return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
}
catch (IllegalArgumentException ex) {
throw new AopInvocationException("Mismatch on arguments to advice method [" +
this.aspectJAdviceMethod + "]; pointcut expression [" +
this.pointcut.getPointcutExpression() + "]", ex);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
好了，切面方法已经被调用了，可是我们发现这个环绕通知没有调用Joinpoint的proceed方法，对于环绕通知我们通常都需要在通知方法参数上面添加一个ProceedingJoinPoint类型的参数，然后在代码中调用它的proceed方法，它的proceed方法又调用过了驱动器ReflectiveMethodInvocation的proceed方法。 好了，aop就了解到这里，其他的通知，如果同学们感兴趣就自己去研究。
