一. 什么时候创建proxy bean
我们知道代理类是在 initializeBean() 的时候的 applyBeanPostProcessorsAfterInitialization() 中触发的，通过后处理器的 postProcessAfterInitialization() 生成的；
我们简单看下流程：
// --------------------- AbstractAutowireCapableBeanFactory ------------------
protected Object initializeBean(String beanName, Object bean,
@Nullable RootBeanDefinition mbd) {
// ...
Object wrappedBean = bean;
// 1. 轮询执行后置处理器的 postProcessBeforeInitialization()
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean,
beanName);
}
try {
// 2. 执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException();
}
// 3. 轮询执行后置处理器的 postProcessAfterInitialization()
// 这里就是会触发生成代理类的地方
// 将原始 bean 传进去，如果原始 Bean 需要代理的话会得到代理后的 bean 对象
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean,
beanName);
}
return wrappedBean;
}
// --------------------- AbstractAutowireCapableBeanFactory ------------------
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean,
String beanName) {
// 轮询所有的后置处理器 BeanPostProcessor
// 调它的 postProcessAfterInitialization()，得到处理后的对象并赋值给 result
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
那么，真正执行 AOP 代理的是哪个后置处理器 BeanPostProcessor 呢？是 AnnotationAwareAspectJAutoProxyCreator，它是一个具体的实现类，postProcessAfterInitialization() 得看它的抽象父类 AbstractAutoProxyCreator，下面我们简单看下 AbstractAutoProxyCreator#postProcessAfterInitialization()；
二. 如何创建proxy bean
我们直接看 AbstractAutoProxyCreator#postProcessAfterInitialization() 的逻辑；
// -------------------------- AbstractAutoProxyCreator ------------------------
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// 如果需要的话包装代理 bean 对象
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
// -------------------------- AbstractAutoProxyCreator ------------------------
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
if (StringUtils.hasLength(beanName) &&
this.targetSourcedBeans.contains(beanName)) {
return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
if (isInfrastructureClass(bean.getClass()) ||
shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 1. 查找 Bean 对应的 Adivce
// 如果有 Advice 的话，就会创建 Proxy 代理对象
Object[] specificInterceptors =
getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 2. 创建代理类对象
// 值得注意的是，这里创建了一个 SingletonTargetSource 对象，其内部包含了原始 bean 对象
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors,
new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
其实就是两个步骤；
- 查找 Bean 对应的 Advices 和 Advisors：getAdvicesAndAdvisorsForBean()；
- 创建代理类对象：createProxy()；
1. getAdvicesAndAdvisorsForBean()
查找 Bean 对应的 Advice，如下：
// ------------------- AbstractAdvisorAutoProxyCreator ------------------
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
// 查找符合条件的 Advisors
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
return advisors.toArray();
}
// ------------------- AbstractAdvisorAutoProxyCreator ------------------
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 1. 获取到所有的 Advisors
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 2. 获取符合条件的 Advisors
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors,
beanClass, beanName);
// 3. 对符合条件的 Advisors 进行扩展
extendAdvisors(eligibleAdvisors);
// 4. 对 Advisors 进行排序
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
我们主要看第 2 点和第 3 点；
第 2 点：findAdvisorsThatCanApply()，我们关注 PointcutAdvisor 即可；
// -------------------------------- AopUtils -------------------------------
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors,
Class<?> clazz) {
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
List<Advisor> eligibleAdvisors = new ArrayList<>();
for (Advisor candidate : candidateAdvisors) {
if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
eligibleAdvisors.add(candidate);
}
}
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
for (Advisor candidate : candidateAdvisors) {
if (candidate instanceof IntroductionAdvisor) {
continue;
}
// candidate Advisor 是否能适配 clazz 对象，适配的话加入到 eligibleAdvisors 中
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
// -------------------------------- AopUtils -------------------------------
public static boolean canApply(Advisor advisor, Class<?> targetClass,
boolean hasIntroductions) {
if (advisor instanceof IntroductionAdvisor) {
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
else if (advisor instanceof PointcutAdvisor) {
// 如果当前 advisor 对象是 PointcutAdvisor 类型，调用 canApply() 看是否适配 target
PointcutAdvisor pca = (PointcutAdvisor) advisor;
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
return true;
}
}
// -------------------------------- AopUtils -------------------------------
public static boolean canApply(Pointcut pc, Class<?> targetClass,
boolean hasIntroductions) {
// 1. pointcut 的类匹配器 ClassFilter 是否匹配 targetClass
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
// 2. pointcut 的方法匹配器 MethodMatcher 如果是 MethodMatcher.TRUE 表示都匹配
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {
return true;
}
// 3. 获取目标类的所有接口
Set<Class<?>> classes = new LinkedHashSet<>();
if (!Proxy.isProxyClass(targetClass)) {
classes.add(ClassUtils.getUserClass(targetClass));
}
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
// 4. MethodMatcher 是否匹配目标类上的接口
for (Class<?> clazz : classes) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
if (introductionAwareMethodMatcher != null ?
introductionAwareMethodMatcher.matches(method, targetClass) :
methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
return false;
}
第 3 点，对符合条件的 Advisors 进行扩展；
这个方法挺有意思的，我们常见常用的 Advisor 是 AspectJ 的 Advisor，它会做一些扩展；
// --------------------- AspectJAwareAdvisorAutoProxyCreator ---------------------
protected void extendAdvisors(List<Advisor> candidateAdvisors) {
AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors);
}
// -------------------------- AspectJProxyUtils ---------------------------
static boolean makeAdvisorChainAspectJCapableIfNecessary(List<Advisor> advisors) {
if (!advisors.isEmpty()) {
boolean foundAspectJAdvice = false;
for (Advisor advisor : advisors) {
if (isAspectJAdvice(advisor)) {
foundAspectJAdvice = true;
break;
}
}
// 如果是 AspectJAdvice，并且不包含 ExposeInvocationInterceptor.ADVISOR
// 那么我们往 advisors 列表的第 0 个元素添加 ExposeInvocationInterceptor.ADVISOR
if (foundAspectJAdvice &&
!advisors.contains(ExposeInvocationInterceptor.ADVISOR)) {
advisors.add(0, ExposeInvocationInterceptor.ADVISOR);
return true;
}
}
return false;
}
这个 ExposeInvocationInterceptor.ADVISOR 值是啥呢，为啥要放在 advisors 列表的第 0 号元素；
我们知道 ExposeInvocationInterceptor.ADVISOR 一定是一个 Advisor 类对象，它的作用是启动 AOP 拦截器链路；如下：
public final class ExposeInvocationInterceptor implements MethodInterceptor {
public static final ExposeInvocationInterceptor INSTANCE = new ExposeInvocationInterceptor();
// 这个就是我们要的 ExposeInvocationInterceptor.ADVISOR
// 它 new 了一个 DefaultPointcutAdvisor
// Advice 为当前 MethodInterceptor 对象 ExposeInvocationInterceptor
public static final Advisor ADVISOR = new DefaultPointcutAdvisor(INSTANCE) {
@Override
public String toString() {
return ExposeInvocationInterceptor.class.getName() +".ADVISOR";
}
};
// 线程变量，保存当前的 MethodInvocation 类对象
private static final ThreadLocal<MethodInvocation> invocation =
new NamedThreadLocal<>("Current AOP method invocation");
/**
* 获取当前的 MethodInvocation 类对象
* 如果当前不是 AOP 代理对象的话，会抛出异常
*/
public static MethodInvocation currentInvocation() throws IllegalStateException {
MethodInvocation mi = invocation.get();
if (mi == null) {
throw new IllegalStateException();
}
return mi;
}
private ExposeInvocationInterceptor() {
}
/**
* invoke(MethodInvocation mi) 是 MethodInterceptor 的抽象方法
* 可以看到 ExposeInvocationInterceptor 的 invoke() 啥也没干，只是 mi.proceed()
* 所以 ExposeInvocationInterceptor.ADVISOR 的作用其实就是启动 AOP 拦截器链路！！！
*/
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
MethodInvocation oldInvocation = invocation.get();
invocation.set(mi);
try {
return mi.proceed();
}
finally {
invocation.set(oldInvocation);
}
}
}
2. createProxy()
下面我们看 createProxy() 创建 Proxy 代理类对象的过程；
// ------------------------- AbstractAutoProxyCreator --------------------------
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors,
TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass(this.beanFactory, beanName, beanClass);
}
// 1. 新建一个 ProxyFactory 对象
// 可以看到，每次创建代理对象都是 new 一个 ProxyFactory 对象
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
// 2. 添加 Advisors
proxyFactory.addAdvisors(advisors);
// 3. 设置 targetSource 目标对象
// 这个 targetSource 包含了原始的 bean 对象，bean 对象类型等！！！
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// 4. 通过 ProxyFactory.getProxy() 生成代理类对象
// 我们主要看这一步
return proxyFactory.getProxy(getProxyClassLoader());
}
// ----------------------------- ProxyFactory ------------------------------
public Object getProxy(@Nullable ClassLoader classLoader) {
// 1. 获取 AopProxy 对象
// 2. 调用 AopProxy 对象的 getProxy() 得到代理类对象
return createAopProxy().getProxy(classLoader);
}
我们先看第 1 步，获取 AopProxy 对象；
// --------------------------- ProxyCreatorSupport ---------------------------
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
// 1. 获取 AopProxyFactory，一般都为默认的 DefaultAopProxyFactory
// AopProxyFactory 也只有 DefaultAopProxyFactory 这一个实现类
// 2. 调用 defaultAopProxyFactory.creaeAopProxy(this)
// 这个 this 其实是 ProxyFactory 类对象
// ProxyFactory 其实是 Advised、AdvisedSupport、ProxyCreatorSupport 等接口的实现类
// 这个 proxyFactory 对象包含了代理类的各种信息，包括 Advisors，被代理原始 bean 对象等
return getAopProxyFactory().createAopProxy(this);
}
// -------------------------- DefaultAopProxyFactory -------------------------
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() ||
hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException();
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
// 如果是接口类型采用 Jdk 动态代理类
return new JdkDynamicAopProxy(config);
}
// 如果 target 没有实现任何接口，采用 Cglib 动态代理类
return new ObjenesisCglibAopProxy(config);
}
else {
// 其他情况也采用 Jdk 动态代理类
return new JdkDynamicAopProxy(config);
}
}
再看第 2 步，调用 AopProxy 对象的 getProxy() 获取代理类对象；
我们知道有 Jdk 动态代理类 JdkDynamicAopProxy 和 Cglib 动态代理类 ObjenesisCglibAopProxy，其实都是大同小异的，我们看它们的 getProxy() 是怎么生成代理类对象的；
2.1 JdkDynamicAopProxy
Jdk 的动态代理，值得注意的是 JdkDynamicAopProxy 不仅是 AopProxy 接口的实现类，也是 Jdk 动态代理中最经典的 InvocationHandler 接口的实现类；
所以我们既要关注作为 AopProxy 接口实现类的 getProxy()，也要关注作为 InvocationHandler 接口实现类的 invoke()；
1、我们先来看它作为 AopProxy 接口实现类的 getProxy()，下面解释了为啥 Spring 生成的代理类对象都可以转换为 Advised 接口，原因是会让生成的代理类实现 Advised 接口！
// -------------------------- JdkDynamicAopProxy ---------------------------
@Override
public Object getProxy(@Nullable ClassLoader classLoader) {
// 1. 获取被代理类的接口
// 这里不仅仅获取被代理类本身实现的接口，Spring 还会往其加入几个接口
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
// 2. 通过 Jdk 动态代理经典的 Proxy.newProxyInstance() 创建代理对象
// 可以看到，传的 InvocationHandler 对象就是 this，也就是 JdkDynamicAopProxy
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
// --------------------------- AopProxyUtils -----------------------------
static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised,
boolean decoratingProxy) {
Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
if (specifiedInterfaces.length == 0) {
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、Advised 接口的话，往里塞入这俩接口
// 其中，DecoratingProxy 接口暂时不知道意义是啥
// 一般 JdkDynamicAopProxy 生成的代理类会实现该接口，Cglib 的不会
boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
boolean addAdvised = !advised.isOpaque() &&
!advised.isInterfaceProxied(Advised.class);
boolean addDecoratingProxy = (decoratingProxy &&
!advised.isInterfaceProxied(DecoratingProxy.class));
int nonUserIfcCount = 0;
if (addSpringProxy) {
nonUserIfcCount++;
}
if (addAdvised) {
nonUserIfcCount++;
}
if (addDecoratingProxy) {
nonUserIfcCount++;
}
Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
int index = specifiedInterfaces.length;
// 代理类需要实现的接口中，加入 SpringProxy、Advised 接口
if (addSpringProxy) {
proxiedInterfaces[index] = SpringProxy.class;
index++;
}
if (addAdvised) {
proxiedInterfaces[index] = Advised.class;
index++;
}
if (addDecoratingProxy) {
proxiedInterfaces[index] = DecoratingProxy.class;
}
return proxiedInterfaces;
}
2、再来看它作为 InvocationHandler 接口实现类的 invoke()；
核心方法是找到匹配当前方法 method 的 advisors，创建一个 ReflectiveMethodInvocation 对象，并调用该对象的 proceed() 执行调用链；
对于 MethodInvocation#proceed() 后面我们还会细讲；
// -------------------------- JdkDynamicAopProxy ---------------------------
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Object target = null;
try {
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
return equals(args[0]);
}
else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
return hashCode();
}
else if (method.getDeclaringClass() == DecoratingProxy.class) {
return AopProxyUtils.ultimateTargetClass(this.advised);
}
Object retVal;
// 是否暴露 AOP 对象到当前线程变量 AopContext 中
// 需要打开 advised.exposeProxy 配置开关
// 常用于解决 this.proxyMethod() 中调用了 this.proxyMethod() 的问题，了解即可！
if (this.advised.exposeProxy) {
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// target 为原始 bean 对象
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
// 1. 根据方法和目标类获取匹配的 advisors
// 该方法是核心方法，查找符合 method 的 advisors
// 我们在 ProxyFactory 中其实已经把对应的 eligibleAdvisors 设置进去了
// 只不过在调用代理类对象方法的时候需要对 eligibleAdvisors 进行筛选过滤
// 我们就不点这个方法了，有兴趣可以点进去看看
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
if (chain.isEmpty()) {
// 2.1 如果没有匹配到 advisor
// 直接通过反射调用目标类的方法 method.invoke(target, args)
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method,args);
retVal = AopUtils.invokeJoinpointUsingReflection(target,method,argsToUse);
}
else {
// 2.2 匹配到了 advisor
// new 了一个 ReflectiveMethodInvocation 对象
// 且执行 MethodInvocation 的 proceed()
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args,
targetClass, chain);
retVal = invocation.proceed();
}
// ...
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
AopContext.setCurrentProxy(oldProxy);
}
}
}
2.2 ObjenesisCglibAopProxy
Cglib 的动态代理，通过上面我们知道，直接 new 了一个 ObjenesisCglibAopProxy，并调用它的 getProxy() 生成代理类对象，我们直接看 ObjenesisCglibAopProxy；
ObjenesisCglibAopProxy 继承了 CglibAopProxy，它的 getProxy() 在它的父类 CglibAopProxy 上；
CglibAopProxy 只实现了 AopProxy 接口，我们直接看它的 getProxy()；
// ----------------------------- CglibAopProxy ----------------------------
public Object getProxy(@Nullable ClassLoader classLoader) {
try {
Class<?> rootClass = this.advised.getTargetClass();
Assert.state(rootClass != null);
Class<?> proxySuperClass = rootClass;
if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
proxySuperClass = rootClass.getSuperclass();
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
for (Class<?> additionalInterface : additionalInterfaces) {
this.advised.addInterface(additionalInterface);
}
}
validateClassIfNecessary(proxySuperClass, classLoader);
// 创建 Cglib 动态代理经典的 Enhancer 类对象
Enhancer enhancer = createEnhancer();
if (classLoader != null) {
enhancer.setClassLoader(classLoader);
if (classLoader instanceof SmartClassLoader &&
((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
enhancer.setUseCache(false);
}
}
enhancer.setSuperclass(proxySuperClass);
// 设置代理类需要实现的接口，Spring 会往里添加 SpringProxy 和 Advised 接口
// 这里和 JdkDynamicAopProxy 类似
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
// 1. 获取 Callbacks
// Callback 是 Cglib 中最重要的类，一般是 MethodInterceptor 类对象
// 要注意一点，这里说的 MethodInterceptor 是 Cglib 里的，不是 SpringAOP 里的
// 这里会获取到多个 callback
// 我们主要关心和 SpringAOP 相关的那个 Callback
Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) {
types[x] = callbacks[x].getClass();
}
// 设置 CallbackFilter
// 多个 Callbacks 能一起工作的原因是有 CallbackFilter
// 对于代理类的指定方法，通过该 filter 选择指定的 callback 对代理类方法进行拦截增强
enhancer.setCallbackFilter(new ProxyCallbackFilter(
this.advised.getConfigurationOnlyCopy(),
this.fixedInterceptorMap,
this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
// 2. 通过 enhancer 和 callbacks 生成代理类对象
return createProxyClassAndInstance(enhancer, callbacks);
}
catch (CodeGenerationException | IllegalArgumentException ex) {
throw new AopConfigException();
}
catch (Throwable ex) {
throw new AopConfigException("Unexpected AOP exception", ex);
}
}
对于第 1 步，会获取多个 Callback，我们关注和 AOP 有关的 Callback：DynamicAdvisedInterceptor；
// ----------------------------- CglibAopProxy ---------------------------
private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
boolean exposeProxy = this.advised.isExposeProxy();
boolean isFrozen = this.advised.isFrozen();
boolean isStatic = this.advised.getTargetSource().isStatic();
// 创建和 AOP 有关的 DynamicAdvisedInterceptor
// 构造函数中传入了 this.advised 对象，也就是 proxyFactory 对象
Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
// 创建其他 Callback 对象
// ...
// 可以看到 callbacks 不仅有 aopIntercetor，还有其他的
// 比较容易理解的有 EqualsInterceptor、HashCodeInterceptor 和 targetInterceptor 等
Callback[] mainCallbacks = new Callback[] {
aopInterceptor, // for normal advice
targetInterceptor, // invoke target without considering advice, if optimized
new SerializableNoOp(), // no override for methods mapped to this
targetDispatcher, this.advisedDispatcher,
new EqualsInterceptor(this.advised),
new HashCodeInterceptor(this.advised)
};
Callback[] callbacks;
if (isStatic && isFrozen) {
// ...
} else {
callbacks = mainCallbacks;
}
return callbacks;
}
对于第 2 步，通过 enhancer 和 callbacks 生成代理类对象；
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
// 调用 enhancer.setCallbacks()，并调用 enhancer.create() 生成代理类对象
enhancer.setInterceptDuringConstruction(false);
enhancer.setCallbacks(callbacks);
return (this.constructorArgs != null && this.constructorArgTypes != null ?
enhancer.create(this.constructorArgTypes, this.constructorArgs) :
enhancer.create());
}
和 AOP 有关的 Callback 是 DynamicAdvisedInterceptor，该类是 CglibAopProxy 的静态内部类；
DynamicAdvisedInterceptor 实现了 Cglib 包的 MethodInterceptor，实现了它的 invoke()，我们直接看它的 invoke()；其实它的 invoke() 和 JdkDynamicAopProxy 的 invoke() 类似，都是先找到符合条件的 advisors，然后创建一个 MethodInvocation，指定 methodInvocation 的 proceed()；
private static class DynamicAdvisedInterceptor implements MethodInterceptor {
private final AdvisedSupport advised;
// 构造方法，传入 AdvisedSupport 类对象，一般是我们的 ProxyFactory 对象
public DynamicAdvisedInterceptor(AdvisedSupport advised) {
this.advised = advised;
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Object target = null;
TargetSource targetSource = this.advised.getTargetSource();
try {
// 是否将代理类对象暴露到 AopContext 线程变量上
if (this.advised.exposeProxy) {
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
target = targetSource.getTarget();
Class<?> targetClass = (target != null ? target.getClass() : null);
// 1. 根据方法和目标类获取匹配的 advisors
// 该方法是核心方法，查找符合 method 的 advisors
// 我们在 ProxyFactory 中其实已经把对应的 eligibleAdvisors 设置进去了
// 只不过在调用代理类对象方法的时候需要对 eligibleAdvisors 进行筛选过滤
// 和 Jdk 动态代理调用的是同一个方法
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method,targetClass);
Object retVal;
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// 2.1 如果没有符合条件的 advisors，反射调用目标方法
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method,
args);
retVal = methodProxy.invoke(target, argsToUse);
}
else {
// 2.2 有符合条件的 advisors
// new 了一个 CglibMethodInvocation，并执行它的 proceed()
// JdkDynamicAopProxy 创建的是 ReflectiveMethodInvocation
// DynamicAdvisedInterceptor 创建的是 CglibMethodInvocation
// 其实两者差不多，CglibMethodInvocation继承了ReflectiveMethodInvocation
// 我们在看源码的时候，可以认为调用的都是 ReflectiveMethodInvocation
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
targetSource.releaseTarget(target);
}
if (setProxyContext) {
AopContext.setCurrentProxy(oldProxy);
}
}
}
}
至此，生成代理类对象的流程结束。
9280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
