pfnie
pfnie

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）

目录(?)[+]

  1. 前言
  2. Spring内部创建代理对象的过程
  3. Spring AOP的核心---ProxyFactoryBean
  4. 基于JDK面向接口的动态代理JdkDynamicAopProxy生成代理对象
  5. 基于Cglib子类继承方式的动态代理CglibAopProxy生成代理对象
  6. 各种Advice是的执行顺序是如何和方法调用进行结合的
  7. PointCut与Advice的结合------Adivce的条件执行
  8. 总结

0、前言

     在上篇文章 《Spring设计思想》AOP设计基本原理 中阐述了Spring AOP 的基本原理以及基本机制，本文将深入源码，详细阐述整个Spring AOP实现的整个过程。

    

读完本文，你将了解到：
1、Spring内部创建代理对象的过程
2、Spring AOP的核心---ProxyFactoryBean
3、基于JDK面向接口的动态代理JdkDynamicAopProxy生成代理对象
4、基于Cglib子类继承方式的动态代理CglibAopProxy生成代理对象
5、各种Advice是的执行顺序是如何和方法调用进行结合的？
6、PointCut与Advice的结合------Adivce的条件执行
7、总结

1、Spring内部创建代理对象的过程

            在spring的底层，如果我们配置了代理模式，Spring会为每一个Bean创建一个对应的ProxyFactoryBean的FactoryBean来创建某个对象的代理对象。

            假定我们现在有一个接口TicketService及其实现类RailwayStation，我们打算创建一个代理类，在执行TicketService的方法时的各个阶段，插入对应的业务代码。

[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. /** 
  4.  * 售票服务 
  5.  * Created by louis on 2016/4/14. 
  6.  */  
  7. public interface TicketService {  
  8.   
  9.     //售票  
  10.     public void sellTicket();  
  11.   
  12.     //问询  
  13.     public void inquire();  
  14.   
  15.     //退票  
  16.     public void withdraw();  
  17. }  

[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. /** 
  4.  * RailwayStation 实现 TicketService 
  5.  * Created by louis on 2016/4/14. 
  6.  */  
  7. public class RailwayStation implements TicketService {  
  8.   
  9.     public void sellTicket(){  
  10.         System.out.println("售票............");  
  11.     }  
  12.   
  13.     public void inquire() {  
  14.         System.out.println("问询.............");  
  15.     }  
  16.   
  17.     public void withdraw() {  
  18.         System.out.println("退票.............");  
  19.     }  
  20. }  

[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. import org.springframework.aop.MethodBeforeAdvice;  
  4.   
  5. import java.lang.reflect.Method;  
  6.   
  7. /** 
  8.  * 执行RealSubject对象的方法之前的处理意见 
  9.  * Created by louis on 2016/4/14. 
  10.  */  
  11. public class TicketServiceBeforeAdvice implements MethodBeforeAdvice {  
  12.   
  13.     public void before(Method method, Object[] args, Object target) throws Throwable {  
  14.         System.out.println("BEFORE_ADVICE: 欢迎光临代售点....");  
  15.     }  
  16. }  

[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. import org.springframework.aop.AfterReturningAdvice;  
  4.   
  5. import java.lang.reflect.Method;  
  6.   
  7. /** 
  8.  * 返回结果时后的处理意见 
  9.  * Created by louis on 2016/4/14. 
  10.  */  
  11. public class TicketServiceAfterReturningAdvice implements AfterReturningAdvice {  
  12.     @Override  
  13.     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {  
  14.         System.out.println("AFTER_RETURNING：本次服务已结束....");  
  15.     }  
  16. }  

[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. import org.springframework.aop.ThrowsAdvice;  
  4.   
  5. import java.lang.reflect.Method;  
  6.   
  7. /** 
  8.  * 抛出异常时的处理意见 
  9.  * Created by louis on 2016/4/14. 
  10.  */  
  11. public class TicketServiceThrowsAdvice implements ThrowsAdvice {  
  12.   
  13.     public void afterThrowing(Exception ex){  
  14.         System.out.println("AFTER_THROWING....");  
  15.     }  
  16.     public void afterThrowing(Method method, Object[] args, Object target, Exception ex){  
  17.         System.out.println("调用过程出错啦！！！！！");  
  18.     }  
  19.   
  20. }   

[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. import org.aopalliance.intercept.MethodInterceptor;  
  4. import org.aopalliance.intercept.MethodInvocation;  
  5. import org.springframework.aop.aspectj.AspectJAroundAdvice;  
  6.   
  7. /** 
  8.  * 
  9.  * AroundAdvice 
  10.  * Created by louis on 2016/4/15. 
  11.  */  
  12. public class TicketServiceAroundAdvice implements MethodInterceptor {  
  13.     @Override  
  14.     public Object invoke(MethodInvocation invocation) throws Throwable {  
  15.         System.out.println("AROUND_ADVICE:BEGIN....");  
  16.         Object returnValue = invocation.proceed();  
  17.         System.out.println("AROUND_ADVICE:END.....");  
  18.         return returnValue;  
  19.     }  
  20. }  


《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第1张图片

               现在，我们来手动使用ProxyFactoryBean来创建Proxy对象，并将相应的几种不同的Advice加入这个proxy对应的各个执行阶段中：


[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. import org.aopalliance.aop.Advice;  
  4. import org.springframework.aop.framework.ProxyFactoryBean;  
  5.   
  6. /** 
  7.  * 通过ProxyFactoryBean 手动创建 代理对象 
  8.  * Created by louis on 2016/4/14. 
  9.  */  
  10. public class App {  
  11.   
  12.     public static void main(String[] args) throws Exception {  
  13.   
  14.         //1.针对不同的时期类型，提供不同的Advice  
  15.         Advice beforeAdvice = new TicketServiceBeforeAdvice();  
  16.         Advice afterReturningAdvice = new TicketServiceAfterReturningAdvice();  
  17.         Advice aroundAdvice = new TicketServiceAroundAdvice();  
  18.         Advice throwsAdvice = new TicketServiceThrowsAdvice();  
  19.   
  20.         RailwayStation railwayStation = new RailwayStation();  
  21.   
  22.         //2.创建ProxyFactoryBean,用以创建指定对象的Proxy对象  
  23.         ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();  
  24.        //3.设置Proxy的接口  
  25.         proxyFactoryBean.setInterfaces(TicketService.class);  
  26.         //4. 设置RealSubject  
  27.         proxyFactoryBean.setTarget(railwayStation);  
  28.         //5.使用JDK基于接口实现机制的动态代理生成Proxy代理对象，如果想使用CGLIB，需要将这个flag设置成true  
  29.         proxyFactoryBean.setProxyTargetClass(true);  
  30.   
  31.         //6. 添加不同的Advice  
  32.   
  33.         proxyFactoryBean.addAdvice(afterReturningAdvice);  
  34.         proxyFactoryBean.addAdvice(aroundAdvice);  
  35.         proxyFactoryBean.addAdvice(throwsAdvice);  
  36.         proxyFactoryBean.addAdvice(beforeAdvice);  
  37.         proxyFactoryBean.setProxyTargetClass(false);  
  38.         //7通过ProxyFactoryBean生成Proxy对象  
  39.         TicketService ticketService = (TicketService) proxyFactoryBean.getObject();  
  40.         ticketService.sellTicket();  
  41.   
  42.     }  
  43.   
  44.   
  45. }  


不出意外的话，你会得到如下的输出结果：

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第2张图片

你会看到，我们成功地创建了一个通过一个ProxyFactoryBean和 真实的实例对象创建出了对应的代理对象，并将各个Advice加入到proxy代理对象中。

你会发现，在调用RailwayStation的sellticket()之前，成功插入了BeforeAdivce逻辑，而调用RailwayStation的sellticket()之后，AfterReturning逻辑也成功插入了。

AroundAdvice也成功包裹了sellTicket()方法，只不过这个AroundAdvice发生的时机有点让人感到迷惑。实际上，这个背后的执行逻辑隐藏了Spring AOP关于AOP的关于Advice调度最为核心的算法机制，这个将在本文后面详细阐述。

另外，本例中ProxyFactoryBean是通过JDK的针对接口的动态代理模式生成代理对象的，具体机制，请看下面关于ProxyFactoryBean的介绍。

2、Spring AOP的核心---ProxyFactoryBean

          上面我们通过了纯手动使用ProxyFactoryBean实现了AOP的功能。现在来分析一下上面的代码：我们为ProxyFactoryBean提供了如下信息：

1). Proxy应该感兴趣的Adivce列表；

2). 真正的实例对象引用ticketService;

3).告诉ProxyFactoryBean使用基于接口实现的JDK动态代理机制实现proxy: 

4). Proxy应该具备的Interface接口：TicketService;

根据这些信息，ProxyFactoryBean就能给我们提供我们想要的Proxy对象了！那么，ProxyFactoryBean帮我们做了什么？

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第3张图片

              Spring 使用工厂Bean模式创建每一个Proxy，对应每一个不同的Class类型，在Spring中都会有一个相对应的ProxyFactoryBean. 以下是ProxyFactoryBean的类图。

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第4张图片

如上所示，对于生成Proxy的工厂Bean而言，它要知道对其感兴趣的Advice信息，而这类的信息，被维护到Advised中。Advised可以根据特定的类名和方法名返回对应的AdviceChain，用以表示需要执行的Advice串。


3、基于JDK面向接口的动态代理JdkDynamicAopProxy生成代理对象

JdkDynamicAopProxy类实现了AopProxy，能够返回Proxy，并且，其自身也实现了InvocationHandler角色。也就是说，当我们使用proxy时，我们对proxy对象调用的方法，都最终被转到这个类的invoke()方法中。

[java] view plain copy
print ?
  1. final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {  
  2.         //省略若干...  
  3.     /** Proxy的配置信息，这里主要提供Advisor列表，并用于返回AdviceChain */  
  4.     private final AdvisedSupport advised;  
  5.   
  6.     /** 
  7.      * Construct a new JdkDynamicAopProxy for the given AOP configuration. 
  8.      * @param config the AOP configuration as AdvisedSupport object 
  9.      * @throws AopConfigException if the config is invalid. We try to throw an informative 
  10.      * exception in this case, rather than let a mysterious failure happen later. 
  11.      */  
  12.     public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {  
  13.         Assert.notNull(config, "AdvisedSupport must not be null");  
  14.         if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {  
  15.             throw new AopConfigException("No advisors and no TargetSource specified");  
  16.         }  
  17.         this.advised = config;  
  18.     }  
  19.   
  20.   
  21.     @Override  
  22.     public Object getProxy() {  
  23.         return getProxy(ClassUtils.getDefaultClassLoader());  
  24.     }  
  25.         //返回代理实例对象  
  26.     @Override  
  27.     public Object getProxy(ClassLoader classLoader) {  
  28.         if (logger.isDebugEnabled()) {  
  29.             logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());  
  30.         }  
  31.         Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);  
  32.         findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);  
  33.                 //这里的InvocationHandler设置成了当前实例对象，即对这个proxy调用的任何方法，都会调用这个类的invoke()方法  
  34.                 //这里的invoke方法被调用，动态查找Advice列表，组成ReflectMethodInvocation  
  35.         return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);  
  36.     }  
  37.     /** 
  38.      * 对当前proxy调用其上的任何方法，都将转到这个方法上 
  39.          * Implementation of {@code InvocationHandler.invoke}. 
  40.      * <p>Callers will see exactly the exception thrown by the target, 
  41.      * unless a hook method throws an exception. 
  42.      */  
  43.     @Override  
  44.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  45.         MethodInvocation invocation;  
  46.         Object oldProxy = null;  
  47.         boolean setProxyContext = false;  
  48.   
  49.         TargetSource targetSource = this.advised.targetSource;  
  50.         Class<?> targetClass = null;  
  51.         Object target = null;  
  52.   
  53.         try {  
  54.             if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {  
  55.                 // The target does not implement the equals(Object) method itself.  
  56.                 return equals(args[0]);  
  57.             }  
  58.             if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {  
  59.                 // The target does not implement the hashCode() method itself.  
  60.                 return hashCode();  
  61.             }  
  62.             if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&  
  63.                     method.getDeclaringClass().isAssignableFrom(Advised.class)) {  
  64.                 // Service invocations on ProxyConfig with the proxy config...  
  65.                 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);  
  66.             }  
  67.   
  68.             Object retVal;  
  69.   
  70.             if (this.advised.exposeProxy) {  
  71.                 // Make invocation available if necessary.  
  72.                 oldProxy = AopContext.setCurrentProxy(proxy);  
  73.                 setProxyContext = true;  
  74.             }  
  75.   
  76.             // May be null. Get as late as possible to minimize the time we "own" the target,  
  77.             // in case it comes from a pool.  
  78.             target = targetSource.getTarget();  
  79.             if (target != null) {  
  80.                 targetClass = target.getClass();  
  81.             }  
  82.   
  83.             // Get the interception chain for this method.获取当前调用方法的拦截链  
  84.             List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);  
  85.   
  86.             // Check whether we have any advice. If we don't, we can fallback on direct  
  87.             // reflective invocation of the target, and avoid creating a MethodInvocation.  
  88.                         //如果没有拦截链，则直接调用Joinpoint连接点的方法。  
  89.             if (chain.isEmpty()) {  
  90.                 // We can skip creating a MethodInvocation: just invoke the target directly  
  91.                 // Note that the final invoker must be an InvokerInterceptor so we know it does  
  92.                 // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.  
  93.                 Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);  
  94.                 retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);  
  95.             }  
  96.             else {  
  97.                 // We need to create a method invocation...  
  98.                                 //根据给定的拦截链和方法调用信息，创建新的MethodInvocation对象，整个拦截链的工作逻辑都在这个ReflectiveMethodInvocation里   
  99.                 invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);  
  100.                 // Proceed to the joinpoint through the interceptor chain.  
  101.                 retVal = invocation.proceed();  
  102.             }  
  103.   
  104.             // Massage return value if necessary.  
  105.             Class<?> returnType = method.getReturnType();  
  106.             if (retVal != null && retVal == target && returnType.isInstance(proxy) &&  
  107.                     !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {  
  108.                 // Special case: it returned "this" and the return type of the method  
  109.                 // is type-compatible. Note that we can't help if the target sets  
  110.                 // a reference to itself in another returned object.  
  111.                 retVal = proxy;  
  112.             }  
  113.             else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {  
  114.                 throw new AopInvocationException(  
  115.                         "Null return value from advice does not match primitive return type for: " + method);  
  116.             }  
  117.             return retVal;  
  118.         }  
  119.         finally {  
  120.             if (target != null && !targetSource.isStatic()) {  
  121.                 // Must have come from TargetSource.  
  122.                 targetSource.releaseTarget(target);  
  123.             }  
  124.             if (setProxyContext) {  
  125.                 // Restore old proxy.  
  126.                 AopContext.setCurrentProxy(oldProxy);  
  127.             }  
  128.         }  
  129.     }  
  130. }  

4、基于Cglib子类继承方式的动态代理CglibAopProxy生成代理对象

基于Cglib子类继承方式的动态代理CglibAopProxy生成代理对象：

[java] view plain copy
print ?
  1. package org.springframework.aop.framework;  
  2. /** 
  3.  * CGLIB-based {@link AopProxy} implementation for the Spring AOP framework. 
  4.  * 
  5.  * <p>Formerly named {@code Cglib2AopProxy}, as of Spring 3.2, this class depends on 
  6.  * Spring's own internally repackaged version of CGLIB 3.</i>. 
  7.  */  
  8. @SuppressWarnings("serial")  
  9. class CglibAopProxy implements AopProxy, Serializable {  
  10.   
  11.     // Constants for CGLIB callback array indices  
  12.     private static final int AOP_PROXY = 0;  
  13.     private static final int INVOKE_TARGET = 1;  
  14.     private static final int NO_OVERRIDE = 2;  
  15.     private static final int DISPATCH_TARGET = 3;  
  16.     private static final int DISPATCH_ADVISED = 4;  
  17.     private static final int INVOKE_EQUALS = 5;  
  18.     private static final int INVOKE_HASHCODE = 6;  
  19.   
  20.   
  21.     /** Logger available to subclasses; static to optimize serialization */  
  22.     protected static final Log logger = LogFactory.getLog(CglibAopProxy.class);  
  23.   
  24.     /** Keeps track of the Classes that we have validated for final methods */  
  25.     private static final Map<Class<?>, Boolean> validatedClasses = new WeakHashMap<Class<?>, Boolean>();  
  26.   
  27.   
  28.     /** The configuration used to configure this proxy */  
  29.     protected final AdvisedSupport advised;  
  30.   
  31.     protected Object[] constructorArgs;  
  32.   
  33.     protected Class<?>[] constructorArgTypes;  
  34.   
  35.     /** Dispatcher used for methods on Advised */  
  36.     private final transient AdvisedDispatcher advisedDispatcher;  
  37.   
  38.     private transient Map<String, Integer> fixedInterceptorMap;  
  39.   
  40.     private transient int fixedInterceptorOffset;  
  41.   
  42.   
  43.     /** 
  44.      * Create a new CglibAopProxy for the given AOP configuration. 
  45.      * @param config the AOP configuration as AdvisedSupport object 
  46.      * @throws AopConfigException if the config is invalid. We try to throw an informative 
  47.      * exception in this case, rather than let a mysterious failure happen later. 
  48.      */  
  49.     public CglibAopProxy(AdvisedSupport config) throws AopConfigException {  
  50.         Assert.notNull(config, "AdvisedSupport must not be null");  
  51.         if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {  
  52.             throw new AopConfigException("No advisors and no TargetSource specified");  
  53.         }  
  54.         this.advised = config;  
  55.         this.advisedDispatcher = new AdvisedDispatcher(this.advised);  
  56.     }  
  57.   
  58.     /** 
  59.      * Set constructor arguments to use for creating the proxy. 
  60.      * @param constructorArgs the constructor argument values 
  61.      * @param constructorArgTypes the constructor argument types 
  62.      */  
  63.     public void setConstructorArguments(Object[] constructorArgs, Class<?>[] constructorArgTypes) {  
  64.         if (constructorArgs == null || constructorArgTypes == null) {  
  65.             throw new IllegalArgumentException("Both 'constructorArgs' and 'constructorArgTypes' need to be specified");  
  66.         }  
  67.         if (constructorArgs.length != constructorArgTypes.length) {  
  68.             throw new IllegalArgumentException("Number of 'constructorArgs' (" + constructorArgs.length +  
  69.                     ") must match number of 'constructorArgTypes' (" + constructorArgTypes.length + ")");  
  70.         }  
  71.         this.constructorArgs = constructorArgs;  
  72.         this.constructorArgTypes = constructorArgTypes;  
  73.     }  
  74.   
  75.   
  76.     @Override  
  77.     public Object getProxy() {  
  78.         return getProxy(null);  
  79.     }  
  80.   
  81.     @Override  
  82.     public Object getProxy(ClassLoader classLoader) {  
  83.         if (logger.isDebugEnabled()) {  
  84.             logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());  
  85.         }  
  86.   
  87.         try {  
  88.             Class<?> rootClass = this.advised.getTargetClass();  
  89.             Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");  
  90.   
  91.             Class<?> proxySuperClass = rootClass;  
  92.             if (ClassUtils.isCglibProxyClass(rootClass)) {  
  93.                 proxySuperClass = rootClass.getSuperclass();  
  94.                 Class<?>[] additionalInterfaces = rootClass.getInterfaces();  
  95.                 for (Class<?> additionalInterface : additionalInterfaces) {  
  96.                     this.advised.addInterface(additionalInterface);  
  97.                 }  
  98.             }  
  99.   
  100.             // Validate the class, writing log messages as necessary.  
  101.             validateClassIfNecessary(proxySuperClass, classLoader);  
  102.   
  103.             // Configure CGLIB Enhancer...  
  104.             Enhancer enhancer = createEnhancer();  
  105.             if (classLoader != null) {  
  106.                 enhancer.setClassLoader(classLoader);  
  107.                 if (classLoader instanceof SmartClassLoader &&  
  108.                         ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {  
  109.                     enhancer.setUseCache(false);  
  110.                 }  
  111.             }  
  112.             enhancer.setSuperclass(proxySuperClass);  
  113.             enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));  
  114.             enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);  
  115.             enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));  
  116.   
  117.             Callback[] callbacks = getCallbacks(rootClass);  
  118.             Class<?>[] types = new Class<?>[callbacks.length];  
  119.             for (int x = 0; x < types.length; x++) {  
  120.                 types[x] = callbacks[x].getClass();  
  121.             }  
  122.             // fixedInterceptorMap only populated at this point, after getCallbacks call above  
  123.             enhancer.setCallbackFilter(new ProxyCallbackFilter(  
  124.                     this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));  
  125.             enhancer.setCallbackTypes(types);  
  126.   
  127.             // Generate the proxy class and create a proxy instance.  
  128.             return createProxyClassAndInstance(enhancer, callbacks);  
  129.         }  
  130.         catch (CodeGenerationException ex) {  
  131.             throw new AopConfigException("Could not generate CGLIB subclass of class [" +  
  132.                     this.advised.getTargetClass() + "]: " +  
  133.                     "Common causes of this problem include using a final class or a non-visible class",  
  134.                     ex);  
  135.         }  
  136.         catch (IllegalArgumentException ex) {  
  137.             throw new AopConfigException("Could not generate CGLIB subclass of class [" +  
  138.                     this.advised.getTargetClass() + "]: " +  
  139.                     "Common causes of this problem include using a final class or a non-visible class",  
  140.                     ex);  
  141.         }  
  142.         catch (Exception ex) {  
  143.             // TargetSource.getTarget() failed  
  144.             throw new AopConfigException("Unexpected AOP exception", ex);  
  145.         }  
  146.     }  
  147.   
  148.     protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {  
  149.         enhancer.setInterceptDuringConstruction(false);  
  150.         enhancer.setCallbacks(callbacks);  
  151.         return (this.constructorArgs != null ?  
  152.                 enhancer.create(this.constructorArgTypes, this.constructorArgs) :  
  153.                 enhancer.create());  
  154.     }  
  155.   
  156.     /** 
  157.      * Creates the CGLIB {@link Enhancer}. Subclasses may wish to override this to return a custom 
  158.      * {@link Enhancer} implementation. 
  159.      */  
  160.     protected Enhancer createEnhancer() {  
  161.         return new Enhancer();  
  162.     }  
  163.   
  164.   
  165.   
  166.     private Callback[] getCallbacks(Class<?> rootClass) throws Exception {  
  167.         // Parameters used for optimisation choices...  
  168.         boolean exposeProxy = this.advised.isExposeProxy();  
  169.         boolean isFrozen = this.advised.isFrozen();  
  170.         boolean isStatic = this.advised.getTargetSource().isStatic();  
  171.   
  172.         // Choose an "aop" interceptor (used for AOP calls).  
  173.         Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);  
  174.   
  175.         // Choose a "straight to target" interceptor. (used for calls that are  
  176.         // unadvised but can return this). May be required to expose the proxy.  
  177.         Callback targetInterceptor;  
  178.         if (exposeProxy) {  
  179.             targetInterceptor = isStatic ?  
  180.                     new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :  
  181.                     new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource());  
  182.         }  
  183.         else {  
  184.             targetInterceptor = isStatic ?  
  185.                     new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :  
  186.                     new DynamicUnadvisedInterceptor(this.advised.getTargetSource());  
  187.         }  
  188.   
  189.         // Choose a "direct to target" dispatcher (used for  
  190.         // unadvised calls to static targets that cannot return this).  
  191.         Callback targetDispatcher = isStatic ?  
  192.                 new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp();  
  193.   
  194.         Callback[] mainCallbacks = new Callback[] {  
  195.                 aopInterceptor,  // for normal advice  
  196.                 targetInterceptor,  // invoke target without considering advice, if optimized  
  197.                 new SerializableNoOp(),  // no override for methods mapped to this  
  198.                 targetDispatcher, this.advisedDispatcher,  
  199.                 new EqualsInterceptor(this.advised),  
  200.                 new HashCodeInterceptor(this.advised)  
  201.         };  
  202.   
  203.         Callback[] callbacks;  
  204.   
  205.         // If the target is a static one and the advice chain is frozen,  
  206.         // then we can make some optimisations by sending the AOP calls  
  207.         // direct to the target using the fixed chain for that method.  
  208.         if (isStatic && isFrozen) {  
  209.             Method[] methods = rootClass.getMethods();  
  210.             Callback[] fixedCallbacks = new Callback[methods.length];  
  211.             this.fixedInterceptorMap = new HashMap<String, Integer>(methods.length);  
  212.   
  213.             // TODO: small memory optimisation here (can skip creation for methods with no advice)  
  214.             for (int x = 0; x < methods.length; x++) {  
  215.                 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);  
  216.                 fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(  
  217.                         chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());  
  218.                 this.fixedInterceptorMap.put(methods[x].toString(), x);  
  219.             }  
  220.   
  221.             // Now copy both the callbacks from mainCallbacks  
  222.             // and fixedCallbacks into the callbacks array.  
  223.             callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];  
  224.             System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);  
  225.             System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);  
  226.             this.fixedInterceptorOffset = mainCallbacks.length;  
  227.         }  
  228.         else {  
  229.             callbacks = mainCallbacks;  
  230.         }  
  231.         return callbacks;  
  232.     }  
  233.   
  234.   
  235.     /** 
  236.      * General purpose AOP callback. Used when the target is dynamic or when the 
  237.      * proxy is not frozen. 
  238.      */  
  239.     private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {  
  240.   
  241.         private final AdvisedSupport advised;  
  242.   
  243.         public DynamicAdvisedInterceptor(AdvisedSupport advised) {  
  244.             this.advised = advised;  
  245.         }  
  246.   
  247.         @Override  
  248.         public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {  
  249.             Object oldProxy = null;  
  250.             boolean setProxyContext = false;  
  251.             Class<?> targetClass = null;  
  252.             Object target = null;  
  253.             try {  
  254.                 if (this.advised.exposeProxy) {  
  255.                     // Make invocation available if necessary.  
  256.                     oldProxy = AopContext.setCurrentProxy(proxy);  
  257.                     setProxyContext = true;  
  258.                 }  
  259.                 // May be null. Get as late as possible to minimize the time we  
  260.                 // "own" the target, in case it comes from a pool...  
  261.                 target = getTarget();  
  262.                 if (target != null) {  
  263.                     targetClass = target.getClass();  
  264.                 }  
  265.                 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);  
  266.                 Object retVal;  
  267.                 // Check whether we only have one InvokerInterceptor: that is,  
  268.                 // no real advice, but just reflective invocation of the target.  
  269.                 if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {  
  270.                     // We can skip creating a MethodInvocation: just invoke the target directly.  
  271.                     // Note that the final invoker must be an InvokerInterceptor, so we know  
  272.                     // it does nothing but a reflective operation on the target, and no hot  
  273.                     // swapping or fancy proxying.  
  274.                     Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);  
  275.                     retVal = methodProxy.invoke(target, argsToUse);  
  276.                 }  
  277.                 else {  
  278.                     // We need to create a method invocation...  
  279.                     retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();  
  280.                 }  
  281.                 retVal = processReturnType(proxy, target, method, retVal);  
  282.                 return retVal;  
  283.             }  
  284.             finally {  
  285.                 if (target != null) {  
  286.                     releaseTarget(target);  
  287.                 }  
  288.                 if (setProxyContext) {  
  289.                     // Restore old proxy.  
  290.                     AopContext.setCurrentProxy(oldProxy);  
  291.                 }  
  292.             }  
  293.         }  
  294.         //省略...  
  295.     }  
  296.   
  297.   
  298.     /** 
  299.      * Implementation of AOP Alliance MethodInvocation used by this AOP proxy. 
  300.      */  
  301.     private static class CglibMethodInvocation extends ReflectiveMethodInvocation {  
  302.   
  303.         private final MethodProxy methodProxy;  
  304.   
  305.         private final boolean publicMethod;  
  306.   
  307.         public CglibMethodInvocation(Object proxy, Object target, Method method, Object[] arguments,  
  308.                 Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers, MethodProxy methodProxy) {  
  309.   
  310.             super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);  
  311.             this.methodProxy = methodProxy;  
  312.             this.publicMethod = Modifier.isPublic(method.getModifiers());  
  313.         }  
  314.   
  315.         /** 
  316.          * Gives a marginal performance improvement versus using reflection to 
  317.          * invoke the target when invoking public methods. 
  318.          */  
  319.         @Override  
  320.         protected Object invokeJoinpoint() throws Throwable {  
  321.             if (this.publicMethod) {  
  322.                 return this.methodProxy.invoke(this.target, this.arguments);  
  323.             }  
  324.             else {  
  325.                 return super.invokeJoinpoint();  
  326.             }  
  327.         }  
  328.     }  
  329.   
  330. }  


5、各种Advice是的执行顺序是如何和方法调用进行结合的？

JdkDynamicAopProxy 和CglibAopProxy只是创建代理方式的两种方式而已，实际上我们为方法调用添加的各种Advice的执行逻辑都是统一的。在Spring的底层，会把我们定义的各个Adivce分别 包裹成一个 MethodInterceptor,这些Advice按照加入Advised顺序，构成一个AdivseChain.

比如我们上述的代码：

[java] view plain copy
print ?
  1. //5. 添加不同的Advice  
  2.   
  3. proxyFactoryBean.addAdvice(afterReturningAdvice);  
  4. proxyFactoryBean.addAdvice(aroundAdvice);  
  5. proxyFactoryBean.addAdvice(throwsAdvice);  
  6. proxyFactoryBean.addAdvice(beforeAdvice);  
  7. proxyFactoryBean.setProxyTargetClass(false);  
  8. //通过ProxyFactoryBean生成  
  9. TicketService ticketService = (TicketService) proxyFactoryBean.getObject();  
  10. ticketService.sellTicket();  

当我们调用 ticketService.sellTicket()时，Spring会把这个方法调用转换成一个MethodInvocation对象，然后结合上述的我们添加的各种Advice,组成一个ReflectiveMethodInvocation:

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第5张图片

 各种Advice本质而言是一个方法调用拦截器，现在让我们看看各个Advice拦截器都干了什么？

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第6张图片

[java] view plain copy
print ?
  1. /** 
  2.  * 包裹MethodBeforeAdvice的方法拦截器 
  3.  * Interceptor to wrap am {@link org.springframework.aop.MethodBeforeAdvice}. 
  4.  * Used internally by the AOP framework; application developers should not need 
  5.  * to use this class directly. 
  6.  * 
  7.  * @author Rod Johnson 
  8.  */  
  9. @SuppressWarnings("serial")  
  10. public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {  
  11.   
  12.     private MethodBeforeAdvice advice;  
  13.   
  14.   
  15.     /** 
  16.      * Create a new MethodBeforeAdviceInterceptor for the given advice. 
  17.      * @param advice the MethodBeforeAdvice to wrap 
  18.      */  
  19.     public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {  
  20.         Assert.notNull(advice, "Advice must not be null");  
  21.         this.advice = advice;  
  22.     }  
  23.   
  24.     @Override  
  25.     public Object invoke(MethodInvocation mi) throws Throwable {  
  26.         //在调用方法之前，先执行BeforeAdvice  
  27.         this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );  
  28.         return mi.proceed();  
  29.     }  
  30.   
  31. }  

[java] view plain copy
print ?
  1. /** 
  2.  * 包裹AfterReturningAdvice的方法拦截器 
  3.  * Interceptor to wrap am {@link org.springframework.aop.AfterReturningAdvice}. 
  4.  * Used internally by the AOP framework; application developers should not need 
  5.  * to use this class directly. 
  6.  * 
  7.  * @author Rod Johnson 
  8.  */  
  9. @SuppressWarnings("serial")  
  10. public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {  
  11.   
  12.     private final AfterReturningAdvice advice;  
  13.   
  14.   
  15.     /** 
  16.      * Create a new AfterReturningAdviceInterceptor for the given advice. 
  17.      * @param advice the AfterReturningAdvice to wrap 
  18.      */  
  19.     public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {  
  20.         Assert.notNull(advice, "Advice must not be null");  
  21.         this.advice = advice;  
  22.     }  
  23.   
  24.     @Override  
  25.     public Object invoke(MethodInvocation mi) throws Throwable {  
  26.         //先调用invocation  
  27.         Object retVal = mi.proceed();  
  28.         //调用成功后，调用AfterReturningAdvice  
  29.         this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());  
  30.         return retVal;  
  31.     }  
  32.   
  33. }  

[java] view plain copy
print ?
  1. /** 
  2.  * Interceptor to wrap an after-throwing advice. 
  3.  * 
  4.  * <p>The signatures on handler methods on the {@code ThrowsAdvice} 
  5.  * implementation method argument must be of the form:<br> 
  6.  * 
  7.  * {@code void afterThrowing([Method, args, target], ThrowableSubclass);} 
  8.  * 
  9.  * <p>Only the last argument is required. 
  10.  * 
  11.  * <p>Some examples of valid methods would be: 
  12.  * 
  13.  * <pre class="code">public void afterThrowing(Exception ex)</pre> 
  14.  * <pre class="code">public void afterThrowing(RemoteException)</pre> 
  15.  * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, Exception ex)</pre> 
  16.  * <pre class="code">public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)</pre> 
  17.  * 
  18.  * <p>This is a framework class that need not be used directly by Spring users. 
  19.  * 
  20.  * @author Rod Johnson 
  21.  * @author Juergen Hoeller 
  22.  */  
  23. public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {  
  24.   
  25.     private static final String AFTER_THROWING = "afterThrowing";  
  26.   
  27.     private static final Log logger = LogFactory.getLog(ThrowsAdviceInterceptor.class);  
  28.   
  29.   
  30.     private final Object throwsAdvice;  
  31.   
  32.     /** Methods on throws advice, keyed by exception class */  
  33.     private final Map<Class<?>, Method> exceptionHandlerMap = new HashMap<Class<?>, Method>();  
  34.   
  35.   
  36.     /** 
  37.      * Create a new ThrowsAdviceInterceptor for the given ThrowsAdvice. 
  38.      * @param throwsAdvice the advice object that defines the exception 
  39.      * handler methods (usually a {@link org.springframework.aop.ThrowsAdvice} 
  40.      * implementation) 
  41.      */  
  42.     public ThrowsAdviceInterceptor(Object throwsAdvice) {  
  43.         Assert.notNull(throwsAdvice, "Advice must not be null");  
  44.         this.throwsAdvice = throwsAdvice;  
  45.   
  46.         Method[] methods = throwsAdvice.getClass().getMethods();  
  47.         for (Method method : methods) {  
  48.             //ThrowsAdvice定义的afterThrowing方法是Handler方法  
  49.             if (method.getName().equals(AFTER_THROWING) &&  
  50.                     (method.getParameterTypes().length == 1 || method.getParameterTypes().length == 4) &&  
  51.                     Throwable.class.isAssignableFrom(method.getParameterTypes()[method.getParameterTypes().length - 1])  
  52.                 ) {  
  53.                 // Have an exception handler  
  54.                 this.exceptionHandlerMap.put(method.getParameterTypes()[method.getParameterTypes().length - 1], method);  
  55.                 if (logger.isDebugEnabled()) {  
  56.                     logger.debug("Found exception handler method: " + method);  
  57.                 }  
  58.             }  
  59.         }  
  60.   
  61.         if (this.exceptionHandlerMap.isEmpty()) {  
  62.             throw new IllegalArgumentException(  
  63.                     "At least one handler method must be found in class [" + throwsAdvice.getClass() + "]");  
  64.         }  
  65.     }  
  66.   
  67.     public int getHandlerMethodCount() {  
  68.         return this.exceptionHandlerMap.size();  
  69.     }  
  70.   
  71.     /** 
  72.      * Determine the exception handle method. Can return null if not found. 
  73.      * @param exception the exception thrown 
  74.      * @return a handler for the given exception type 
  75.      */  
  76.     private Method getExceptionHandler(Throwable exception) {  
  77.         Class<?> exceptionClass = exception.getClass();  
  78.         if (logger.isTraceEnabled()) {  
  79.             logger.trace("Trying to find handler for exception of type [" + exceptionClass.getName() + "]");  
  80.         }  
  81.         Method handler = this.exceptionHandlerMap.get(exceptionClass);  
  82.         while (handler == null && exceptionClass != Throwable.class) {  
  83.             exceptionClass = exceptionClass.getSuperclass();  
  84.             handler = this.exceptionHandlerMap.get(exceptionClass);  
  85.         }  
  86.         if (handler != null && logger.isDebugEnabled()) {  
  87.             logger.debug("Found handler for exception of type [" + exceptionClass.getName() + "]: " + handler);  
  88.         }  
  89.         return handler;  
  90.     }  
  91.   
  92.     @Override  
  93.     public Object invoke(MethodInvocation mi) throws Throwable {  
  94.         //使用大的try，先执行代码，捕获异常  
  95.         try {  
  96.             return mi.proceed();  
  97.         }  
  98.         catch (Throwable ex) {  
  99.             //获取异常处理方法  
  100.             Method handlerMethod = getExceptionHandler(ex);  
  101.             //调用异常处理方法  
  102.             if (handlerMethod != null) {  
  103.                 invokeHandlerMethod(mi, ex, handlerMethod);  
  104.             }  
  105.             throw ex;  
  106.         }  
  107.     }  
  108.   
  109.     private void invokeHandlerMethod(MethodInvocation mi, Throwable ex, Method method) throws Throwable {  
  110.         Object[] handlerArgs;  
  111.         if (method.getParameterTypes().length == 1) {  
  112.             handlerArgs = new Object[] { ex };  
  113.         }  
  114.         else {  
  115.             handlerArgs = new Object[] {mi.getMethod(), mi.getArguments(), mi.getThis(), ex};  
  116.         }  
  117.         try {  
  118.             method.invoke(this.throwsAdvice, handlerArgs);  
  119.         }  
  120.         catch (InvocationTargetException targetEx) {  
  121.             throw targetEx.getTargetException();  
  122.         }  
  123.     }  
  124.   
  125. }  

关于AroundAdivce,其本身就是一个MethodInterceptor，所以不需要额外做转换了。

细心的你会发现，在拦截器串中，每个拦截器最后都会调用MethodInvocation的proceed()方法。如果按照简单的拦截器的执行串来执行的话，MethodInvocation的proceed()方法至少要执行N次(N表示拦截器Interceptor的个数)，因为每个拦截器都会调用一次proceed()方法。更直观地讲，比如我们调用了ticketService.sellTicket()方法，那么，按照这个逻辑，我们会打印出四条记录：

[plain] view plain copy
print ?
  1. 售票............  
  2. 售票............  
  3. 售票............  
  4. 售票............  
这样我们肯定不是我们需要的结果！！！！因为按照我们的理解，只应该有一条"售票............"才对。真实的Spring的方法调用过程能够控制这个逻辑按照我们的思路执行，Spring将这个整个方法调用过程连同若干个Advice组成的拦截器链组合成ReflectiveMethodInvocation对象，让我们来看看这一执行逻辑是怎么控制的：

[java] view plain copy
print ?
  1. public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {  
  2.   
  3.     protected final Object proxy;  
  4.   
  5.     protected final Object target;  
  6.   
  7.     protected final Method method;  
  8.   
  9.     protected Object[] arguments;  
  10.   
  11.     private final Class<?> targetClass;  
  12.   
  13.     /** 
  14.      * Lazily initialized map of user-specific attributes for this invocation. 
  15.      */  
  16.     private Map<String, Object> userAttributes;  
  17.   
  18.     /** 
  19.      * List of MethodInterceptor and InterceptorAndDynamicMethodMatcher 
  20.      * that need dynamic checks. 
  21.      */  
  22.     protected final List<?> interceptorsAndDynamicMethodMatchers;  
  23.   
  24.     /** 
  25.      * Index from 0 of the current interceptor we're invoking. 
  26.      * -1 until we invoke: then the current interceptor. 
  27.      */  
  28.     private int currentInterceptorIndex = -1;  
  29.   
  30.   
  31.     /** 
  32.      * Construct a new ReflectiveMethodInvocation with the given arguments. 
  33.      * @param proxy the proxy object that the invocation was made on 
  34.      * @param target the target object to invoke 
  35.      * @param method the method to invoke 
  36.      * @param arguments the arguments to invoke the method with 
  37.      * @param targetClass the target class, for MethodMatcher invocations 
  38.      * @param interceptorsAndDynamicMethodMatchers interceptors that should be applied, 
  39.      * along with any InterceptorAndDynamicMethodMatchers that need evaluation at runtime. 
  40.      * MethodMatchers included in this struct must already have been found to have matched 
  41.      * as far as was possibly statically. Passing an array might be about 10% faster, 
  42.      * but would complicate the code. And it would work only for static pointcuts. 
  43.      */  
  44.     protected ReflectiveMethodInvocation(  
  45.             Object proxy, Object target, Method method, Object[] arguments,  
  46.             Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {  
  47.   
  48.         this.proxy = proxy;//proxy对象  
  49.         this.target = target;//真实的realSubject对象  
  50.         this.targetClass = targetClass;//被代理的类类型  
  51.         this.method = BridgeMethodResolver.findBridgedMethod(method);//方法引用  
  52.         this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);//调用参数  
  53.         this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;//Advice拦截器链  
  54.     }  
  55.   
  56.   
  57.     @Override  
  58.     public final Object getProxy() {  
  59.         return this.proxy;  
  60.     }  
  61.   
  62.     @Override  
  63.     public final Object getThis() {  
  64.         return this.target;  
  65.     }  
  66.   
  67.     @Override  
  68.     public final AccessibleObject getStaticPart() {  
  69.         return this.method;  
  70.     }  
  71.   
  72.     /** 
  73.      * Return the method invoked on the proxied interface. 
  74.      * May or may not correspond with a method invoked on an underlying 
  75.      * implementation of that interface. 
  76.      */  
  77.     @Override  
  78.     public final Method getMethod() {  
  79.         return this.method;  
  80.     }  
  81.   
  82.     @Override  
  83.     public final Object[] getArguments() {  
  84.         return (this.arguments != null ? this.arguments : new Object[0]);  
  85.     }  
  86.   
  87.     @Override  
  88.     public void setArguments(Object... arguments) {  
  89.         this.arguments = arguments;  
  90.     }  
  91.   
  92.   
  93.     @Override  
  94.     public Object proceed() throws Throwable {  
  95.         //  没有拦截器，则直接调用Joinpoint上的method，即直接调用MethodInvocation We start with an index of -1 and increment early.  
  96.         if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {  
  97.             return invokeJoinpoint();  
  98.         }  
  99.                 // 取得第拦截器链上第N个拦截器   
  100.         Object interceptorOrInterceptionAdvice =  
  101.                 this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);  
  102.         //PointcutInterceptor会走这个逻辑  
  103.                 if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {  
  104.             // Evaluate dynamic method matcher here: static part will already have  
  105.             // been evaluated and found to match.  
  106.             InterceptorAndDynamicMethodMatcher dm =  
  107.                     (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;  
  108.             //当前拦截器是符合拦截规则，每个拦截器可以定义是否特定的类和方法名是否符合拦截规则  
  109.                         //实际上PointCut定义的方法签名最后会转换成这个MethodMatcher，并置于拦截器中  
  110.                         if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {  
  111.                  //符合拦截规则，调用拦截器invoke()   
  112.                              return dm.interceptor.invoke(this);  
  113.             }  
  114.             else {  
  115.                 // Dynamic matching failed.  
  116.                 // Skip this interceptor and invoke the next in the chain.  
  117.                                 // 当前方法不需要拦截器操作，则直接往前推进  
  118.                                 return proceed();  
  119.             }  
  120.         }  
  121.         else {  
  122.             // It's an interceptor, so we just invoke it: The pointcut will have  
  123.             // been evaluated statically before this object was constructed.  
  124.                         //直接调用拦截器，  
  125.                         return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);  
  126.         }  
  127.     }  
  128.   
  129.     /** 
  130.      * Invoke the joinpoint using reflection. 
  131.      * Subclasses can override this to use custom invocation. 
  132.      * @return the return value of the joinpoint 
  133.      * @throws Throwable if invoking the joinpoint resulted in an exception 
  134.      */  
  135.     protected Object invokeJoinpoint() throws Throwable {  
  136.         return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);  
  137.     }  

上述的代码比较冗杂，解释起来比较繁琐，请看下面一张图，你就知道这段代码的思路了：

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第7张图片


实例分析

根据上面的执行链上的逻辑，我们将我们上面举的例子的输出结果在整理一下：

Advice拦截器的添加顺序:

[java] view plain copy
print ?
  1. proxyFactoryBean.addAdvice(afterReturningAdvice);  
  2. proxyFactoryBean.addAdvice(aroundAdvice);  
  3. proxyFactoryBean.addAdvice(throwsAdvice);  
  4. proxyFactoryBean.addAdvice(beforeAdvice);  
第一个拦截器：AfterReturningAdvice

第一个添加的是afterReturningAdivce,它所处的位置是第一个拦截器，执行的操作就是：

[java] view plain copy
print ?
  1. @Override  
  2. public Object invoke(MethodInvocation mi) throws Throwable {  
  3.     Object retVal = mi.proceed();  
  4.     this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());  
  5.     return retVal;  
  6. }  
也就是说，先完成MethodInvocation的proceed()方法再执行相应的advice；而调用了mi.proceed()方法，导致了当前的调用链后移，进行和后续的操作，也就是说，AfterReturningAdvice只能等到整个拦截器链上所有执行完毕后才会生效，所以： AFTER_RETURNING:本次服务已结束.... 这句话排在了最后：

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第8张图片

第二个拦截器：AroundAdvice

[java] view plain copy
print ?
  1. @Override  
  2. public Object invoke(MethodInvocation invocation) throws Throwable {  
  3.     System.out.println("AROUND_ADVICE:BEGIN....");  
  4.     Object returnValue = invocation.proceed();  
  5.     System.out.println("AROUND_ADVICE:END.....");  
  6.     return returnValue;  
  7. }  
现在执行到了第二个拦截器，首先输出了"AROUND_ADVICE:BEGIN......"，接着调用Invocation.proceed(),等到剩余的执行完后，再输出"AROUND_ADVICE:END....."：

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第9张图片


第三个拦截器：ThrowsAdvice:

ThrowsAdvice拦截器的处理模式是：

[java] view plain copy
print ?
  1. @Override  
  2. public Object invoke(MethodInvocation mi) throws Throwable {  
  3.     try {  
  4.            //先执行invocation.proceed();     
  5.                       return mi.proceed();  
  6.     }  
  7.     catch (Throwable ex) {  
  8.                       //捕捉错误，调用afterThrowing()方法  
  9.                        Method handlerMethod = getExceptionHandler(ex);  
  10.         if (handlerMethod != null) {  
  11.             invokeHandlerMethod(mi, ex, handlerMethod);  
  12.         }  
  13.         throw ex;  
  14.     }  
  15. }  

上述的逻辑是，先执行Invocation.proceed();如果这个过程中抛出异常，则调用ThrowsAdvice。

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第10张图片

第四个拦截器:BeforeAdvice:

这个拦截器的工作逻辑如下：

[java] view plain copy
print ?
  1. @Override  
  2. public Object invoke(MethodInvocation mi) throws Throwable {  
  3.     this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() );//先执行Advice  
  4.     return mi.proceed();//后执行Invocation  
  5. }  
《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第11张图片

综上所有的拦截器过程，我们就能理解，为什么我们刚开始的输出为什么是下面这样了：

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第12张图片


6、PointCut与Advice的结合------Adivce的条件执行

上面我们提供了几个Adivce，你会发现，这些Advice是无条件地加入了我们创建的对象中。无论调用Target的任何方法，这些Advice都会被触发到。

那么，我们可否告诉Advice，只让它对特定的方法或特定类起作用呢？ 这个实际上是要求我们添加一个过滤器，如果满足条件，则Advice生效，否则无效。Spring将这个过滤器抽象成如下的接口：

[java] view plain copy
print ?
  1. public interface MethodMatcher {  
  2.   
  3.     /** 
  4.      * 提供方法签名和所属的Class类型，判断是否支持  
  5.          * Perform static checking whether the given method matches. If this 
  6.      * returns {@code false} or if the {@link #isRuntime()} method 
  7.      * returns {@code false}, no runtime check (i.e. no. 
  8.      * {@link #matches(java.lang.reflect.Method, Class, Object[])} call) will be made. 
  9.      * @param method the candidate method 
  10.      * @param targetClass the target class (may be {@code null}, in which case 
  11.      * the candidate class must be taken to be the method's declaring class) 
  12.      * @return whether or not this method matches statically 
  13.      */  
  14.     boolean matches(Method method, Class<?> targetClass);  
  15.   
  16.     /** 
  17.      * Is this MethodMatcher dynamic, that is, must a final call be made on the 
  18.      * {@link #matches(java.lang.reflect.Method, Class, Object[])} method at 
  19.      * runtime even if the 2-arg matches method returns {@code true}? 
  20.      * <p>Can be invoked when an AOP proxy is created, and need not be invoked 
  21.      * again before each method invocation, 
  22.      * @return whether or not a runtime match via the 3-arg 
  23.      * {@link #matches(java.lang.reflect.Method, Class, Object[])} method 
  24.      * is required if static matching passed 
  25.      */  
  26.     boolean isRuntime();  
  27.   
  28.     /** 
  29.      * Check whether there a runtime (dynamic) match for this method, 
  30.      * which must have matched statically. 
  31.      * <p>This method is invoked only if the 2-arg matches method returns 
  32.      * {@code true} for the given method and target class, and if the 
  33.      * {@link #isRuntime()} method returns {@code true}. Invoked 
  34.      * immediately before potential running of the advice, after any 
  35.      * advice earlier in the advice chain has run. 
  36.      * @param method the candidate method 
  37.      * @param targetClass the target class (may be {@code null}, in which case 
  38.      * the candidate class must be taken to be the method's declaring class) 
  39.      * @param args arguments to the method 
  40.      * @return whether there's a runtime match 
  41.      * @see MethodMatcher#matches(Method, Class) 
  42.      */  
  43.     boolean matches(Method method, Class<?> targetClass, Object... args);  
  44.   
  45.   
  46.     /** 
  47.      * Canonical instance that matches all methods. 
  48.      */  
  49.     MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;  
  50.   
  51. }  

将这个匹配器MethodMatcher和拦截器Interceptor 结合到一起，就构成了一个新的类InterceptorAndDynamicMethodMatcher ：

[java] view plain copy
print ?
  1. /** 
  2.  * Internal framework class, combining a MethodInterceptor instance 
  3.  * with a MethodMatcher for use as an element in the advisor chain. 
  4.  * 
  5.  * @author Rod Johnson 
  6.  */  
  7. class InterceptorAndDynamicMethodMatcher {  
  8.   
  9.     final MethodInterceptor interceptor;  
  10.   
  11.     final MethodMatcher methodMatcher;  
  12.   
  13.     public InterceptorAndDynamicMethodMatcher(MethodInterceptor interceptor, MethodMatcher methodMatcher) {  
  14.         this.interceptor = interceptor;  
  15.         this.methodMatcher = methodMatcher;  
  16.     }  
  17.   
  18. }  
我们再将上述的包含整个拦截器执行链逻辑的ReflectiveMethodInvocation实现的核心代码在过一遍：

[java] view plain copy
print ?
  1. @Override  
  2. public Object proceed() throws Throwable {  
  3.     //  We start with an index of -1 and increment early.  
  4.     if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {  
  5.         return invokeJoinpoint();  
  6.     }  
  7.   
  8.     Object interceptorOrInterceptionAdvice =  
  9.             this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);  
  10.     //起到一定的过滤作用，如果不匹配，则直接skip  
  11.                if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {  
  12.         // Evaluate dynamic method matcher here: static part will already have  
  13.         // been evaluated and found to match.  
  14.         InterceptorAndDynamicMethodMatcher dm =  
  15.                 (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;  
  16.         //满足匹配规则，则拦截器Advice生效  
  17.                        if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {  
  18.             return dm.interceptor.invoke(this);  
  19.         }  
  20.         else {  
  21.             // Dynamic matching failed.  
  22.             // Skip this interceptor and invoke the next in the chain.  
  23.                                //拦截器尚未生效，直接skip  
  24.                                return proceed();  
  25.         }  
  26.     }  
  27.     else {  
  28.         // It's an interceptor, so we just invoke it: The pointcut will have  
  29.         // been evaluated statically before this object was constructed.  
  30.         return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);  
  31.     }  
  32. }  

实战：

我们现在实现一个PointcutAdisor，PointcutAdvisor表示拥有某个Pointcut的Advisor。

[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. import org.aopalliance.aop.Advice;  
  4. import org.springframework.aop.Pointcut;  
  5. import org.springframework.aop.PointcutAdvisor;  
  6.   
  7. /** 
  8.  * 实现一个PointcutAdvisor，通过提供的Pointcut,对Advice的执行进行过滤 
  9.  * Created by louis on 2016/4/16. 
  10.  */  
  11. public class FilteredAdvisor implements PointcutAdvisor {  
  12.   
  13.     private Pointcut pointcut;  
  14.     private Advice advice;  
  15.   
  16.     public FilteredAdvisor(Pointcut pointcut, Advice advice) {  
  17.         this.pointcut = pointcut;  
  18.         this.advice = advice;  
  19.     }  
  20.   
  21.     /** 
  22.      * Get the Pointcut that drives this advisor. 
  23.      */  
  24.     @Override  
  25.     public Pointcut getPointcut() {  
  26.         return pointcut;  
  27.     }  
  28.   
  29.     @Override  
  30.     public Advice getAdvice() {  
  31.         return advice;  
  32.     }  
  33.   
  34.     @Override  
  35.     public boolean isPerInstance() {  
  36.         return false;  
  37.     }  
  38. }  

[java] view plain copy
print ?
  1. package org.luanlouis.meditations.thinkinginspring.aop;  
  2.   
  3. import org.aopalliance.aop.Advice;  
  4. import org.springframework.aop.aspectj.AspectJExpressionPointcut;  
  5. import org.springframework.aop.framework.ProxyFactoryBean;  
  6.   
  7. /** 
  8.  * 通过ProxyFactoryBean 手动创建 代理对象 
  9.  * Created by louis on 2016/4/14. 
  10.  */  
  11. public class App {  
  12.   
  13.     public static void main(String[] args) throws Exception {  
  14.   
  15.         //1.针对不同的时期类型，提供不同的Advice  
  16.         Advice beforeAdvice = new TicketServiceBeforeAdvice();  
  17.         Advice afterReturningAdvice = new TicketServiceAfterReturningAdvice();  
  18.         Advice aroundAdvice = new TicketServiceAroundAdvice();  
  19.         Advice throwsAdvice = new TicketServiceThrowsAdvice();  
  20.   
  21.         RailwayStation railwayStation = new RailwayStation();  
  22.   
  23.         //2.创建ProxyFactoryBean,用以创建指定对象的Proxy对象  
  24.         ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();  
  25.        //3.设置Proxy的接口  
  26.         proxyFactoryBean.setInterfaces(TicketService.class);  
  27.         //4. 设置RealSubject  
  28.         proxyFactoryBean.setTarget(railwayStation);  
  29.         //5.使用JDK基于接口实现机制的动态代理生成Proxy代理对象，如果想使用CGLIB，需要将这个flag设置成true  
  30.         proxyFactoryBean.setProxyTargetClass(true);  
  31.   
  32.         //5. 添加不同的Advice  
  33.   
  34.         proxyFactoryBean.addAdvice(afterReturningAdvice);  
  35.         proxyFactoryBean.addAdvice(aroundAdvice);  
  36.         proxyFactoryBean.addAdvice(throwsAdvice);  
  37.         //proxyFactoryBean.addAdvice(beforeAdvice);  
  38.         proxyFactoryBean.setProxyTargetClass(false);  
  39.   
  40.         //手动创建一个pointcut,专门拦截sellTicket方法  
  41.         AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();  
  42.         pointcut.setExpression("execution( * sellTicket(..))");  
  43.         //传入创建的beforeAdvice和pointcut  
  44.         FilteredAdvisor sellBeforeAdvior = new FilteredAdvisor(pointcut,beforeAdvice);  
  45.         //添加到FactoryBean中  
  46.         proxyFactoryBean.addAdvisor(sellBeforeAdvior);  
  47.           
  48.         //通过ProxyFactoryBean生成  
  49.         TicketService ticketService = (TicketService) proxyFactoryBean.getObject();  
  50.         ticketService.sellTicket();  
  51.         System.out.println("---------------------------");  
  52.         ticketService.inquire();  
  53.   
  54.     }  
  55.   
  56.   
  57. }  

这个时候，你会看到输出：

《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）_第13张图片

从结果中你可以清晰地看到，我们可以对某一个Advisor(即Advice)添加一个pointcut限制，这样就可以针对指定的方法执行Advice了！本例中使用了PointcutAdvisor,实际上，带底层代码中，Spring会将PointcutAdvisor转换成InterceptorAndDynamicMethodMatcher 参与ReflectiveMethodInvocation关于拦截器链的执行逻辑：

[java] view plain copy
print ?
  1. public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {  
  2.   
  3.     @Override  
  4.     public List<Object> getInterceptorsAndDynamicInterceptionAdvice(  
  5.             Advised config, Method method, Class<?> targetClass) {  
  6.   
  7.         // This is somewhat tricky... We have to process introductions first,  
  8.         // but we need to preserve order in the ultimate list.  
  9.         List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);  
  10.         Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());  
  11.         boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);  
  12.         AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();  
  13.                   
  14.         for (Advisor advisor : config.getAdvisors()) {  
  15.                                 //PointcutAdvisor向 InterceptorAndDynamicMethodMatcher 的转换    
  16.                                if (advisor instanceof PointcutAdvisor) {  
  17.                 // Add it conditionally.  
  18.                 PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;  
  19.                 if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {  
  20.                     MethodInterceptor[] interceptors = registry.getInterceptors(advisor);  
  21.                     MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();  
  22.                     if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {  
  23.                         if (mm.isRuntime()) {  
  24.                             // Creating a new object instance in the getInterceptors() method  
  25.                             // isn't a problem as we normally cache created chains.  
  26.                             for (MethodInterceptor interceptor : interceptors) {  
  27.                                 interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));  
  28.                             }  
  29.                         }  
  30.                         else {  
  31.                             interceptorList.addAll(Arrays.asList(interceptors));  
  32.                         }  
  33.                     }  
  34.                 }  
  35.             }  
  36.             else if (advisor instanceof IntroductionAdvisor) {  
  37.                 IntroductionAdvisor ia = (IntroductionAdvisor) advisor;  
  38.                 if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {  
  39.                     Interceptor[] interceptors = registry.getInterceptors(advisor);  
  40.                     interceptorList.addAll(Arrays.asList(interceptors));  
  41.                 }  
  42.             }  
  43.             else {  
  44.                 Interceptor[] interceptors = registry.getInterceptors(advisor);  
  45.                 interceptorList.addAll(Arrays.asList(interceptors));  
  46.             }  
  47.         }  
  48.   
  49.         return interceptorList;  
  50.     }  
  51.   
  52.     /** 
  53.      * Determine whether the Advisors contain matching introductions. 
  54.      */  
  55.     private static boolean hasMatchingIntroductions(Advised config, Class<?> actualClass) {  
  56.         for (int i = 0; i < config.getAdvisors().length; i++) {  
  57.             Advisor advisor = config.getAdvisors()[i];  
  58.             if (advisor instanceof IntroductionAdvisor) {  
  59.                 IntroductionAdvisor ia = (IntroductionAdvisor) advisor;  
  60.                 if (ia.getClassFilter().matches(actualClass)) {  
  61.                     return true;  
  62.                 }  
  63.             }  
  64.         }  
  65.         return false;  
  66.     }  
  67.   
  68. }  


7、总结

            至此，你已经了解了Spring的AOP的精髓，以及Spring的整个工作机制。我个人认为,想要理解Spring AOP，你需要从ProxyFactoryBean 开始，逐步地分析整个代理的构建过程：

            1. 代理对象是怎么生成的(JDK or Cglib)

            2. Advice链(即拦截器链)的构造过程以及执行机制

            3. 如何在Advice上添加pointcut,并且这个pointcut是如何工作的(实际上起到的过滤作用)

     

           最后再讲一下性能问题，如上面描述的，Spring创建Proxy的过程逻辑虽然很清晰，但是你也看到，对于我们每一个方法调用，都会经过非常复杂的层层Advice拦截判断，是否需要拦截处理，这个开销是非常大的。记得Spring的documentation介绍，如果使用Spring的AOP，对项目而言会造成10%的性能消耗，So，用AOP之前要仔细考虑一下性能问题~~~~~


            



作者的话

     本文使用的源码，已经托管到Github上，读者可以自行clone查看测验~

      源码地址：https://github.com/LuanLouis/thinking-in-spring.git ,请fetch branch : aop-principle   分支~


本文关于Spring AOP的设计原理仅是本人个人的见解和看法，如有任何疑问和错误，请不吝指出，敬请赐教，共同进步！



本文转载自：http://blog.csdn.net/luanlouis/article/details/51155821

你可能感兴趣的:(《Spring设计思想》AOP实现原理（基于JDK和基于CGLIB）)

  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》 1784e22615e0
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 放下是一段成长的修行 小莳玥
    人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 网易严选官方旗舰店，优质商品，卓越服务 高省_飞智666600
    网易严选官方旗舰店是网易旗下的一家电商平台，以提供优质商品和卓越服务而闻名。作为一名SEO优化师，我将为您详细介绍网易严选官方旗舰店，并重点强调其特点和优势。大家好！我是高省APP最大团队&联合创始人飞智导师。相较于其他返利app，高省APP的佣金更高，模式更好，最重要的是，终端用户不会流失！高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几
  • 桌面上有多个球在同时运动，怎么实现球之间不交叉，即碰撞？ 换个号韩国红果果 html小球碰撞
    稍微想了一下，然后解决了很多bug，最后终于把它实现了。其实原理很简单。在每改变一个小球的x y坐标后，遍历整个在dom树中的其他小球，看一下它们与当前小球的距离是否小于球半径的两倍？若小于说明下一次绘制该小球（设为a）前要把他的方向变为原来相反方向（与a要碰撞的小球设为b），即假如当前小球的距离小于球半径的两倍的话，马上改变当前小球方向。那么下一次绘制也是先绘制b，再绘制a，由于a的方向已经改变
  • 《高性能HTML5》读后整理的Web性能优化内容 白糖_ html5
    读后感         先说说《高性能HTML5》这本书的读后感吧，个人觉得这本书前两章跟书的标题完全搭不上关系，或者说只能算是讲解了“高性能”这三个字，HTML5完全不见踪影。个人觉得作者应该首先把HTML5的大菜拿出来讲一讲，再去分析性能优化的内容，这样才会有吸引力。因为只是在线试读，没有机会看后面的内容，所以不胡乱评价了。  
  • [JShop]Spring MVC的RequestContextHolder使用误区 dinguangx jeeshop商城系统jshop电商系统
        在spring mvc中，为了随时都能取到当前请求的request对象，可以通过RequestContextHolder的静态方法getRequestAttributes()获取Request相关的变量，如request, response等。         在jshop中，对RequestContextHolder的
  • 算法之时间复杂度 周凡杨 java算法时间复杂度效率
          在 计算机科学 中， 算法 的时间复杂度是一个 函数 ，它定量描述了该算法的运行时间。这是一个关于代表算法输入值的 字符串 的长度的函数。时间复杂度常用 大O符号 表述，不包括这个函数的低阶项和首项系数。使用这种方式时，时间复杂度可被称为是 渐近 的，它考察当输入值大小趋近无穷时的情况。 这样用大写O()来体现算法时间复杂度的记法，
  • Java事务处理 g21121 java
    一、什么是Java事务 通常的观念认为，事务仅与数据库相关。 事务必须服从ISO/IEC所制定的ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。事务的原子性表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。一致性表示当事务执行失败时，所有被该事务影响的数据都应该恢复到事务执行前的状
  • Linux awk命令详解 510888780 linux
    一.  AWK 说明   awk是一种编程语言，用于在linux/unix下对文本和数据进行处理。数据可以来自标准输入、一个或多个文件，或其它命令的输出。它支持用户自定义函数和动态正则表达式等先进功能，是linux/unix下的一个强大编程工具。它在命令行中使用，但更多是作为脚本来使用。    awk的处理文本和数据的方式：它逐行扫描文件，从第一行到
  • android permission 布衣凌宇 Permission
    <uses-permission android:name="android.permission.ACCESS_CHECKIN_PROPERTIES" ></uses-permission>允许读写访问"properties"表在checkin数据库中，改值可以修改上传 <uses-permission android:na
  • Oracle和谷歌Java Android官司将推迟 aijuans javaoracle
    北京时间 10 月 7 日，据国外媒体报道，Oracle 和谷歌之间一场等待已久的官司可能会推迟至 10 月 17 日以后进行，这场官司的内容是 Android 操作系统所谓的 Java 专利权之争。本案法官 William Alsup 称根据专利权专家 Florian Mueller 的预测，谷歌 Oracle 案很可能会被推迟。　　该案中的第二波辩护被安排在 10 月 17 日出庭，从目前看来
  • linux shell 常用命令 antlove linuxshellcommand
    grep [options] [regex] [files] /var/root # grep -n "o" * hello.c:1:/* This C source can be compiled with:
  • Java解析XML配置数据库连接(DOM技术连接 SAX技术连接) 百合不是茶 sax技术Java解析xml文档dom技术XML配置数据库连接
        XML配置数据库文件的连接其实是个很简单的问题,为什么到现在才写出来主要是昨天在网上看了别人写的,然后一直陷入其中,最后发现不能自拔 所以今天决定自己完成 ,,,,现将代码与思路贴出来供大家一起学习   XML配置数据库的连接主要技术点的博客; JDBC编程 : JDBC连接数据库 DOM解析XML:  DOM解析XML文件 SA
  • underscore.js 学习（二） bijian1013 JavaScriptunderscore
            Array Functions 所有数组函数对参数对象一样适用。1.first   _.first(array, [n])   别名: head, take       返回array的第一个元素，设置了参数n，就
  • plSql介绍 bijian1013 oracle数据库plsql
    /* * PL/SQL 程序设计学习笔记 * 学习plSql介绍.pdf * 时间：2010-10-05 */ --创建DEPT表 create table DEPT ( DEPTNO NUMBER(10), DNAME NVARCHAR2(255), LOC NVARCHAR2(255) ) delete dept; select
  • 【Nginx一】Nginx安装与总体介绍 bit1129 nginx
    启动、停止、重新加载Nginx nginx 启动Nginx服务器，不需要任何参数u nginx -s stop 快速(强制)关系Nginx服务器 nginx -s quit 优雅的关闭Nginx服务器 nginx -s reload 重新加载Nginx服务器的配置文件 nginx -s reopen 重新打开Nginx日志文件  
  • spring mvc开发中浏览器兼容的奇怪问题 bitray jqueryAjaxspringMVC浏览器上传文件
        最近个人开发一个小的OA项目,属于复习阶段.使用的技术主要是spring mvc作为前端框架,mybatis作为数据库持久化技术.前台使用jquery和一些jquery的插件.     在开发到中间阶段时候发现自己好像忽略了一个小问题,整个项目一直在firefox下测试,没有在IE下测试,不确定是否会出现兼容问题.由于jquer
  • Lua的io库函数列表 ronin47 lua io
    1、io表调用方式：使用io表，io.open将返回指定文件的描述，并且所有的操作将围绕这个文件描述 　　io表同样提供三种预定义的文件描述io.stdin,io.stdout,io.stderr 　　2、文件句柄直接调用方式,即使用file:XXX()函数方式进行操作,其中file为io.open()返回的文件句柄 　　多数I/O函数调用失败时返回nil加错误信息,有些函数成功时返回nil
  • java-26-左旋转字符串 bylijinnan java
    public class LeftRotateString { /** * Q 26 左旋转字符串 * 题目：定义字符串的左旋转操作：把字符串前面的若干个字符移动到字符串的尾部。 * 如把字符串abcdef左旋转2位得到字符串cdefab。 * 请实现字符串左旋转的函数。要求时间对长度为n的字符串操作的复杂度为O(n)，辅助内存为O(1)。 */ pu
  • 《vi中的替换艺术》-linux命令五分钟系列之十一 cfyme linux命令
    vi方面的内容不知道分类到哪里好，就放到《Linux命令五分钟系列》里吧！ 今天编程，关于栈的一个小例子，其间我需要把”S.”替换为”S->”(替换不包括双引号)。 其实这个不难，不过我觉得应该总结一下vi里的替换技术了，以备以后查阅。   1 所有替换方案都要在冒号“:”状态下书写。 2 如果想将abc替换为xyz，那么就这样 :s/abc/xyz/ 不过要特别
  • [轨道与计算]新的并行计算架构 comsci 并行计算
         我在进行流程引擎循环反馈试验的过程中，发现一个有趣的事情。。。如果我们在流程图的每个节点中嵌入一个双向循环代码段，而整个流程中又充满着很多并行路由，每个并行路由中又包含着一些并行节点，那么当整个流程图开始循环反馈过程的时候，这个流程图的运行过程是否变成一个并行计算的架构呢？      
  • 重复执行某段代码 dai_lm android
    用handler就可以了 private Handler handler = new Handler(); private Runnable runnable = new Runnable() { public void run() { update(); handler.postDelayed(this, 5000); } }; 开始计时 h
  • Java实现堆栈（list实现） datageek 数据结构——堆栈
    public interface IStack<T> { //元素出栈，并返回出栈元素 public T pop(); //元素入栈 public void push(T element); //获取栈顶元素 public T peek(); //判断栈是否为空 public boolean isEmpty
  • 四大备份MySql数据库方法及可能遇到的问题 dcj3sjt126com DBbackup
    一：通过备份王等软件进行备份前台进不去？ 用备份王等软件进行备份是大多老站长的选择，这种方法方便快捷，只要上传备份软件到空间一步步操作就可以，但是许多刚接触备份王软件的客用户来说还原后会出现一个问题：因为新老空间数据库用户名和密码不统一，网站文件打包过来后因没有修改连接文件，还原数据库是好了，可是前台会提示数据库连接错误，网站从而出现打不开的情况。 解决方法：学会修改网站配置文件，大多是由co
  • github做webhooks：[1]钩子触发是否成功测试 dcj3sjt126com githubgitwebhook
    转自: http://jingyan.baidu.com/article/5d6edee228c88899ebdeec47.html github和svn一样有钩子的功能，而且更加强大。例如我做的是最常见的push操作触发的钩子操作，则每次更新之后的钩子操作记录都会在github的控制板可以看到！ 工具/原料 github 方法/步骤
  • ">的作用" target="_blank">JSP中的作用 蕃薯耀
    JSP中<base href="<%=basePath%>">的作用 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  • linux下SAMBA服务安装与配置 hanqunfeng linux
    局域网使用的文件共享服务。 一.安装包： rpm -qa | grep samba samba-3.6.9-151.el6.x86_64 samba-common-3.6.9-151.el6.x86_64 samba-winbind-3.6.9-151.el6.x86_64 samba-client-3.6.9-151.el6.x86_64 samba-winbind-clients
  • guava cache IXHONG cache
    缓存，在我们日常开发中是必不可少的一种解决性能问题的方法。简单的说，cache 就是为了提升系统性能而开辟的一块内存空间。 　　缓存的主要作用是暂时在内存中保存业务系统的数据处理结果，并且等待下次访问使用。在日常开发的很多场合，由于受限于硬盘IO的性能或者我们自身业务系统的数据处理和获取可能非常费时，当我们发现我们的系统这个数据请求量很大的时候，频繁的IO和频繁的逻辑处理会导致硬盘和CPU资源的
  • Query的开始--全局变量,noconflict和兼容各种js的初始化方法 kvhur JavaScriptjquerycss
    这个是整个jQuery代码的开始，里面包含了对不同环境的js进行的处理，例如普通环境，Nodejs，和requiredJs的处理方法。 还有jQuery生成$, jQuery全局变量的代码和noConflict代码详解  完整资源： http://www.gbtags.com/gb/share/5640.htm jQuery 源码：   (
  • 美国人的福利和中国人的储蓄 nannan408
       今天看了篇文章，震动很大，说的是美国的福利。    美国医院的无偿入院真的是个好措施。小小的改善，对于社会是大大的信心。小孩，税费等，政府不收反补，真的体现了人文主义。    美国这么高的社会保障会不会使人变懒？答案是否定的。正因为政府解决了后顾之忧，人们才得以倾尽精力去做一些有创造力，更造福社会的事情，这竟成了美国社会思想、人
  • N阶行列式计算(JAVA) qiuwanchi N阶行列式计算
    package gaodai; import java.util.List; /** * N阶行列式计算 * @author 邱万迟 * */ public class DeterminantCalculation { public DeterminantCalculation(List<List<Double>> determina
  • C语言算法之打渔晒网问题 qiufeihu c算法
    如果一个渔夫从2011年1月1日开始每三天打一次渔，两天晒一次网，编程实现当输入2011年1月1日以后任意一天，输出该渔夫是在打渔还是在晒网。 代码如下：   #include <stdio.h> int leap(int a) /*自定义函数leap()用来指定输入的年份是否为闰年*/ { if((a%4 == 0 && a%100 != 0
  • XML中DOCTYPE字段的解析 wyzuomumu xml
    DTD声明始终以!DOCTYPE开头,空一格后跟着文档根元素的名称,如果是内部DTD,则再空一格出现[],在中括号中是文档类型定义的内容. 而对于外部DTD,则又分为私有DTD与公共DTD,私有DTD使用SYSTEM表示,接着是外部DTD的URL. 而公共DTD则使用PUBLIC,接着是DTD公共名称,接着是DTD的URL.   私有DTD <!DOCTYPErootSYST
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他