如何使用Spring AOP
　　可以通过配置文件或者编程的方式来使用Spring AOP。
　　配置可以通过xml文件来进行，大概有四种方式：
　　1.        配置ProxyFactoryBean，显式地设置advisors， advice， target等
　　2.        配置AutoProxyCreator，这种方式下，还是如以前一样使用定义的bean，但是从容器中获得的其实已经是代理对象
　　3.        通过<aop:config>来配置
　　4.        通过<aop: aspectj-autoproxy>来配置，使用AspectJ的注解来标识通知及切入点
　　也可以直接使用ProxyFactory来以编程的方式使用Spring AOP，通过ProxyFactory提供的方法可以设置target对象， advisor等相关配置，终通过 getProxy()方法来获取代理对象
　　具体使用的示例可以google. 这里略去
　　Spring AOP代理对象的生成
　　Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。下面我们来研究一下Spring如何使用JDK来生成代理对象，具体的生成代码放在JdkDynamicAopProxy这个类中，直接上相关代码：
　　/**
　　* <ol>
　　* <li>获取代理类要实现的接口，除了Advised对象中配置的，还会加上SpringProxy， Advised(opaque=false)
　　* <li>检查上面得到的接口中有没有定义 equals或者hashcode的接口
　　* <li>调用Proxy.newProxyInstance创建代理对象
　　* </ol>
　　*/
　　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);
　　findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
　　return Proxy.newProxyInstance(classLoader， proxiedInterfaces， this);
　　}
　　那这个其实很明了，注释上我也已经写清楚了，不再赘述。
　　下面的问题是，代理对象生成了，那切面是如何织入的？
　　我们知道InvocationHandler是JDK动态代理的核心，生成的代理对象的方法调用都会委托到InvocationHandler.invoke()方法。而通过JdkDynamicAopProxy的签名我们可以看到这个类其实也实现了InvocationHandler，下面我们通过分析这个类中实现的invoke()方法来具体看下Spring AOP是如何织入切面的。
publicObject invoke(Object proxy， Method method， Object[] args) throwsThrowable {
MethodInvocation invocation = null;
Object oldProxy = null;
boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Class targetClass = null;
Object target = null;
try {
//eqauls()方法，具目标对象未实现此方法
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)){
return (equals(args[0])? Boolean.TRUE : Boolean.FALSE);
}
//hashCode()方法，具目标对象未实现此方法
if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)){
return newInteger(hashCode());
}
//Advised接口或者其父接口中定义的方法，直接反射调用，不应用通知
if (!this.advised.opaque &&method.getDeclaringClass().isInterface()
&&method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations onProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised，method， args);
}
Object retVal = null;
if (this.advised.exposeProxy) {
// Make invocation available ifnecessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
//获得目标对象的类
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
//获取可以应用到此方法上的Interceptor列表
List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method，targetClass);
//如果没有可以应用到此方法的通知(Interceptor)，此直接反射调用 method.invoke(target， args)
if (chain.isEmpty()) {
retVal = AopUtils.invokeJoinpointUsingReflection(target，method， args);
} else {
//创建MethodInvocation
invocation = newReflectiveMethodInvocation(proxy， target， method， args， targetClass， chain);
retVal = invocation.proceed();
}
// Massage return value if necessary.
if (retVal != null && retVal == target &&method.getReturnType().isInstance(proxy)
&&!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned"this" and the return type of the method
// is type-compatible. Notethat we can't help if the target sets
// a reference to itself inanother returned object.
retVal = proxy;
}
return retVal;
} finally {
if (target != null && !targetSource.isStatic()) {
// Must have come fromTargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}