Authentication 权限

Caching 缓存

Context passing 内容传递

Error handling 错误处理

Lazy loading　懒加载

Debugging　　调试

logging, tracing, profiling and monitoring　记录跟踪　优化　校准

Performance optimization　性能优化

Persistence　　持久化

Resource pooling　资源池

Synchronization　同步

Transactions 事务

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);

           }

       }

    }  

public List<Object>getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) {

                   MethodCacheKeycacheKey = new MethodCacheKey(method);

                   List<Object>cached = this.methodCache.get(cacheKey);

                   if(cached == null) {

                            cached= this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(

                                               this,method, targetClass);

                            this.methodCache.put(cacheKey,cached);

                   }

                   returncached;

         }  

if (chain.isEmpty()) {

                retVal = AopUtils.invokeJoinpointUsingReflection(target,method, args);

            } else {

                //创建MethodInvocation

                invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);

                retVal = invocation.proceed();

            }  

public Object proceed() throws Throwable {

       //  We start with an index of -1and increment early.

       if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size()- 1) {

           //如果Interceptor执行完了，则执行joinPoint

           return invokeJoinpoint();

       }  

       Object interceptorOrInterceptionAdvice =

           this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);  

       //如果要动态匹配joinPoint

       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)) {

                //执行当前Intercetpor

                returndm.interceptor.invoke(this);

           }

           else {

                //动态匹配失败时,略过当前Intercetpor,调用下一个Interceptor

                return proceed();

           }

       }

       else {

           // It's an interceptor, so we just invoke it: The pointcutwill have

           // been evaluated statically before this object was constructed.

           //执行当前Intercetpor

           return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);

       }

}