目录
AOP及Spring AOP原理介绍
通俗简单地理解，aop的原理是：在代码编译或项目启动运行的时候生成代理对象，代理对象糅合了被拦截方法和切面逻辑方法的执行。
AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理对象，AOP 代理主要分为静态代理和动态代理两大类，静态代理为编译时增强，动态代理为运行时增强。
静态代理中AspectJ是一个面向切面的框架，它扩展了Java语言，定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。动态代理则不需要专门的编译器和扩展语法，而是在字节码级别进行运行时的增强生成代理对象，常见的有jdk和cglib动态代理。
spring支持的AOP实现方式：编程式的AOP实现，XML配置的AOP实现，Aspect注解配置的AOP实现。
XML配置和Aspect注解配置底层机制都是通过编程式的AOP来实现，即使用jdk或cglib动态代理来实现运行时的增强（动态代理）。
可参考：http://blog.jobbole.com/28791/
AOP使用场景
AOP用来封装横切关注点，具体可以在下面的场景中使用:
Log 日志
Authentication 权限
Caching 缓存
Persistence 持久化
Resource pooling 资源池
Synchronization 同步
Transactions 事务
Context passing 内容传递
Error handling 错误处理
Lazy loading 懒加载
Debugging 调试
logging, tracing, profiling and monitoring 记录跟踪 优化 校准
Performance optimization 性能优化
spring AOP基础概念和核心类介绍
切面(aspect)：用来切插业务方法的类。
连接点(joinpoint)：是切面类和业务类的连接点，其实就是封装了业务方法的一些基本属性，作为通知的参数来解析。
通知/增强(advice)：这个术语用增强来描述更为贴切，它是在切面类中，声明对业务方法做切面增强的方法。
切入点(pointcut)：业务类中指定的方法，作为切面切入的点。其实就是指定某个方法作为切面切的地方。
目标对象(target object)：被代理对象。
AOP代理(aop proxy)：代理对象。
通知/增强器(advisor)：定义在哪个关注点应该使用哪个增强（advice），即将advice和pointcut结合起来。
具体的advice有：
前置增强(before advice)：在切入点之前执行。
后置增强(after returning advice)：在切入点执行完成后，执行通知。
环绕增强(around advice)：包围切入点，调用方法前后完成自定义行为。
异常增强(after throwing advice)：在切入点抛出异常后，执行通知。
了解了上面的基础概念之后我们来看下spring对AOP设计上的核心类框架。spring AOP的设计核心主要有两个要点：
1.如何生成代理对象；
2.代理对象的拦截器如何进行处理来实现AOP功能;
因此根据这两条主线来分别分析AOP的设计：
生成代理对象主要是通过ProxyConfig的这条继承线来设计实现的。作为共同基类，ProxyConfig为子类提供了AOP的配置属性，其子类AdvisedSupport封装了AOP对通知和通知器的相关操作，ProxyCreatorSupport可以看成是其子类创建AOP代理对象的一个辅助类。
深入源码分析之创建代理对象
DefaultAopProxyFactory是策略层面上创建代理对象的工厂类，创建代理对象代码如下：
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
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);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}代理对象的生成中，首先要从AdvisedSupport对象中取得配置的目标对象，如果没有配置目标对象会抛出异常。在对目标对象配置的检查完成之后，需要根据配置的情况来决定用什么方式创建代理对象。默认的方式是使用JDK来产生代理对象，但是如果遇到的配置的目标对象不是接口类的实现，会使用Cglib来生成代理对象。
来研究一下Spring如何使用JDK来生成代理对象，具体的生成代码放在JdkDynamicAopProxy这个类中：
@Override
public Object getProxy() {
return getProxy(ClassUtils.getDefaultClassLoader());
}
@Override
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}jdk创建代理对象需要三个参数: 类加载器、代理接口、代理回调方法所在的对象实例。通过AopProxyUtils.completeProxiedInterfaces(this.advised, true);来获取代理接口的具体实现中可以知道除了Advised对象中配置的,还会加上SpringProxy, Advised(opaque=false) 。JdkDynamicAopProxy本身就是代理回调方法所在的对象，它完成AOP的功能，这个另一条主线要讲的，下面会详细来分析。
jdk动态代理的原理机制可查看这篇博客：JDK动态代理-超详细源码分析。
接下来看下CGLIB如何实现对代理对象的生成，具体是在CglibAopProxy类中实现：
@Override
public Object getProxy() {
return getProxy(null);
}
@Override
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
}
try {
Class<?> rootClass = this.advised.getTargetClass();
Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
Class<?> proxySuperClass = rootClass;
if (ClassUtils.isCglibProxyClass(rootClass)) {
proxySuperClass = rootClass.getSuperclass();
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
for (Class<?> additionalInterface : additionalInterfaces) {
this.advised.addInterface(additionalInterface);
}
}
// Validate the class, writing log messages as necessary.
validateClassIfNecessary(proxySuperClass, classLoader);
// Configure 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);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) {
types[x] = callbacks[x].getClass();
}
// fixedInterceptorMap only populated at this point, after getCallbacks call above
enhancer.setCallbackFilter(new ProxyCallbackFilter(
this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
// Generate the proxy class and create a proxy instance.
return createProxyClassAndInstance(enhancer, callbacks);
}
catch (CodeGenerationException ex) {
throw new AopConfigException("Could not generate CGLIB subclass of class [" +
this.advised.getTargetClass() + "]: " +
"Common causes of this problem include using a final class or a non-visible class",
ex);
}
catch (IllegalArgumentException ex) {
throw new AopConfigException("Could not generate CGLIB subclass of class [" +
this.advised.getTargetClass() + "]: " +
"Common causes of this problem include using a final class or a non-visible class",
ex);
}
catch (Throwable ex) {
// TargetSource.getTarget() failed
throw new AopConfigException("Unexpected AOP exception", ex);
}
}在代码清单中可以看到具体对CGLIB的使用，比如对Enhancer对象的配置，以及通过Enhancer对象生成代理对象的过程。其中要注意的是Enhancer的callback回调的设置。通过回调设置，实际采用了DynamicAdvisedInterceptor拦截器来完成AOP的功能，这个另一条主线要讲的，下面会详细来分析。
深入源码分析之代理对象AOP拦截器调用实现
生成AOP代理对象的时候，相关的拦截器已经配置到代理对象中去了，拦截器在代理对象中起作用是通过拦截器的方法的回调来完成的。JdkDynamicAopProxy类实现的回调方法：
/**
* Implementation of {@code InvocationHandler.invoke}.
* <p>Callers will see exactly the exception thrown by the target,
* unless a hook method throws an exception.
*/
@Override
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]);
}
else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
else if (method.getDeclaringClass() == DecoratingProxy.class) {
// There is only getDecoratedClass() declared -> dispatch to proxy config.
return AopProxyUtils.ultimateTargetClass(this.advised);
}
else 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();
}
// 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 != Object.class && 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;
}
finally {
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}Cglib对于AOP的拦截回调是在DynamicAdvisedInterceptor对象中实现的，实现如下：
/**
* General purpose AOP callback. Used when the target is dynamic or when the
* proxy is not frozen.
*/
private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
private final AdvisedSupport advised;
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;
Class<?> targetClass = null;
Object target = null;
try {
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 = getTarget();
if (target != null) {
targetClass = target.getClass();
}
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// Check whether we only have one InvokerInterceptor: that is,
// no real advice, but just reflective invocation of the target.
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// 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 = methodProxy.invoke(target, argsToUse);
}
else {
// We need to create a method invocation...
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null) {
releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
...
}
520
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
