cglib动态代理
Waiter target = new NaiveWaiter();//一个实现了Waiter接口的类
BeforeAdvice advice = new GreetingBeforeAdvice();//一个实现了MethodBeforeAdvice的类 //spring提供的代理工厂 ProxyFactory pf = new ProxyFactory(); //设置代理目标 pf.setTarget(target); //为代理目标添加增强 pf.addAdvice(advice); //生成代理实例 Waiter proxy = (Waiter) pf.getProxy(); proxy.greetTo("Brian"); public interface MethodBeforeAdvice extends BeforeAdvice { /** * Callback before a given method is invoked. * @param method method being invoked * @param args arguments to the method * @param target target of the method invocation. May be <code>null</code>. * @throws Throwable if this object wishes to abort the call. */ void before(Method method, Object[] args, Object target) throws Throwable; }
spring提供的代理工厂new ProxyFactory();
//其父类ProxyCreatorSupport
public ProxyCreatorSupport() { this.aopProxyFactory = new DefaultAopProxyFactory(); } 设置代理目标 pf.setTarget(target);
//进入ProxyFactory的父类AdvisedSupport
public void setTarget(Object target) { setTargetSource(new SingletonTargetSource(target)); } public void setTargetSource(TargetSource targetSource) { this.targetSource = (targetSource != null ? targetSource : EMPTY_TARGET_SOURCE); } public SingletonTargetSource(Object target) { Assert.notNull(target, "Target object must not be null"); this.target = target; } 为代理目标添加增强pf.addAdvice(advice);
/**
* List of Advisors. If an Advice is added, it will be wrapped
* in an Advisor before being added to this List.
*/
private List advisors = new LinkedList(); //advice就是一个声明，跟serializble一样
//进入AdvisedSupport
public void addAdvice(Advice advice) throws AopConfigException { int pos = this.advisors.size(); addAdvice(pos, advice); } public void addAdvice(int pos, Advice advice) throws AopConfigException { Assert.notNull(advice, "Advice must not be null"); if (advice instanceof IntroductionInfo) { addAdvisor(pos, new DefaultIntroductionAdvisor(advice, (IntroductionInfo) advice)); } else if (advice instanceof DynamicIntroductionAdvice) { throw new AopConfigException("DynamicIntroductionAdvice may only be added as part of IntroductionAdvisor"); } else { addAdvisor(pos, new DefaultPointcutAdvisor(advice)); //普通的advice走这里 } } public DefaultPointcutAdvisor(Advice advice) { this(Pointcut.TRUE, advice);//Pointcut.TRUE表示所有方法，所有类都匹配 } public DefaultPointcutAdvisor(Pointcut pointcut, Advice advice) { this.pointcut = pointcut; setAdvice(advice); } //进入AbstractGenericPointcutAdvisor public void setAdvice(Advice advice) { this.advice = advice; } public void addAdvisor(int pos, Advisor advisor) throws AopConfigException { if (advisor instanceof IntroductionAdvisor) { validateIntroductionAdvisor((IntroductionAdvisor) advisor); } addAdvisorInternal(pos, advisor); } private void addAdvisorInternal(int pos, Advisor advisor) throws AopConfigException { ... this.advisors.add(pos, advisor); ... } 生成代理实例pf.getProxy();
//进入ProxyFactory
public Object getProxy() { return createAopProxy().getProxy(); } //进入父类ProxyCreatorSupport protected final synchronized AopProxy createAopProxy() { ... 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.isInterface() || Proxy.isProxyClass(targetClass)) { return new JdkDynamicAopProxy(config); } return new ObjenesisCglibAopProxy(config); //走cglib } else { return new JdkDynamicAopProxy(config); //走jdk动态代理 } } //进入ObjenesisCglibAopProxy的父类CglibAopProxy public CglibAopProxy(AdvisedSupport config) throws AopConfigException { ... this.advised = config; this.advisedDispatcher = new AdvisedDispatcher(this.advised); } //CglibAopProxy public Object getProxy() { return getProxy(null); } public Object getProxy(ClassLoader classLoader) { ... Class<?> rootClass = this.advised.getTargetClass(); Class<?> proxySuperClass = rootClass; ... // Validate the class, writing log messages as necessary. validateClassIfNecessary(proxySuperClass, classLoader); // Configure CGLIB Enhancer... Enhancer enhancer = createEnhancer(); ... enhancer.setSuperclass(proxySuperClass); enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised)); enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE); enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader)); .... // Generate the proxy class and create a proxy instance. return createProxyClassAndInstance(enhancer, callbacks); } //子类ObjenesisCglibAopProxy实现，无构造器创建对象 protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) { Class<?> proxyClass = enhancer.createClass(); Object proxyInstance = null; if (objenesis.isWorthTrying()) { proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache()); } if (proxyInstance == null) { // Regular instantiation via default constructor... proxyInstance = (this.constructorArgs != null ? proxyClass.getConstructor(this.constructorArgTypes).newInstance(this.constructorArgs) : proxyClass.newInstance()); } ((Factory) proxyInstance).setCallbacks(callbacks); return proxyInstance; } 进入Cglib2AopProxy的静态内部类DynamicAdvisedInterceptor
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { MethodInvocation invocation = null; Object oldProxy = null; boolean setProxyContext = false; Class targetClass = null; Object target = null; try { Object retVal = null; ... target = getTarget(); if (target != null) { targetClass = target.getClass(); } List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) { retVal = methodProxy.invoke(target, args); } else { invocation = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy); retVal = invocation.proceed(); //执行拦截器链,同下文jdk动态代理的aop一样 } retVal = massageReturnTypeIfNecessary(proxy, target, method, retVal); return retVal; } .... } 指定接口进行jdk动态代理
Waiter target = new NaiveWaiter();
BeforeAdvice advice = new GreetingBeforeAdvice();
//spring提供的代理工厂
ProxyFactory pf = new ProxyFactory(); //指定接口进行代理 pf.setInterfaces(target.getClass().getInterfaces()); //pf.setOptimize(true);//启用优化后则还将使用Cglib2AopProxy代理 //设置代理目标 pf.setTarget(target); //为代理目标添加增强 pf.addAdvice(advice); //生成代理实例 Waiter proxy = (Waiter) pf.getProxy(); 指定接口进行代理
//进入AdvisedSupport
public void setInterfaces(Class<?>... interfaces) { this.interfaces.clear(); for (Class<?> ifc : interfaces) { addInterface(ifc); } } public void addInterface(Class<?> intf) { ... if (!this.interfaces.contains(intf)) { this.interfaces.add(intf); ... } } ... //获取代理，进入JdkDynamicAopProxy public Object getProxy() { return getProxy(ClassUtils.getDefaultClassLoader()); //获取应用类加载器 } public Object getProxy(ClassLoader classLoader) { ... Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised); //获得需要代理的接口 findDefinedEqualsAndHashCodeMethods(proxiedInterfaces); //对Object的方法特殊处理 return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);//经典的jdk动态代理 } public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) { Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces(); ... boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);//有没有接口是SpringProxy的子类，这是个标志接口 boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);//opaque表示是否禁止将代理对象转换为Advised对象 int nonUserIfcCount = 0; if (addSpringProxy) { nonUserIfcCount++; } if (addAdvised) { nonUserIfcCount++; } Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount]; System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length); if (addSpringProxy) { proxiedInterfaces[specifiedInterfaces.length] = SpringProxy.class; }//一个标志类，由spring生产的 if (addAdvised) { proxiedInterfaces[proxiedInterfaces.length - 1] = Advised.class; } //Advised是一个代理配置类 return proxiedInterfaces;//又添加了俩接口 } private void findDefinedEqualsAndHashCodeMethods(Class<?>[] proxiedInterfaces) { for (Class<?> proxiedInterface : proxiedInterfaces) { Method[] methods = proxiedInterface.getDeclaredMethods(); for (Method method : methods) { if (AopUtils.isEqualsMethod(method)) { this.equalsDefined = true; } if (AopUtils.isHashCodeMethod(method)) { this.hashCodeDefined = true; } if (this.equalsDefined && this.hashCodeDefined) { return; //发现有复写equals和hashcode，接下来要进行代理 } } } } 当调用具体方法时proxy.greetTo("Brian");
final class JdkDynamicAopProxy implements ..., InvocationHandler { 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 { if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) { // The target does not implement the equals(Object) method itself. return equals(args[0]); } if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) { // The target does not implement the hashCode() method itself. return hashCode(); } if (!this.advised.opaque && method.getDeclaringClass().isInterface() && method.getDeclaringClass().isAssignableFrom(Advised.class)) { //调用了advised的方法 // Service invocations on ProxyConfig with the proxy config... return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args); } Object retVal; ... target = targetSource.getTarget(); //获取代理对象 if (target != null) { targetClass = target.getClass(); } // Get the interception chain for this method. List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); // 没有advice，走简单反射 if (chain.isEmpty()) { 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(); } ... return retVal; } ... } } public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) { MethodCacheKey cacheKey = new MethodCacheKey(method); List<Object> cached = this.methodCache.get(cacheKey);//缓存机制，毕竟构造耗时 if (cached == null) { cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice( this, method, targetClass);//获得某方法对应的Interceptor this.methodCache.put(cacheKey, cached); } return cached; } //进入DefaultAdvisorChainFactory public List<Object> getInterceptorsAndDynamicInterceptionAdvice( Advised config, Method method, Class<?> targetClass) { List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length); //里面存着MethodInterceptor Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass()); boolean hasIntroductions = hasMatchingIntroductions(config, actualClass); AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();//返回一个DefaultAdvisorAdapterRegistry for (Advisor advisor : config.getAdvisors()) { if (advisor instanceof PointcutAdvisor) {//我们的DefaultPointcutAdvisor // Add it conditionally. PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor; if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) { //匹配指定类 MethodInterceptor[] interceptors = registry.getInterceptors(advisor); //获得方法拦截器 MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher(); if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {//匹配指定方法 ... interceptorList.addAll(Arrays.asList(interceptors));//又转成list了 } } } ... } return interceptorList; } //进入DefaultAdvisorAdapterRegistry public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException { List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3); Advice advice = advisor.getAdvice(); if (advice instanceof MethodInterceptor) { interceptors.add((MethodInterceptor) advice); //如果实现了MethodInterceptor接口直接加入 } for (AdvisorAdapter adapter : this.adapters) { if (adapter.supportsAdvice(advice)) { //是否实现了相应advice interceptors.add(adapter.getInterceptor(advisor)); } } ... return interceptors.toArray(new MethodInterceptor[interceptors.size()]);//转化为数组返回 } //DefaultAdvisorAdapterRegistry在构造时会创建这三种adapter public DefaultAdvisorAdapterRegistry() { registerAdvisorAdapter(new MethodBeforeAdviceAdapter()); registerAdvisorAdapter(new AfterReturningAdviceAdapter()); registerAdvisorAdapter(new ThrowsAdviceAdapter()); } //以MethodBeforeAdviceAdapter为例 public boolean supportsAdvice(Advice advice) { return (advice instanceof MethodBeforeAdvice); } public MethodInterceptor getInterceptor(Advisor advisor) { MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice(); return new MethodBeforeAdviceInterceptor(advice); } protected ReflectiveMethodInvocation( Object proxy, Object target, Method method, Object[] arguments, Class targetClass, List<Object> interceptorsAndDynamicMethodMatchers) { this.proxy = proxy; this.target = target; this.targetClass = targetClass; this.method = BridgeMethodResolver.findBridgedMethod(method); this.arguments = arguments; this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers; } 执行拦截链invocation.proceed()
//进入ReflectiveMethodInvocation
public Object proceed() throws Throwable { // We start with an index of -1 and increment early. if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { return invokeJoinpoint(); //拦截器走到最后一个进行普通方法反射调用 } Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);//计数累加 if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) { ... } else { return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this); } } //进入MethodBeforeAdviceInterceptor public Object invoke(MethodInvocation mi) throws Throwable { this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() ); return mi.proceed(); } //终于进入自己实现的GreetingBeforeAdvice了 public void before(Method method, Object[] args, Object obj) throws Throwable { String clientName = (String) args[0]; System.out.println("How are you！Mr." + clientName + "."); } protected Object invokeJoinpoint() throws Throwable { return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments); } //进入AopUtils public static Object invokeJoinpointUsingReflection(Object target, Method method, Object[] args) throws Throwable { ... ReflectionUtils.makeAccessible(method); return method.invoke(target, args); //执行target方法 } ProxyFactory和ProxyFactoryBean的区别
- ProxyFactoryBean实现了Spring的FactoryBean接口，所以它跟Spring中的其它FactoryBean一样，都是基于工厂模式来获取一个bean的。
- ProxyFactoryBean就是用来获取一个对象的代理对象的FactoryBean。它也是继承自ProxyCreatorSupport类的，所以它的功能基本跟ProxyFactory差不多
- 只是ProxyFactory是用于编程式的创建代理对象。而ProxyFactoryBean用于在Spring的bean容器中创建基于bean的代理对象
网上找的图，虽然丑，但画的非常好，把各个组件的关系描绘的分明
Spring配置
<bean id="forumServiceTarget" class="com.brianway.learning.spring.aop.advice.ForumService"/> <bean id="transactionManager" class="com.brianway.learning.spring.aop.advice.TransactionManager"/> <bean id="forumService" class="org.springframework.aop.framework.ProxyFactoryBean" p:interceptorNames="transactionManager" p:target-ref="forumServiceTarget" p:proxyTargetClass="false"/> <!--需要将ForumService抽成接口，不然会转用cglib--> //从获取bean开始
ForumServiceInterface forumService = (ForumServiceInterface) context.getBean("forumService");
//进入AbstractBeanFactory public Object getBean(String name) throws BeansException { return doGetBean(name, null, null, false); } protected <T> T doGetBean( final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException { final String beanName = transformedBeanName(name); Object bean; Object sharedInstance = getSingleton(beanName); //获得ProxyFactoryBean if (sharedInstance != null && args == null) { ... bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } ... return (T) bean; } protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, RootBeanDefinition mbd) { ... if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { return beanInstance; //不是factoryBean直接返回 } Object object = null; if (mbd == null) { object = getCachedObjectForFactoryBean(beanName);//先看缓存 } if (object == null) { FactoryBean<?> factory = (FactoryBean<?>) beanInstance; // Caches object obtained from FactoryBean if it is a singleton. if (mbd == null && containsBeanDefinition(beanName)) { mbd = getMergedLocalBeanDefinition(beanName); } boolean synthetic = (mbd != null && mbd.isSynthetic()); object = getObjectFromFactoryBean(factory, beanName, !synthetic); //factoryBean获取对象 } return object; } protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { Object object = this.factoryBeanObjectCache.get(beanName); if (object == null) { object = doGetObjectFromFactoryBean(factory, beanName); Object alreadyThere = this.factoryBeanObjectCache.get(beanName); //先从缓存找 if (alreadyThere != null) { object = alreadyThere; } else { if (object != null && shouldPostProcess) { object = postProcessObjectFromFactoryBean(object, beanName); //后置处理器 } this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT)); //放入缓存 } } return (object != NULL_OBJECT ? object : null); } private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName) throws BeanCreationException { Object object; ... object = factory.getObject(); ... return object; } ProxyFactoryBean获取对象
public Object getObject() throws BeansException {
initializeAdvisorChain(); //初始化拦截器链
if (isSingleton()) {
return getSingletonInstance(); } else { return newPrototypeInstance(); } } private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException { if (this.advisorChainInitialized) { return;//已经初始化过了直接返回 } if (!ObjectUtils.isEmpty(this.interceptorNames)) { ... for (String name : this.interceptorNames) { if (name.endsWith(GLOBAL_SUFFIX)) { ... } else { Object advice; if (this.singleton || this.beanFactory.isSingleton(name)) { advice = this.beanFactory.getBean(name);//从bean获得advice } else { advice = new PrototypePlaceholderAdvisor(name); } addAdvisorOnChainCreation(advice, name); } } } this.advisorChainInitialized = true; } private void addAdvisorOnChainCreation(Object next, String name) { Advisor advisor = namedBeanToAdvisor(next); //转换成相应的advisor addAdvisor(advisor); } private Advisor namedBeanToAdvisor(Object next) { return this.advisorAdapterRegistry.wrap(next); } //进入DefaultAdvisorAdapterRegistry public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException { if (adviceObject instanceof Advisor) { return (Advisor) adviceObject; } ... Advice advice = (Advice) adviceObject; if (advice instanceof MethodInterceptor) { return new DefaultPointcutAdvisor(advice); } for (AdvisorAdapter adapter : this.adapters) { if (adapter.supportsAdvice(advice)) { return new DefaultPointcutAdvisor(advice); } } throw new UnknownAdviceTypeException(advice); } private synchronized Object getSingletonInstance() { if (this.singletonInstance == null) { this.targetSource = freshTargetSource(); if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) { Class<?> targetClass = getTargetClass(); setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader)); //代理目标类的所有接口 } super.setFrozen(this.freezeProxy); this.singletonInstance = getProxy(createAopProxy()); } return this.singletonInstance; } private TargetSource freshTargetSource() { if (this.targetName == null) { return this.targetSource; } else { ... } } //进入父类ProxyCreatorSupport，和之前分析一样，就不赘述了 protected final synchronized AopProxy createAopProxy() { ... return getAopProxyFactory().createAopProxy(this); } protected Object getProxy(AopProxy aopProxy) { return aopProxy.getProxy(this.proxyClassLoader); } //进入JdkDynamicAopProxy，生成代理对象 public Object getProxy(ClassLoader classLoader) { Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised); findDefinedEqualsAndHashCodeMethods(proxiedInterfaces); return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); } aspectj注解的代理
- 用户通过配置XML <aop:aspectj-autoproxy>或@EnableAspectJAutoProxy注解来开启AOP自动代理对象，spring IOC容器在启动时会将配置的目标对象bean、切面及相关通知信息，解析成Advisor对象对应的BeanDefintion，并把代理对象的配置信息保存在ProxyConfig对象中。
- AbstractAutoProxyCreator继承了ProxyConfig，且实现了SmartInstantiationAwareBeanPostProcessor , BeanFactoryAware接口，这意味着当IOC容器启动时，会创建AbstractAutoProxyCreator对象，实现了BeanFactoryAware意味着，在AbstractAutoProxyCreator实例初始化阶段，BeanFactory自动注入DefaultListableBeanFactory工厂给AbstractAutoProxyCreator实例使用，有BeanFactory对象则可以通过getBean方法来访问容器中所有的通知对象Advisor相关信息.
- 每当调用BeanFactory取得bean对象时，利用实现了SmartInstantiationAwareBeanPostProcessor的后置处理器功能，BeanFactory会在多个阶段自动调用AbstractAutoProxyCreator这个后置处理器的实现方法，这些实现方法用来判断该Bean是否需要代理，判断Bean是否需要的代理的依据是根据该bean对象是否在IOC容器中存在匹配的一个或多个通知Advisor对象，存在则需要代理，否则，就放过。
Spring Aop只是借鉴aspectj的定义，提供注解驱动的AOP，本质上还是用的aop的动态代理，这种风格的好处就是不需要使用XML进行配置
参考文档:
ajc环境配置：
编译时织入（Compile Time Weaving, CTW） 载入（Load Time Weaving, LTW）时织入。
只需要配 ajc compiler:aspectjtools.jar，其他不勾选，1.7的aspectjtools，字节码选1.5？ 注意先清空target目录，再全项目编译