經過一個aop術語介紹和動態代理的深入講解，我們終於可以來看aop的源碼了，下面跟着博主一點點剖析spring aop源碼的實現吧
我們知道spring使用中我們只要做好相關的配置，spring自動幫我們做好了代理的相關工作。
我們從三個方面入手吧
1、配置
2、創建代理
3、獲取代理類
配置
我們從AopNamespaceHandler入手，這個是自定義配置的實現類
public void init() {
this.registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
this.registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
}
對aop的aspectj的配置很熟悉了吧
我們來看看AspectJAutoProxyBeanDefinitionParser的parse方法吧，這個是ioc加載自定義配置調用的方法
public BeanDefinition parse(Element element, ParserContext parserContext) {
AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
}
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
ParserContext parserContext, Element sourceElement) {
//註冊AspectJAnnotationAutoProxyCreator
BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
parserContext.getRegistry(), parserContext.extractSource(sourceElement));
//處理proxy-target-class和expose-proxy
useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
//註冊組件
registerComponentIfNecessary(beanDefinition, parserContext);
}
//註冊的是AnnotationAwareAspectJAutoProxyCreator
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
這裏我們注意，springaop自動幫我們註冊了AnnotationAwareAspectJAutoProxyCreator
另外target-proxy-class：spring提供了兩種代理的，jdk和cglib（建議使用jdk），這個屬性就是配置使用哪個代理模式的true-cglib，false-jdk
expose-proxy:解決那日不自我調用無法增強
創建代理
我們看看AnnotationAwareAspectJAutoProxyCreator的UML類關係圖
可以看出AbstractAutoProxyCreator實現了BeanPostProcessor方法，看到這個我想我們應該知道去關注什麼方法吧，對postProcessAfterInitialization是創建bean的時候會執行的方法
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.containsKey(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
什麼緩存之類的我們先不看了，因爲這個時候還沒有
if (beanName != null && this.targetSourcedBeans.containsKey(beanName)) {
return bean;
}
// 獲取bean的切面
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
//創建代理對象
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
}
return bean;
}
我們先來看看增強的獲取：
1、
protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource targetSource) {
List advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
2、
protected List<Advisor> findEligibleAdvisors(Class beanClass, String beanName) {
//尋找所有的增強
List<Advisor> candidateAdvisors = findCandidateAdvisors();
//匹配適應的增強，無法找到返回null
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
//排序增強
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
在過來看看代理的創建
protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
ProxyFactory proxyFactory = new ProxyFactory();
//添加代理接口
if (!shouldProxyTargetClass(beanClass, beanName)) {
// Must allow for introductions; can't just set interfaces to
// the target's interfaces only.
Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
for (Class<?> targetInterface : targetInterfaces) {
proxyFactory.addInterface(targetInterface);
}
}
//添加增強
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
for (Advisor advisor : advisors) {
proxyFactory.addAdvisor(advisor);
}
proxyFactory.setTargetSource(targetSource);
return proxyFactory.getProxy(this.proxyClassLoader);
}
直接看getProxy()
public Object getProxy(ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
我先看看createAopFactory創建了什麼代理類
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
//判斷配置，optimize配置爲true或者proxy-target-class=true
//且目標類是一個接口使用jdk
//或者使用cglib
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class targetClass = config.getTargetClass();
if (targetClass.isInterface()) {
return new JdkDynamicAopProxy(config);
}
return CglibProxyFactory.createCglibProxy(config);
}
//optimize配置爲false並且proxy-target-class=false直接使用jdk代理
else {
return new JdkDynamicAopProxy(config);
}
}
看到了吧，這裏就決定了代理的創建方式，optimize爲false且proxy-target-class=false，且不存在使用代理接口直接使用jdk，否則再判斷如果目標類是一個接口，則使用jdk，否則使用cglib。
先剖析Jdk的getProxy
我們來看下JdkDynamicAopProxy的類關係圖
從上圖可知，JdkDynamicAopProxy實現了InvocationHandler，也就是代理的邏輯操作在這裏面實現
再看看getProxy這個函數
public Object getProxy(ClassLoader classLoader) {
Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
這裏的return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);就是創建代理類了
我們看看jdk的關鍵InvocationHandler的實現吧
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
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();
}
// 獲取當前方法的增強的攔截鏈
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()) {
//沒有攔截鏈直接調用方法
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
// 封裝攔截鏈
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, 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;
} 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;
}
}
這裏比較重要的就是攔截鏈了，我們接下來剖析一下攔截鏈的執行
public Object proceed() throws Throwable {
// 執行完所有攔截器鏈後，執行切點方法
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 {
//匹配失敗，不執行啥
return proceed();
}
}
else {
//普通攔截器直接調用攔截器，處理引介增強
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
這裏就是通過一個索引遍歷列表的，注意一下這個InterceptorAndDynamicMethodMatcher類
class InterceptorAndDynamicMethodMatcher {
final MethodInterceptor interceptor;
final MethodMatcher methodMatcher;
public InterceptorAndDynamicMethodMatcher(MethodInterceptor interceptor, MethodMatcher methodMatcher) {
this.interceptor = interceptor;
this.methodMatcher = methodMatcher;
}
}
其實就是一個方法匹配攔截器，這裏我們在回到上面的創建攔截器鏈的方法，看看怎麼創建攔截器的
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
Advised config, Method method, Class targetClass) {
List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
//獲取所有的增強器
for (Advisor advisor : config.getAdvisors()) {
//判斷增強是否有切點
if (advisor instanceof PointcutAdvisor) {
PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
if (config.isPreFiltered() ||
//類過濾器匹配
pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
//方法匹配器匹配
if (MethodMatchers.matches(mm, method, targetClass, 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));
}
}
}
}
//引介增強
else if (advisor instanceof IntroductionAdvisor) {
IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
if (config.isPreFiltered() || ia.getClassFilter().matches(targetClass)) {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
//普通方法
else {
Interceptor[] interceptors = registry.getInterceptors(advisor);
interceptorList.addAll(Arrays.asList(interceptors));
}
}
return interceptorList;
}
其實這個攔截器鏈的處理和process()加起來就決定了哪些增強方法會被處理。
Cglib
public Object getProxy(ClassLoader classLoader) {
Class<?> rootClass = this.advised.getTargetClass();
Class<?> proxySuperClass = rootClass;
if (ClassUtils.isCglibProxyClass(rootClass)) {
proxySuperClass = rootClass.getSuperclass();
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
for (Class<?> additionalInterface : additionalInterfaces) {
this.advised.addInterface(additionalInterface);
}
}
Enhancer enhancer = createEnhancer();
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new MemorySafeUndeclaredThrowableStrategy(UndeclaredThrowableException.class));
enhancer.setInterceptDuringConstruction(false);
//獲取回調
Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) {
types[x] = callbacks[x].getClass();
}
enhancer.setCallbackFilter(new ProxyCallbackFilter(
this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
//設置回調
enhancer.setCallbacks(callbacks);
//創建代理類
proxy = enhancer.create();
return proxy;
}
上面代碼一目瞭然了，基本上就是一個cglib動態代理的配置創建代碼，我們需要想jdk部分那樣找到代理的處理部分，在cglib中是callback
getCallBack
private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
retVal = methodProxy.invoke(target, args);
}
else {
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
基本和jdk的流程差不多，首先創建一個攔截器鏈，然後遍歷。
至此aop的源碼我們分析完畢，我們來做個總結吧：
1、springaop默認使用的是jdk的代理方式，如果想使用cglib，可配置<aop:aspectj-autoproxy proxy-target-class=true/>
2、這裏有必要提一提jdk的運行性能沒有cglib高，比cglib差8倍，但創建代理的性能比cglib高10倍，對於無需頻繁創建代理比較適合使用cglib模式，反之jdk模式比較適合
3、jdk和cglib都是運行時創建代理的方式