小波同学
小波同学

Spring5AOP——创建AOP动态代理

Spring AOP的总体流程

  • 1、注册解析AOP的服务
  • 2、解析和加载横切逻辑
  • 3、将横切逻辑织入目标Bean中

AnnotationAwareAspectJAutoProxyCreator继承体系图

AnnotationAwareAspectJAutoProxyCreator既实现了SmartInstantiationAwareBeanPostProcessor 又实现了BeanFactoryAware。就可以对容器做一些事情。

AnnotationAwareAspectJAutoProxyCreator 实现了Order接口，所以先于普通的BeanPostProcessor注册，并对普通BeanPostProcessor也能起作用。

AnnotationAwareAspectJAutoProxyCreator 是InstantiationAwareBeanPostProcessor，会在Bean被创建之前，在resolveBeforeInstantiation中被调用。

Spring Aop主要是通过AbstractAutoProxyCreator实现的BeanPostProcessor、InstantiationAwareBeanPostProcessor以及SmartInstantiationAwareBeanPostProcessor接口里面的后置处理器方法，来介入到Spring IOC容器的Bean的实例化以及初始化的过程中对Bean进行AOP的处理的。

所以AbstractAutoProxyCreator类里面的实现的容器级别的后置处理器方法便是介入分析的点：

  • 横切逻辑的加载主要是在AbstractAutoProxyCreator类中的postProcessBeforeInstantiation方法中，该方法是在Bean的实例化之前被调用的。

  • 横切逻辑织入目标Bean中主要是在AbstractAutoProxyCreator类中的postProcessAfterInitialization方法中，该方法是在Bean的实例化之后被调用的。

Spring AOP横切逻辑的织入过程：

在Spring5AOP——AbstractAutoProxyCreator横切逻辑织入目标Bean中文章中，分析了横切逻辑织入目标Bean中，本文就分析AbstractAutoProxyCreator类中wrapIfNecessary方法中的createProxy方法，创建AOP动态代理。

wrapIfNecessary

  • 判断当前bean是否需要被代理，如果需要则创建动态代理类。
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    /**
     * Spring实现Bean代理的核心方法。wrapIfNecessary在两处会被调用，一处是getEarlyBeanReference，
     * 另一处是postProcessAfterInitialization
     */
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        //已经被处理过
        // 1.判断当前bean是否在targetSourcedBeans缓存中存在（已经处理过），如果存在，则直接返回当前bean
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        //不需要被织入逻辑的
        // 2.在advisedBeans缓存中存在，并且value为false，则代表无需处理
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //是不是基础的bean 是不是需要跳过的
        // 3.bean的类是aop基础设施类 || bean应该跳过，则标记为无需处理，并返回
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // Create proxy if we have advice.
        // 返回匹配当前Bean的所有Advice\Advisor\Interceptor
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        // 5.如果存在增强器则创建代理
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //创建Bean对应的代理，SingletonTargetSource用于封装实现类的信息
            // 5.1 创建代理对象：这边SingletonTargetSource的target属性存放的就是我们原来的bean实例（也就是被代理对象），
            // 用于最后增加逻辑执行完毕后，通过反射执行我们真正的方法时使用（method.invoke(bean, args)）
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            // 5.2 创建完代理后，将cacheKey -> 代理类的class放到缓存
            this.proxyTypes.put(cacheKey, proxy.getClass());
            // 返回代理对象
            return proxy;
        }
        //该Bean是不需要进行代理的，下次就不需要重复生成了
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
}

  • 当执行完getAdvicesAndAdvisorsForBean方法之后，就可以从候选的Advisor列表里筛选出匹配于当前Bean的Advisor列表，获取到Advisor列表之后就会接着执行后续的创建动态代理的步骤了。

  • 由于getAdvicesAndAdvisorsForBean筛选出匹配的Advisor了，将该Bean对应的cacheKey写入到advisedBeans中，并将对应的值设置为true，表示对该Bean进行过Spring AOP的处理了。

  • 之后就会调用createProxy方法去创建目标代理对象实例，创建好动态代理实例之后，就会动态代理实例类型给保存到proxyTypes的缓存里面，并将动态代理实例返回，这样就完成了wrapIfNecessary方法的执行。

  • 如果没有getAdvicesAndAdvisorsForBean没有筛选出匹配的Advisor的话，就证明该Bean不需要织入横切逻辑，此时就会在advisedBeans里给该Bean设置对应的cacheKey和false，以表明该bean是不需要被织入的。

本文重点分析createProxy方法——创建AOP动态代理

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    protected Object createProxy(Class beanClass, @Nullable String beanName,
            @Nullable Object[] specificInterceptors, TargetSource targetSource) {
        //如果beanFactory是ConfigurableListableBeanFactory的类型，暴露目标类
        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }
        //创建一个ProxyFactory，当前ProxyCreator在创建代理时将需要用到的字段赋值到ProxyFactory中去
        ProxyFactory proxyFactory = new ProxyFactory();
        //将 当前的AnnotationAwareAspectJAutoProxyCreator 对象的属性赋值给ProxyFactory对象
        proxyFactory.copyFrom(this);
        // 处理 proxyTargetClass 属性
        // 如果希望使用 CGLIB 来代理接口，可以配置
        // proxy-target-class="true",这样不管有没有接口，都使用 CGLIB 来生成代理：
        // 
        if (!proxyFactory.isProxyTargetClass()) {
            // 检查preserveTargetClass属性，判断beanClass是应该基于类代理还是基于接口代理
            if (shouldProxyTargetClass(beanClass, beanName)) {
                // 如果是基于类代理，则将proxyTargetClass赋值为true
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                // 评估bean的代理接口
                // 1. 有接口的，调用一次或多次：proxyFactory.addInterface(ifc);
                // 2. 没有接口的，调用：proxyFactory.setProxyTargetClass(true);
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        // 这个方法主要来对前面传递进来的横切逻辑实例进行包装
        // 注意：如果 specificInterceptors 中有 Advice 和 Interceptor，它们也会被包装成 Advisor
        // 方法会整理合并得到最终的advisors （毕竟interceptorNames还指定了一些拦截器的）
        // 至于调用的先后顺序，通过方法里的applyCommonInterceptorsFirst参数可以进行设置，
        // 若applyCommonInterceptorsFirst为true，interceptorNames属性指定的Advisor优先调用。默认为true
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        // 将advisors添加到proxyFactory
        proxyFactory.addAdvisors(advisors);
        // 设置要代理的类，将targetSource赋值给proxyFactory的targetSource属性，之后可以通过该属性拿到被代理的bean的实例
        proxyFactory.setTargetSource(targetSource);
        // 这个方法是交给子类的，子类可以继续去定制此proxyFactory
        customizeProxyFactory(proxyFactory);

        // 用来控制proxyFactory被配置之后，是否还允许修改通知。默认值为false（即在代理被配置之后，不允许修改代理类的配置）
        proxyFactory.setFrozen(this.freezeProxy);
        // 设置preFiltered的属性值，默认是false。子类：AbstractAdvisorAutoProxyCreator修改为true
        // preFiltered字段意思为：是否已为特定目标类筛选Advisor
        // 这个字段和DefaultAdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice获取所有的Advisor有关
        //CglibAopProxy和JdkDynamicAopProxy都会调用此方法，然后递归执行所有的Advisor
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        // 使用proxyFactory获取代理
        return proxyFactory.getProxy(getProxyClassLoader());
    }
}

evaluateProxyInterfaces(beanClass, proxyFactory)

  • 根据被代理beanClass是否实现了接口，来评估是调用CGLIB还是JDK动态代理。
public class ProxyProcessorSupport extends ProxyConfig implements Ordered, BeanClassLoaderAware, AopInfrastructureBean {

    /**
     * 这里决定了如果目标类没有实现接口直接就是Cglib代理
     * 检查给定beanClass上的接口们，并交给proxyFactory处理
     */
    protected void evaluateProxyInterfaces(Class beanClass, ProxyFactory proxyFactory) {
        // 找到该类实现的所有接口们
        Class[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
        // 标记：是否有存在合理的接口
        boolean hasReasonableProxyInterface = false;
        for (Class ifc : targetInterfaces) {
            if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
                    ifc.getMethods().length > 0) {
                hasReasonableProxyInterface = true;
                break;
            }
        }
        if (hasReasonableProxyInterface) {
            // Must allow for introductions; can't just set interfaces to the target's interfaces only.
            //不管接口是否合理，都将其添加进去
            for (Class ifc : targetInterfaces) {
                proxyFactory.addInterface(ifc);
            }
        }
        else {
            proxyFactory.setProxyTargetClass(true);
        }
    }
}

buildAdvisors(beanName, specificInterceptors)

  • 对横切逻辑实例进行包装
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {
        // Handle prototypes correctly...
        // 解析interceptorNames而来得Advisor数组
        Advisor[] commonInterceptors = resolveInterceptorNames();

        List allInterceptors = new ArrayList<>();
        if (specificInterceptors != null) {
            // 添加参数传进来的，即前面解析出来的advisors
            allInterceptors.addAll(Arrays.asList(specificInterceptors));
            if (commonInterceptors.length > 0) {
                // 添加拦截器
                //调用的先后顺序，通过applyCommonInterceptorsFirst参数可以进行设置，
                // 若applyCommonInterceptorsFirst为true，interceptorNames属性指定的Advisor优先调用。
                // 默认为true
                if (this.applyCommonInterceptorsFirst) {
                    allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
                }
                else {
                    allInterceptors.addAll(Arrays.asList(commonInterceptors));
                }
            }
        }
        if (logger.isTraceEnabled()) {
            int nrOfCommonInterceptors = commonInterceptors.length;
            int nrOfSpecificInterceptors = (specificInterceptors != null ? specificInterceptors.length : 0);
            logger.trace("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
                    " common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
        }
        //把拦截器包装为Advisor
        Advisor[] advisors = new Advisor[allInterceptors.size()];
        for (int i = 0; i < allInterceptors.size(); i++) {
            // wrap包装
            advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
        }
        return advisors;
    }
}
 
 
resolveInterceptorNames
 
 
     
  
  • 解析interceptorNames而来得Advisor数组
    •  
 
 
 
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    private Advisor[] resolveInterceptorNames() {
        BeanFactory bf = this.beanFactory;
        ConfigurableBeanFactory cbf = (bf instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory) bf : null);
        List advisors = new ArrayList<>();
        for (String beanName : this.interceptorNames) {
            if (cbf == null || !cbf.isCurrentlyInCreation(beanName)) {
                Assert.state(bf != null, "BeanFactory required for resolving interceptor names");
                Object next = bf.getBean(beanName);
                advisors.add(this.advisorAdapterRegistry.wrap(next));
            }
        }
        return advisors.toArray(new Advisor[0]);
    }
}

 
 
wrap
 
 
     
  
  • this.advisorAdapterRegistry.wrap(next)
    •  
  
  • 将满足不是正在创建中的横切逻辑实例，给统一转换成Advisor
    •  
 
 
 
public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {

    @Override
    public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
        //如果已经是Advisor，则无需多做处理
        if (adviceObject instanceof Advisor) {
            return (Advisor) adviceObject;
        }
        if (!(adviceObject instanceof Advice)) {
            //必须是Advice类型
            throw new UnknownAdviceTypeException(adviceObject);
        }
        Advice advice = (Advice) adviceObject;
        if (advice instanceof MethodInterceptor) {
            // So well-known it doesn't even need an adapter.
            //如果是MethodInterceptor，则直接使用DefaultPointcutAdvisor进行包装
            return new DefaultPointcutAdvisor(advice);
        }
        // 否则遍历注册的适配器，如果存在支持的适配器则使用 DefaultPointcutAdvisor 进行包装
        //BeforeAdvice、AfterAdvice、ThrowsAdvice三种通知类型的支持是借助适配器模式来实现的
        //AdvisorAdapterRegistry，DefaultAdvisorAdapterRegistry和GlobalAdvisorAdapterRegistry
        //主要负责对AdvisorAdapter进行注册
        for (AdvisorAdapter adapter : this.adapters) {
            // Check that it is supported.
            if (adapter.supportsAdvice(advice)) {
                return new DefaultPointcutAdvisor(advice);
            }
        }
        throw new UnknownAdviceTypeException(advice);
    }
}

 
 
     
  
  • 接着回到createProxy方法中，在执行完buildAdvisors方法之后，就能获取到所有的适配于被代理Bean的Advisor列表，
    •  
 
 
 
proxyFactory.getProxy
 
 
     
  
  • 使用proxyFactory获取代理
    •  
 
 
 
public class ProxyFactory extends ProxyCreatorSupport {

    public Object getProxy(@Nullable ClassLoader classLoader) {
        // 首先获取AopProxy对象，其主要有两个实现：JdkDynamicAopProxy和ObjenesisCglibAopProxy，
        // 分别用于Jdk和Cglib代理类的生成，其getProxy()方法则用于获取具体的代理对象
        // 1.createAopProxy：创建AopProxy
        // 2.getProxy(classLoader)：获取代理对象实例
        return createAopProxy().getProxy(classLoader);
    }
}

 
 
createAopProxy()
 
 
     
  
  • 首先获取AopProxy对象，其主要有两个实现：JdkDynamicAopProxy和ObjenesisCglibAopProxy
    •  
 
 
 
public class ProxyCreatorSupport extends AdvisedSupport {
    protected final synchronized AopProxy createAopProxy() {
        //主要是为了激活AdvisedSupportListener监听器
        if (!this.active) {
            activate();
        }
        // 2.创建AopProxy
        return getAopProxyFactory().createAopProxy(this);
    }
}

 
 
getAopProxyFactory()
 
 
     
  
  • 获取AopProxyFactory
    •  
 
 
 
public class ProxyCreatorSupport extends AdvisedSupport {
        
    private AopProxyFactory aopProxyFactory;

    public ProxyCreatorSupport() {
        this.aopProxyFactory = new DefaultAopProxyFactory();
    }

    protected final synchronized AopProxy createAopProxy() {
        //主要是为了激活AdvisedSupportListener监听器
        if (!this.active) {
            activate();
        }
        // 2.创建AopProxy
        return getAopProxyFactory().createAopProxy(this);
    }

    public AopProxyFactory getAopProxyFactory() {
        return this.aopProxyFactory;
    }
}

 
 
createAopProxy
 
 
     
  
  • createAopProxy(this)
    •  
  
  • 创建AopProxy
    •  
 
 
 
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        // 1.判断使用JDK动态代理还是Cglib代理
        // optimize：用于控制通过cglib创建的代理是否使用激进的优化策略。除非完全了解AOP如何处理代理优化，
        // 否则不推荐使用这个配置，目前这个属性仅用于cglib代理，对jdk动态代理无效
        // proxyTargetClass：默认为false，设置为true时，强制使用cglib代理，设置方式：
        // hasNoUserSuppliedProxyInterfaces：config是否存在代理接口或者只有SpringProxy一个接口
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            // 拿到要被代理的对象的类型
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                // TargetSource无法确定目标类：代理创建需要接口或目标。
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            // 要被代理的对象是接口 || targetClass是Proxy class 已经是个JDK的代理类（Proxy的子类，所有的JDK代理类都是此类的子类）
            // 当且仅当使用getProxyClass方法或newProxyInstance方法动态生成指定的类作为代理类时，才返回true。
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                // JDK动态代理，这边的入参config(AdvisedSupport)实际上是ProxyFactory对象
                // 具体为：AbstractAutoProxyCreator中的proxyFactory.getProxy发起的调用，在ProxyCreatorSupport使用了this作为参数，
                // 调用了的本方法，这边的this就是发起调用的proxyFactory对象，而proxyFactory对象中包含了要执行的的拦截器
                return new JdkDynamicAopProxy(config);
            }
            // Cglib代理
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            // JDK动态代理
            return new JdkDynamicAopProxy(config);
        }
    }

    /**
     * 判断是否有实现自定义的接口
     */
    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        Class[] ifcs = config.getProxiedInterfaces();
        return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
    }

}

 
 
     
  
  • 这边创建 AopProxy 的参数 config（AdvisedSupport）实际上是proxyFactory 对象。
    •  
  
  • 具体为：AbstractAutoProxyCreator 中的 proxyFactory.getProxy 发起的调用，在 ProxyCreatorSupport 使用了 this 作为参数调用了本方法，这边的 this 就是发起调用的 proxyFactory对象，而 proxyFactory 对象中包含了要执行的的拦截器（Advisor）。
    •  
  
  • 无论是创建 JDK 动态代理还是 CGLIB 代理，都会传入 config 参数，该参数会被保存在 advised（AdvisedSupport）变量中。
    •  
 
 
 
JDK 动态代理、CBLIB 代理构造函数
 
 
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
        Assert.notNull(config, "AdvisedSupport must not be null");
        if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
            throw new AopConfigException("No advisors and no TargetSource specified");
        }
        this.advised = config;
    }
}


class ObjenesisCglibAopProxy extends CglibAopProxy {

    public ObjenesisCglibAopProxy(AdvisedSupport config) {
        super(config);
    }
}


class CglibAopProxy implements AopProxy, Serializable {
    public CglibAopProxy(AdvisedSupport config) throws AopConfigException {
        Assert.notNull(config, "AdvisedSupport must not be null");
        if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
            throw new AopConfigException("No advisors and no TargetSource specified");
        }
        this.advised = config;
        this.advisedDispatcher = new AdvisedDispatcher(this.advised);
    }
}

 
 
getProxy(classLoader)
 
 
     
  
  • 获取代理对象实例
    •  
 
 
 
JdkDynamicAopProxy#getProxy
 
 
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
        }
        // 1.拿到要被代理对象的所有接口
        Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        // 2.通过classLoader、接口、InvocationHandler实现类，来获取到代理对象
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }
}

 
 
最终，通过 JDK 动态代理的类被调用时，会走到 JdkDynamicAopProxy#invoke 方法。
 
 
JdkDynamicAopProxy#invoke
 
 
final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    @Override
    @Nullable
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;

        TargetSource targetSource = this.advised.targetSource;
        Object target = null;

        try {
            //若是equals方法不需要代理
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                return equals(args[0]);
            }
            //若是hashCode方法不需要代理
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                return hashCode();
            }
            // 如果当前方法是Spring织入的DecoratingProxy接口中的方法，则返回目标对象的Class类型
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                // There is only getDecoratedClass() declared -> dispatch to proxy config.
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            //如果被代理的对象本身就实现了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;
            //是否将动态代理暴露给AopContext
            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            // Get as late as possible to minimize the time we "own" the target,
            // in case it comes from a pool.
            //获取我们的目标对象
            target = targetSource.getTarget();
            Class targetClass = (target != null ? target.getClass() : null);

            // Get the interception chain for this method.
            //把aop的advisor转化为拦截器链
            List 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.
                // chain 是空的，说明不需要被织入横切逻辑，直接执行被代理的方法实例本身
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // We need to create a method invocation...
                // 获取目标对象的调用链逻辑，并且对该链进行调用
                MethodInvocation 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()) {
                // 如果返回值满足其为空，不是Void类型，并且是基本数据类型，那么就抛出异常，
                // 因为基本数据类型的返回值必然不为空
                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()方法将生成的目标对象释放
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                // Restore old proxy.
                // 处理AopContext中保存的当前代理对象
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
}
 
 
getInterceptorsAndDynamicInterceptionAdvice
 
 
     
  
  • List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass) 
  
  • 把aop的advisor转化为拦截器链
    •  
  
 
    public class AdvisedSupport extends ProxyConfig implements Advised {

    /**
     * 将之前注入到advisorChain中的advisors转换为MethodInterceptor
     * 和InterceptorAndDynamicMethodMatcher集合
     */
    public List getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class targetClass) {
        MethodCacheKey cacheKey = new MethodCacheKey(method);
        //尝试从缓存获取
        List cached = this.methodCache.get(cacheKey);
        if (cached == null) {
            //缓存没有，则尝试通过advisorChainFactory去创建调用链
            cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                    this, method, targetClass);
            //将获取到的结果加入到缓存中
            this.methodCache.put(cacheKey, cached);
        }
        return cached;
    }
}
 
 
    可以看出上面方法用到缓存的，假设现在缓存没有相应的拦截器, 则到 AdvisorChainFactory 的相应方法中获取，继续跟踪AdvisorChainFactory，进入DefaultAdvisorChainFactory中的相应方法，比较长。
     
 
    getInterceptorsAndDynamicInterceptionAdvice
     
 
       
  
    • cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this, method, targetClass)
      •  
  
    • 缓存没有，则尝试通过advisorChainFactory去创建调用链。
      •  
 
     
 
    public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {

    @Override
    public List getInterceptorsAndDynamicInterceptionAdvice(
            Advised config, Method method, @Nullable Class targetClass) {

        // This is somewhat tricky... We have to process introductions first,
        // but we need to preserve order in the ultimate list.
        //通过单例方式实例一个DefaultAdvisorAdapterRegistry
        // 拿到代理里面所有的通知们：getAdvisors
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        Advisor[] advisors = config.getAdvisors();
        List interceptorList = new ArrayList<>(advisors.length);
        Class actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
        Boolean hasIntroductions = null;

        for (Advisor advisor : advisors) {
            if (advisor instanceof PointcutAdvisor) {
                // Add it conditionally.
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                    //已预过滤过的或者这个切点适用于给定的接口或目标类
                    //从registry获取MethodInterceptor拦截器
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    boolean match;
                    if (mm instanceof IntroductionAwareMethodMatcher) {
                        if (hasIntroductions == null) {
                            hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
                        }
                        match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
                    }
                    else {
                        match = mm.matches(method, actualClass);
                    }
                    if (match) {
                        // 将advisor转为MethodInterceptor
                        MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                        // 动态匹配
                        if (mm.isRuntime()) {
                            // Creating a new object instance in the getInterceptors() method
                            // isn't a problem as we normally cache created chains.
                            for (MethodInterceptor interceptor : interceptors) {
                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                            }
                        }
                        else {
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            }
            else if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            }
            else {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }

        return interceptorList;
    }

    private static boolean hasMatchingIntroductions(Advisor[] advisors, Class actualClass) {
        for (Advisor advisor : advisors) {
            if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                if (ia.getClassFilter().matches(actualClass)) {
                    return true;
                }
            }
        }
        return false;
    }
}
 
 
    如果aop的advisor转化为拦截器链为空，说明不需要被织入横切逻辑，直接执行被代理的方法实例本身。
     
 
    invokeJoinpointUsingReflection
     
 
       
  
    • 目标对象方法的调用
      •  
  
    • AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse)
      •  
  
    • 其实是通过AopUtils的方法调用，使用反射机制来对目标对象的方法进行的。
      •  
 
     
 
    public abstract class AopUtils {

    @Nullable
    public static Object invokeJoinpointUsingReflection(@Nullable Object target, Method method, Object[] args)
            throws Throwable {

        // Use reflection to invoke the method.
        // 通过反射机制来获得相应的方法，并调用invoke
        try {
            ReflectionUtils.makeAccessible(method);
            return method.invoke(target, args);
        }
        catch (InvocationTargetException ex) {
            // Invoked method threw a checked exception.
            // We must rethrow it. The client won't see the interceptor.
            throw ex.getTargetException();
        }
        catch (IllegalArgumentException ex) {
            throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" +
                    method + "] on target [" + target + "]", ex);
        }
        catch (IllegalAccessException ex) {
            throw new AopInvocationException("Could not access method [" + method + "]", ex);
        }
    }
}


     
 
    如果aop的advisor转化为拦截器链不为空，获取目标对象的调用链逻辑，并且对该链进行调用。
     
 
       
  
    • 如果存在拦截器，则创建一个 ReflectiveMethodInvocation，代理对象、被代理对象、方法、参数、被代理对象的 Class、拦截器链作为参数。这边 ReflectiveMethodInvocation 已经持有了被代理对象、方法、参数，后续就可以直接使用反射来调用被代理的方法了。
      •  
 
     
 
    ReflectiveMethodInvocation 构造函数
     
 
    public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {

    protected ReflectiveMethodInvocation(
            Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,
            @Nullable Class targetClass, List interceptorsAndDynamicMethodMatchers) {

        this.proxy = proxy;
        this.target = target;
        this.targetClass = targetClass;
        this.method = BridgeMethodResolver.findBridgedMethod(method);
        this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
        this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
    }
}
 
 
    // 获取目标对象的调用链逻辑，并且对该链进行调用
MethodInvocation invocation =
        new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);

retVal = invocation.proceed();

     
 
    ReflectiveMethodInvocation#proceed() 拦截器方法执行
     
 
       
  
    • 看看拦截器对象，即ReflectiveMethodInvocation中proceed()方法的调用，
      •  
 
     
 
    public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {

    @Override
    @Nullable
    public Object proceed() throws Throwable {
        // We start with an index of -1 and increment early.
        // 注意这里是递归调用，所以是从索引为-1的拦截器开始调用，并按序递增
        //如果拦截器链中的拦截器调用完毕，就执行被代理的方法本身
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            //执行目标方法
            return invokeJoinpoint();
        }
        //获取第一个方法拦截器使用的是前++，获取下一个要执行的拦截器
        //每递归调用一次，currentInterceptorIndex加一。
        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            Class targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
            //精确匹配
            if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
                //递归调用
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                // 匹配错误，跳过，调用下一个
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            // 如果拦截的不是精确到方法级别的，比如是拦截一整个类，就直接调用，不用再匹配方法了
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }
}

     
 
    该方法是一个责任链的方法，会按索引执行所有的拦截器。
     
 
       
  
    • 如果所有拦截器都执行完毕（index是从-1开始，所以跟size - 1比较），则直接使用反射调用连接点（也就是我们原本的方法）。
      •  
  
    • MethodBeforeAdviceInterceptor 前置通知
      •  
  
    • AspectJAfterAdvice 后置通知
      •  
  
    • AfterReturningAdviceInterceptor 返回通知
      •  
  
    • AspectJAfterThrowingAdvice 异常通知
      •  
 
     
 
    以上拦截器方法都在invoke()方法中执行
     
 
    递归调用拦截器
     
 
     
  
     
   
      
   
     
  
     
  
     
 
     
 
    invokeJoinpoint 执行目标方法
     
 
    public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {

    @Nullable
    protected Object invokeJoinpoint() throws Throwable {
        // 反射执行连接点，也就是原方法，target为被代理的对象实例、method为执行的方法、arguments为方法参数
        return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
    }
}


public abstract class AopUtils {

    @Nullable
    public static Object invokeJoinpointUsingReflection(@Nullable Object target, Method method, Object[] args)
            throws Throwable {

        // Use reflection to invoke the method.
        // 通过反射机制来获得相应的方法，并调用invoke
        try {
            ReflectionUtils.makeAccessible(method);
            return method.invoke(target, args);
        }
        catch (InvocationTargetException ex) {
            // Invoked method threw a checked exception.
            // We must rethrow it. The client won't see the interceptor.
            throw ex.getTargetException();
        }
        catch (IllegalArgumentException ex) {
            throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" +
                    method + "] on target [" + target + "]", ex);
        }
        catch (IllegalAccessException ex) {
            throw new AopInvocationException("Could not access method [" + method + "]", ex);
        }
    }
}

     
 
    CglibAopProxy#getProxy
     
 
    class CglibAopProxy implements AopProxy, Serializable {

    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
        }

        try {
            // 1.拿到要代理目标类
            Class rootClass = this.advised.getTargetClass();
            Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
            // proxySuperClass默认为rootClass
            Class proxySuperClass = rootClass;
            // 这里判断rootClass是否是Cglib代理所产生的类（内部判断rootClass的className是否包含$$）
            // 如果rootClass是被Cglib代理过的，获取rootClass的父类作为proxySuperClass
            if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
                proxySuperClass = rootClass.getSuperclass();
                Class[] additionalInterfaces = rootClass.getInterfaces();
                for (Class additionalInterface : additionalInterfaces) {
                    // 将父类的接口也添加到advised的interfaces属性
                    this.advised.addInterface(additionalInterface);
                }
            }

            // Validate the class, writing log messages as necessary.
            // 方法校验，final方法不能被代理，记录日志
            // 2.校验proxySuperClass，主要是校验方法是否用final修饰、跨ClassLoader的包可见方法，如果有将警告写入日志
            validateClassIfNecessary(proxySuperClass, classLoader);

            // Configure CGLIB Enhancer...
            // 3.创建和配置Cglib Enhancer
            Enhancer enhancer = createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader &&
                        ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }
            // superclass为被代理的目标类proxySuperClass，通过名字可以看出，生成的代理类实际上是继承了被代理类
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

            // 4.获取所有要回调的拦截器
            // 通过callbacks设置拦截器链
            // spring在这里考虑了很多种情况，将所有callback放到一个数组中。
            // 而在某些特定场景下，spring还对回调进行了优化，生成新的回调函数，追加到callbacks数组中。
            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
            // 设置回调过滤器，修正后的拦截器map和偏移量在这里传进去
            // 在上面调用getCallbacks之后，此时仅填充fixedInterceptorMap
            enhancer.setCallbackFilter(new ProxyCallbackFilter(
                    this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
            enhancer.setCallbackTypes(types);

            // Generate the proxy class and create a proxy instance.
            // 生成代理类实例
            // 5.生成代理类并创建代理实例，返回代理实例
            return createProxyClassAndInstance(enhancer, callbacks);
        }
        catch (CodeGenerationException | IllegalArgumentException ex) {
            throw new AopConfigException("Could not generate CGLIB subclass of " + 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);
        }
    }
}

     
 
    getCallbacks
     
 
       
  
    • 获取所有要回调的拦截器
      •  
 
     
 
    class CglibAopProxy implements AopProxy, Serializable {

    private Callback[] getCallbacks(Class rootClass) throws Exception {
        // Parameters used for optimization choices...
        // 1.用于优化选择的参数
        boolean exposeProxy = this.advised.isExposeProxy();
        boolean isFrozen = this.advised.isFrozen();
        boolean isStatic = this.advised.getTargetSource().isStatic();

        // Choose an "aop" interceptor (used for AOP calls).
        // 最常用的就是这个拦截器DynamicAdvisedInterceptor
        // 2.使用AdvisedSupport作为参数，创建一个DynamicAdvisedInterceptor（“aop”拦截器，用于AOP调用）
        // this.advised就是之前创建CglibAopProxy时传进来的ProxyFactory(ProxyCreatorSupport子类)
        Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

        // Choose a "straight to target" interceptor. (used for calls that are
        // unadvised but can return this). May be required to expose the proxy.
        Callback targetInterceptor;
        if (exposeProxy) {
            targetInterceptor = (isStatic ?
                    new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
                    new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
        }
        else {
            targetInterceptor = (isStatic ?
                    new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
                    new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));
        }

        // Choose a "direct to target" dispatcher (used for
        // unadvised calls to static targets that cannot return this).
        Callback targetDispatcher = (isStatic ?
                new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());

        // 原始的7种callback
        // 3.将aop拦截器添加到mainCallbacks中
        Callback[] mainCallbacks = new Callback[] {
                aopInterceptor,  // for normal advice
                targetInterceptor,  // invoke target without considering advice, if optimized
                new SerializableNoOp(),  // no override for methods mapped to this
                targetDispatcher, this.advisedDispatcher,
                new EqualsInterceptor(this.advised),
                new HashCodeInterceptor(this.advised)
        };

        Callback[] callbacks;

        // If the target is a static one and the advice chain is frozen,
        // then we can make some optimizations by sending the AOP calls
        // direct to the target using the fixed chain for that method.
        // 如果目标类是不可变的(getTarget()方法返回的对象是否一直是同一个，也就是说对单例对象而言，isStatic都返回true)，
        // 且代理对象被冻结(isFrozen属性设置为true)，那么spring将会采取优化，在callbacks数组中增加了新的回调，
        // 使用修正后的增强链把aop调用直接转发到目标方法来进行一些优化，也就是说此时代理将不生效
        if (isStatic && isFrozen) {
            Method[] methods = rootClass.getMethods();
            Callback[] fixedCallbacks = new Callback[methods.length];
            this.fixedInterceptorMap = new HashMap<>(methods.length);

            // TODO: small memory optimization here (can skip creation for methods with no advice)
            for (int x = 0; x < methods.length; x++) {
                Method method = methods[x];
                List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
                fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
                        chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
                this.fixedInterceptorMap.put(method, x);
            }

            // Now copy both the callbacks from mainCallbacks
            // and fixedCallbacks into the callbacks array.
            // 把默认的7种callback和修正后的callback合并到一个数组中返回
            callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
            System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
            System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
            this.fixedInterceptorOffset = mainCallbacks.length;
        }
        else {
            callbacks = mainCallbacks;
        }
        return callbacks;
    }
}
 
 
    最终，通过 CGLIB 代理的类被调用时，会走到 DynamicAdvisedInterceptor#intercept 方法。
     
 
    DynamicAdvisedInterceptor#intercept
     
 
    class CglibAopProxy implements AopProxy, Serializable {
    private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {

        private final AdvisedSupport advised;

        public DynamicAdvisedInterceptor(AdvisedSupport advised) {
            this.advised = advised;
        }

        @Override
        @Nullable
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            boolean setProxyContext = false;
            Object target = null;
            TargetSource targetSource = this.advised.getTargetSource();
            try {
                if (this.advised.exposeProxy) {
                    // Make invocation available if necessary.
                    oldProxy = AopContext.setCurrentProxy(proxy);
                    setProxyContext = true;
                }
                // Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
                target = targetSource.getTarget();
                Class targetClass = (target != null ? target.getClass() : null);
                // 这里获取拦截器链的方式与jdk动态代理方式调用了同一个方法
                List 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.
                    // chain 是空的，说明不需要被织入横切逻辑，直接执行被代理的方法实例本身
                    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 && !targetSource.isStatic()) {
                    // 如果TargetSource不是静态的，
                    // 则调用其releaseTarget()方法将生成的目标对象释放
                    targetSource.releaseTarget(target);
                }
                if (setProxyContext) {
                    // Restore old proxy.
                    // 处理AopContext中保存的当前代理对象
                    AopContext.setCurrentProxy(oldProxy);
                }
            }
        }
    }
}
 
 
       
  
    • DynamicAdvisedInterceptor#intercept()，该方法中通过List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)获取一个List拦截链，这里获取拦截器链的方式与上面分析jdk动态代理方式调用了同一个方法。
       
  
    • 然后通过retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed()方法执行对应的拦截链进行执行处理。
      •  
  
    • 最后通过processReturnType(proxy, target, method, retVal)处理返回值，并返回。
      •  
  
    • 整体过程完全采用动态代理模式来实现。
      •  
  
 
      CglibMethodInvocation构造函数
       
 
      class CglibAopProxy implements AopProxy, Serializable {

    private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

        @Nullable
        private final MethodProxy methodProxy;

        public CglibMethodInvocation(Object proxy, @Nullable Object target, Method method,
                Object[] arguments, @Nullable Class targetClass,
                List interceptorsAndDynamicMethodMatchers, MethodProxy methodProxy) {

            super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);

            // Only use method proxy for public methods not derived from java.lang.Object
            this.methodProxy = (Modifier.isPublic(method.getModifiers()) &&
                    method.getDeclaringClass() != Object.class && !AopUtils.isEqualsMethod(method) &&
                    !AopUtils.isHashCodeMethod(method) && !AopUtils.isToStringMethod(method) ?
                    methodProxy : null);
        }
    }
}
 
 
      CglibMethodInvocation#proceed()
       
 
      class CglibAopProxy implements AopProxy, Serializable {

    private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

        @Override
        @Nullable
        public Object proceed() throws Throwable {
            try {
                return super.proceed();
            }
            catch (RuntimeException ex) {
                throw ex;
            }
            catch (Exception ex) {
                if (ReflectionUtils.declaresException(getMethod(), ex.getClass())) {
                    throw ex;
                }
                else {
                    throw new UndeclaredThrowableException(ex);
                }
            }
        }
    }
}

       
 
      CglibMethodInvocation中的proceed方法最终调用到了ReflectiveMethodInvocation类中的proceed方法，该方法在前面JDK动态代理中解析过。
       
 
      至此，创建 AOP 代理，以及AOP的调用，已经介绍完毕。
       
 
      总结：
       
 
         
  
      • 1、@EnableAspectJAutoProxy 会注册一个AnnotationAwareAspectJAutoProxyCreator
        •  
  
      • 2、AnnotationAwareAspectJAutoProxyCreator是一个InstantiationAwareBeanPostProcessor
        •  
  
      •  
        3、创建流程：
         
   
           
    
        • A、registerBeanPostProcessors() 注册后置处理器，创建AnnotationAwareAspectJAutoProxyCreator
          •  
    
        • B、finishBeanFactoryInitialization 初始化剩下的单实例Bean 
     
             
      
          • a、创建Bean和切面
            •  
      
          • b、AnnotationAwareAspectJAutoProxyCreator拦截创建过程
            •  
      
          • c、创建完Bean判断是否需要增强。通过BeanPostProcessorsAfterInitialization，wrapIfNecessary() 包装代理对象
            •  
     
           
          •  
   
         
        •  
  
      •  
        4、执行目标方法
         
   
           
    
        • A、获取拦截器链（advisor包装为Interceptor）
          •  
    
        • B、递归调用拦截器链 
     
             
      
          • 前置通知、目标方法、后置通知、返回通知、异常通知
            •  
     
           
          •  
   
         
        •  
 
       
 
      参考：
       https://zhuanlan.zhihu.com/p/104521455
       
 
      https://segmentfault.com/a/1190000015830477
       
 
      https://blog.csdn.net/fuli_mouren/article/details/45244453
       
 
      http://www.mamicode.com/info-detail-890966.html
       

                            
                        
                    
                    
                    
      
                    
                    
                    
      
                
                
      
                    
                
      
            
        
    
    
      
        
      你可能感兴趣的:(Spring5AOP——创建AOP动态代理)
      
        
      
            
      
                
        
                    
      • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
        目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
        
                    
        • 
                    
      • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
        在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
        
                    
        • 
                    
      • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
        需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
        
                    
        • 
                    
      • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
        如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
        
                    
        • 
                    
      • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
        GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
        
                    
        • 
                    
      • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
        本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
        
                    
        • 
                    
      • 509. 斐波那契数(每日一题)
                        lzyprime

                        
        lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
        
                    
        • 
                    
      • 在一台Ubuntu计算机上构建Hyperledger Fabric网络
                        落叶无声9
区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
                        
        在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
        
                    
        • 
                    
      • Python快速入门 —— 第三节：类与对象
                        孤华暗香
Python快速入门python开发语言
                        
        第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
        
                    
        • 
                    
      • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
        文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
        
                    
        • 
                    
      • 【Git】常见命令(仅笔记)
                        好想有猫猫
GitLinux学习笔记git笔记elasticsearchlinuxc++
                        
        文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
        
                    
        • 
                    
      • Linux MariaDB使用OpenSSL安装SSL证书
                        Meta39
MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
                        
        进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
        
                    
        • 
                    
      • Python中深拷贝与浅拷贝的区别
                        yuxiaoyu.

                        
        转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
        
                    
        • 
                    
      • 一文掌握python常用的list（列表）操作
                        程序员neil
pythonpython开发语言
                        
        目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
        
                    
        • 
                    
      • python中的深拷贝与浅拷贝
                        anshejd70787
python
                        
        深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
        
                    
        • 
                    
      • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
        这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
        
                    
        • 
                    
      • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
        在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
        
                    
        • 
                    
      • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理
                        月夜星辉雪
rabbitmq分布式
                        
        文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
        
                    
        • 
                    
      • vue 创建项目报错：command failed: npm install --loglevel error
                        那鱼、会飞
vue.jsvue-cli3
                        
        这个问题其实很好解决，只是很多种情况，逐一排除即可。稳下心来~vuecli3创建项目我的node版本是node14.15.0，（永远不要尝试最新版本）node各种版本下载地址：以往的版本|Node.js(nodejs.org)vue/[email protected]@vue/[email protected]（注意vue/cli2和vue/cli3的下载命名有所改变，2是-形式，3是/形式）其实报错
        
                    
        • 
                    
      • iOS内存管理简单理解
                        烧烤有点辣

                        
        什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
        
                    
        • 
                    
      • python获取子进程返回值_Python对进程Multiprocessing子进程返回值
                        weixin_39752157
python获取子进程返回值
                        
        在实际使用多进程的时候，可能需要获取到子进程运行的返回值。如果只是用来存储，则可以将返回值保存到一个数据结构中；如果需要判断此返回值，从而决定是否继续执行所有子进程，则会相对比较复杂。另外在Multiprocessing中，可以利用Process与Pool创建子进程，这两种用法在获取子进程返回值上的写法上也不相同。这篇中，我们直接上代码，分析多进程中获取子进程返回值的不同用法，以及优缺点。初级用法
        
                    
        • 
                    
      • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
        博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
        
                    
        • 
                    
      • 非对称加密算法原理与应用2——RSA私钥加密文件
                        私语茶馆
云部署与开发架构及产品灵感记录RSA2048私钥加密
                        
        作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
        
                    
        • 
                    
      • MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
        目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
        
                    
        • 
                    
      • Python编程 - 初识面向对象
                        易辰君
Python核心编程python开发语言
                        
        目录前言一、面向对象二、类和对象（一）类简介定义类（二）对象简介创建对象（三）总结三、实例属性和实例方法（一）实例属性创建的基本语法使用示例（二）实例方法定义实例方法的基本语法调用示例方法的示例（三）总结四、类中的self（一）基本概念（二）作用访问实例属性调用其他实例方法在构造函数中初始化对象（三）总结五、__init__方法（一）__init__方法的特点（二）基本语法（三）示例（四）总结前言
        
                    
        • 
                    
      • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
        文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
        
                    
        • 
                    
      • 【2023年】云计算金砖牛刀小试6
                        geekgold
云计算服务器网络kubernetes容器
                        
        第一套【任务1】私有云服务搭建[10分]【题目1】基础环境配置[0.5分]使用提供的用户名密码，登录提供的OpenStack私有云平台，在当前租户下，使用CentOS7.9镜像，创建两台云主机，云主机类型使用4vCPU/12G/100G_50G类型。当前租户下默认存在一张网卡，自行创建第二张网卡并连接至controller和compute节点（第二张网卡的网段为10.10.X.0/24，X为工位号
        
                    
        • 
                    
      • vue render 函数详解 (配参数详解)
                        你的眼睛會笑
vue2vue.jsjavascript前端
                        
        vuerender函数详解(配参数详解)在Vue3中，`render`函数被用来代替Vue2中的模板语法。它接收一个h函数（或者是`createElement`函数的别名），并且返回一个虚拟DOM。render函数的语法结构如下：render(h){returnh('div',{class:'container'},'Hello,World!')}在上面的示例中，我们使用h函数创建了一个div元素
        
                    
        • 
                    
      • C++常见知识掌握
                        nfgo
c++开发语言
                        
        1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
        
                    
        • 
                    
      • Dockerfile FROM 两个
                        redDelta

                        
        Docker相关视频讲解：什么是容器Docker介绍实现"DockerfileFROM两个"的步骤步骤表格步骤操作1创建一个Dockerfile文件2写入FROM指令3构建第一个镜像4创建第二个Dockerfile文件5写入FROM指令6构建第二个镜像7合并两个镜像操作步骤说明步骤1：创建一个Dockerfile文件使用任意文本编辑器创建一个名为Dockerfile的文件。登录后复制#Docker
        
                    
        • 
                                
      • 辗转相处求最大公约数
                                    沐刃青蛟
C++漏洞
                                    
        无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！ 
  
为此，总结一下以方便日后忘了好查找。 
  
1.输入要比较的两个数a,b 
  
忽略：2.比较大小（因为后面要的是大的数对小的数做%操作） 
  
3.辗转相除（用循环不停的取余，如a%b,直至b=0） 
  
4.最后的a为两数的最大公约数 
&
        
                                
        • 
                                
      • F5负载均衡会话保持技术及原理技术白皮书
                                    bijian1013
F5负载均衡
                                    
        一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
        
                                
        • 
                                
      • Object.equals方法：重载还是覆盖
                                    Cwind
javagenericsoverrideoverload
                                    
        本文译自StackOverflow上对此问题的讨论。 
原问题链接 
  
在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： 
“不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” 
pu
        
                                
        • 
                                
      • 初始线程
                                    15700786134

                                    
              暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。 
  
  
       既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： 
public class ShapeFr
        
                                
        • 
                                
      • Linux的tcpdump
                                    被触发
tcpdump
                                    
        用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 
 
实用命令实例 
默认启动 
tcpdump 
普通情况下，直
        
                                
        • 
                                
      • 安卓程序listview优化后还是卡顿
                                    肆无忌惮_
ListView
                                    
        最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 
&nb
        
                                
        • 
                                
      • 扩展easyUI tab控件，添加加载遮罩效果
                                    知了ing
jquery
                                    
        (function () {  
    $.extend($.fn.tabs.methods, {  
        //显示遮罩  
        loading: function (jq, msg) {  
            return jq.each(function () {  
                var panel = $(this).tabs(&
        
                                
        • 
                                
      • gradle上传jar到nexus
                                    矮蛋蛋
gradle
                                    
        原文地址： 
https://docs.gradle.org/current/userguide/maven_plugin.html 
configurations { 
    deployerJars 
} 
 
dependencies { 
    deployerJars "org.apache.maven.wagon
        
                                
        • 
                                
      • 千万条数据外网导入数据库的解决方案。
                                    alleni123
sqlmysql
                                    
        从某网上爬了数千万的数据，存在文本中。 
然后要导入mysql数据库。 
 
悲剧的是数据库和我存数据的服务器不在一个内网里面。。 
 
 
ping了一下， 19ms的延迟。 
 
于是下面的代码是没用的。 
 

ps = con.prepareStatement(sql);
	ps.setString(1, info.getYear())............;
			ps.exec
        
                                
        • 
                                
      • JAVA IO InputStreamReader和OutputStreamReader
                                    百合不是茶
JAVA.io操作 字符流
                                    
        这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： 
JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流 
  
字节流和字符的难点：a,怎么将读到的数据
        
                                
        • 
                                
      • MO、MT解读
                                    bijian1013
GSM
                                    
        MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 
上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
        
                                
        • 
                                
      • 五个JavaScript基础问题
                                    bijian1013
JavaScriptcallapplythisHoisting
                                    
        下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 
问题1：Scope作用范围 
考虑下面的代码：  
(function() {
   var a = b = 5;
})();
console.log(b); 
什么会被打印在控制台上？  
回答： 
        上面的代码会打印 5。 
&nbs
        
                                
        • 
                                
      • 【Thrift二】Thrift Hello World
                                    bit1129
Hello world
                                    
        本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程 
  
1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 
        <dependency>
        
        
                                
        • 
                                
      • 【Avro一】Avro入门
                                    bit1129
入门
                                    
        本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。 
  1. 添加Maven依赖 
  
<?xml version="1.0" encoding="UTF-8"?>
<proj
        
                                
        • 
                                
      • 安装nginx+ngx_lua支持WAF防护功能
                                    ronin47

                                    
        需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
        
                                
        • 
                                
      • java-5.查找最小的K个元素-使用最大堆
                                    bylijinnan
java
                                    
        
import java.util.Arrays;
import java.util.Random;


public class MinKElement {

	/**
	 * 5.最小的K个元素
	 * I would like to use MaxHeap.
	 * using QuickSort is also OK
	 */
	public static void
        
                                
        • 
                                
      • TCP的TIME-WAIT
                                    bylijinnan
socket
                                    
        原文连接： 
http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 
 
以下为对原文的阅读笔记 
 
说明： 
主动关闭的一方称为local end，被动关闭的一方称为remote end 
本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 
 
1、TIME_WA
        
                                
        • 
                                
      • jquery ajax 序列化表单
                                    coder_xpf
Jquery ajax 序列化
                                    
          
 checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值 
  
<input type="checkbox" name="favor" id="favor" checked="checked"/>
$("#favor&quo
        
                                
        • 
                                
      • Apache集群乱码和最高并发控制
                                    cuisuqiang
apachetomcat并发集群乱码
                                    
        都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 
最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： 
<Connector maxThreads="300" port="8019" prot
        
                                
        • 
                                
      • websocket
                                    dalan_123
websocket
                                    
        一、低延迟的客户端-服务器 和 服务器-客户端的连接 
很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。 
  通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
        
                                
        • 
                                
      • 菜鸟分析网络执法官
                                    dcj3sjt126com
网络
                                    
          
最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. 
OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 
前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
        
                                
        • 
                                
      • Android相对布局属性全集
                                    dcj3sjt126com
android
                                    
        RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 
// 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
        
                                
        • 
                                
      • Tomcat内存设置详解
                                    eksliang
jvmtomcattomcat内存设置
                                    
        Java内存溢出详解 
  
一、常见的Java内存溢出有以下三种： 
  
1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 
可以利用JVM提
        
                                
        • 
                                
      • Java6 JVM参数选项
                                    greatwqs
javaHotSpotjvmjvm参数JVM Options
                                    
        Java 6 JVM参数选项大全（中文版）  
  
作者：Ken Wu 
Email: [email protected] 
转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！ 
  
本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
        
                                
        • 
                                
      • weblogic创建JMC
                                    i5land
weblogicjms
                                    
        进入 weblogic控制太 
1.创建持久化存储 
 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 
 
2.创建JMS服务器 
 --Services--Messaging--JMS Servers--new--name随便起--Pers
        
                                
        • 
                                
      • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构
                                    justjavac
DHT
                                    
        上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 
系统包括几个独立的部分： 
 
  使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子；  
  使用 PHP CI 框架开发的简易网站；  
  搜索引擎目前直接使用的 MySQL，将来可以考虑使
        
                                
        • 
                                
      • sql添加、删除表中的列
                                    macroli
sql
                                    
        添加没有默认值：alter table Test add BazaarType char(1) 
有默认值的添加列：alter table Test add BazaarType char(1) default(0) 
删除没有默认值的列：alter table Test drop COLUMN BazaarType 
删除有默认值的列：先删除约束（默认值）alter table Test DRO
        
                                
        • 
                                
      • PHP中二维数组的排序方法
                                    abc123456789cba
排序二维数组PHP
                                    
        <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level 
        
                                
        • 
                                
      • hive优化之------控制hive任务中的map数和reduce数
                                    superlxw1234
hivehive优化
                                    
        一、    控制hive任务中的map数:  1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。  主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
        
                                
        • 
                                
      • Spring Boot 1.2.4 发布
                                    wiselyman
spring boot
                                    
        Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。 
  
这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。 
  
Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
        
                                
        •