石小白aqa
石小白aqa

Spring AOP核心源码、原理详解前篇

本文主要分4部分

  1. Aop原理介绍
  2. 介绍aop相关的一些类
  3. 通过源码详解aop代理的创建过程
  4. 通过源码详解aop代理的调用过程
  5. Aop代理一些特性的使用案例

Spring AOP原理
原理比较简单，主要就是使用jdk动态代理和cglib代理来创建代理对象，通过代理对象来访问目标对象，而代理对象中融入了增强的代码，最终起到对目标对象增强的效果。

aop相关的一些类

  1. 连接点（JoinPoint）相关类
  2. 通知（Advice）相关的类
  3. 切入点（Pointcut）相关的类
  4. 切面（Advisor）相关的类
连接点（JoinPoint）相关类

JoinPoint接口
这个接口表示一个通用的运行时连接点（在AOP术语中)

import java.lang.reflect.AccessibleObject;

public interface Joinpoint {
    /**
     * 转到拦截器链中的下一个拦截器
     * @return
     * @throws Throwable
     */
    Object proceed() throws Throwable;

    /**
     * 返回保存当前连接点静态部分【的对象】，这里一般指被代理的目标对象
     * @return
     */
    Object getThis();

    /**
     * 返回此静态连接点 一般就为当前的Method(至少目前的唯一实现是MethodInvocation,所以连接点得静态部分肯定就是本方法)
     * @return
     */
    AccessibleObject getStaticPart();
}

几个重要的子接口和实现类，如下：


image.png

Invocation接口
此接口表示程序中的调用，调用是一个连接点，可以被拦截器拦截。

package org.aopalliance.intercept;

public interface Invocation extends Joinpoint {
    /**
     * 将参数作为数组对象获取，可以更改此数组中的元素值以更改参数。
     * 通常用来获取调用目标方法的参数
     */
    Object[] getArguments();
}

MethodInvocation接口
用来表示连接点中方法的调用，可以获取调用过程中的目标方法。

package org.aopalliance.intercept;
import java.lang.reflect.Method;

/**
 * 方法调用的描述，在方法调用时提供给拦截器。
 * 方法调用是一个连接点，可以被方法拦截器拦截。
 */
public interface MethodInvocation extends Invocation {
    /**
     * 返回正在被调用得方法~~~ 返回的是当前Method对象。
     * 此时，效果同父类的AccessibleObject getStaticPart() 这个方法
     */
    Method getMethod();
}

ProxyMethodInvocation接口
表示代理方法的调用


public interface ProxyMethodInvocation extends MethodInvocation {
    /**
     * 获取被调用的代理对象
     * @return
     */
    Object getProxy();

    /**
     * 克隆一个方法调用器MethodInvocation
     * @return
     */
    MethodInvocation invocableClone();

    /**
     * 克隆一个方法调用器MethodInvocation，并为方法调用器指定参数
     * @param arguments
     * @return
     */
    MethodInvocation invocableClone(Object... arguments);

    /**
     * 设置要用于此链中任何通知的后续调用的参数
     * @param arguments
     */
    void setArguments(Object... arguments);

    /**
     * 添加一些扩展用户属性，这些属性不在AOP框架内使用。它们只是作为调用对象的一部分保留，用于
     * 特殊的拦截器
     * @param key
     * @param value
     */
    void setUserAttribute(String key, @Nullable Object value);

    /**
     * 根据key获取对应的用户属性
     * @param key
     * @return
     */
    @Nullable
    Object getUserAttribute(String key);
}

通俗点理解：连接点表示方法的调用过程，内部包含了方法调用过程中的所有信息，比如被调用的方法、目标、代理对象、执行拦截器链等信息。
上面定义都是一些接口，最终有2个实现。

ReflectiveMethodInvocation
当代理对象是采用jdk动态代理创建的，通过代理对象来访问目标对象的方法的时，最终过程是由ReflectiveMethodInvocation来处理的，内部会通过递归调用方法拦截器，最终会调用到目标方法。

CglibMethodInvocation
功能和上面的类似，当代理对象是采用cglib创建的，通过代理对象来访问目标对象的方法的时，最终过程是由CglibMethodInvocation来处理的，内部会通过递归调用方法拦截器，最终会调用到目标方法。

通知相关的类

通知用来定义需要增强的逻辑。

image.png

Advice接口
通知的底层接口,只是一个标记作用 

package org.aopalliance.aop;

public interface Advice {
}

BeforeAdvice接口
方法前置通知，内部空的，也就是方法前置增强

package org.springframework.aop;
import org.aopalliance.aop.Advice;

public interface BeforeAdvice extends Advice {
}

Interceptor接口
此接口表示通用拦截器

package org.aopalliance.intercept;
public interface Interceptor extends Advice {
}

MethodInterceptor接口
方法拦截器，所有的通知均需要转换为MethodInterceptor类型的，最终多个MethodInterceptor组成一个方法拦截器连

package org.aopalliance.intercept;

@FunctionalInterface
public interface MethodInterceptor extends Interceptor {
    /**
     * 拦截目标方法的执行，可以在这个方法内部实现需要增强的逻辑，以及主动调用目标方法
     * @param methodInvocation
     * @return
     * @throws Throwable
     */
    Object invoke(MethodInvocation methodInvocation) throws Throwable;
}

AfterAdvice接口
后置通知的公共标记接口,也就是后置增强接口

package org.springframework.aop;
import org.aopalliance.aop.Advice;

public interface AfterAdvice extends Advice {
}

MethodBeforeAdvice接口
方法执行前通知，需要在目标方法执行前执行一些逻辑的，可以通过这个实现。
通俗点说：需要在目标方法执行之前增强一些逻辑，可以通过这个接口来实现。before方法：在调用给定方法之前回调。

package org.springframework.aop;

import java.lang.reflect.Method;
import org.springframework.lang.Nullable;

public interface MethodBeforeAdvice extends BeforeAdvice {
    /**
     *  调用目标方法之前会先调用这个before方法
     * @param method 需要执行的目标方法
     * @param args  目标方法的参数
     * @param target    目标对象
     * @throws Throwable
     */
    void before(Method method, Object[] args, @Nullable Object target) throws Throwable;
}

如同

public Object invoke(){
    调用MethodBeforeAdvice#before方法
    return 调用目标方法;
}

AfterReturningAdvice接口
方法执行后通知，需要在目标方法执行之后执行增强一些逻辑的，可以通过这个实现。
不过需要注意一点：目标方法正常执行后，才会回调这个接口，当目标方法有异常，那么这通知会被跳过。

package org.springframework.aop;
public interface AfterReturningAdvice extends AfterAdvice {
    /**
    * 目标方法执行之后会回调这个方法
    * method：需要执行的目标方法
    * args：目标方法的参数
    * target：目标对象
    */
    void afterReturning(@Nullable Object returnValue, Method method, Object[] args, @Nullable Object target) throws Throwable;
}

ThrowsAdvice接口
异常增强标记接口

package org.springframework.aop;

public interface ThrowsAdvice extends AfterAdvice {
}

此接口上没有任何方法，因为方法由反射调用，实现类必须实现以下形式的方法，前3个参数是可选的，最后一个参数为需要匹配的异常的类型。

void afterThrowing([Method, args, target], ThrowableSubclass);

通知包装器
负责将各种非MethodInterceptor类型的通知(Advice)包装为MethodInterceptor类型。
刚才有说过：Aop中所有的Advice最终都会转换为MethodInterceptor类型的，组成一个方法调用链，然后执行。
3个包装器类

  • MethodBeforeAdviceInterceptor
  • AfterReturningAdviceInterceptor
  • ThrowsAdviceInterceptor

MethodBeforeAdviceInterceptor类
这个类实现了 MethodInterceptor 接口，负责将 MethodBeforeAdvice 方法前置通知包装为MethodInterceptor 类型，创建这个类型的对象的时候需要传递一个MethodBeforeAdvice 类型的参数，重点是 invoke 方法。

package org.springframework.aop.framework.adapter;

import java.io.Serializable;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.BeforeAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.util.Assert;

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {
    private final MethodBeforeAdvice advice;

    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }

    public Object invoke(MethodInvocation mi) throws Throwable {
        //负责调用前置通知的方法
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        //继续执行方法调用链
        return mi.proceed();
    }
}

AfterReturningAdviceInterceptor类
这个类实现了 MethodInterceptor 接口，负责将 AfterReturningAdvice 方法后置通知包装为MethodInterceptor 类型，创建这个类型的对象的时候需要传递一个AfterReturningAdvice 类型的参数，重点是 invoke 方法

package org.springframework.aop.framework.adapter;

import java.io.Serializable;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterAdvice;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.util.Assert;

public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice, Serializable {
    private final AfterReturningAdvice advice;

    public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }

    public Object invoke(MethodInvocation mi) throws Throwable {
        //先执行方法调用链,可以获取目标方法的执行结果
        Object retVal = mi.proceed();
        //执行后置通知
        this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
        //返回结果
        return retVal;
    }
}

ThrowsAdviceInterceptor类
这个类实现了 MethodInterceptor 接口，负责将 ThrowsAdvice 异常通知包装为 MethodInterceptor类型，创建这个类型的对象的时候需要传递一个 Object 类型的参数，通常这个参数是 ThrowsAdvice类型的，重点是 invoke 方法


package org.springframework.aop.framework.adapter;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.AfterAdvice;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;

public class ThrowsAdviceInterceptor implements MethodInterceptor, AfterAdvice {
    private static final String AFTER_THROWING = "afterThrowing";
    private static final Log logger = LogFactory.getLog(org.springframework.aop.framework.adapter.ThrowsAdviceInterceptor.class);
    private final Object throwsAdvice;
    private final Map, Method> exceptionHandlerMap = new HashMap<>();

    public ThrowsAdviceInterceptor(Object throwsAdvice) {
        Assert.notNull(throwsAdvice, "Advice must not be null");
        this.throwsAdvice = throwsAdvice;
        //获取异常通知中定义的所有方法（public、默认的、protected、private）
        Method[] methods = throwsAdvice.getClass().getMethods();
        int length = methods.length;
        //轮询methods
        for (Method method : methods) {
            //方法名称为afterThrowing && 方法参数为1或者4
            if (method.getName().equals(AFTER_THROWING) && (method.getParameterCount() == 1 || method.getParameterCount() == 4)) {
                //获取方法的最后一个参数类型
                Class throwableParam = method.getParameterTypes()[method.getParameterCount() - 1];
                //判断方法参数类型是不是Throwable类型的
                if (Throwable.class.isAssignableFrom(throwableParam)) {
                    //缓存异常处理方法到map中（异常类型->异常处理方法）
                    this.exceptionHandlerMap.put(throwableParam, method);
                }
            }
        }
        //如果exceptionHandlerMap是空，抛出异常，所以最少要有一个异常处理方法
        if (this.exceptionHandlerMap.isEmpty()) {
            throw new IllegalArgumentException("At least one handler method must be found in class [" + throwsAdvice.getClass() + "]");
        }
    }

    /**
     * @return 获取异常通知中自定义的处理异常方法的数量
     */
    public int getHandlerMethodCount() {
        return this.exceptionHandlerMap.size();
    }

    public Object invoke(MethodInvocation mi) throws Throwable {
        try {
            //调用通知链
            return mi.proceed();
        } catch (Throwable e) {
            //获取异常通知中自定义的处理异常的方法
            Method handlerMethod = this.getExceptionHandler(e);
            //当处理的方法不为空
            if (handlerMethod != null) {
                this.invokeHandlerMethod(mi, e, handlerMethod);
            }
            //继续向外抛出异常
            throw e; //@1
        }
    }

    /**
     * @param exception 获取throwsAdvice中处理exception参数指定的异常的方法
     * @return
     */
    @Nullable
    private Method getExceptionHandler(Throwable exception) {
        //获取异常类型
        Class exceptionClass = exception.getClass();

        //从缓存中获取异常类型对应的方法
        Method handler = this.exceptionHandlerMap.get(exceptionClass);
        //来一个循环，查询处理方法，循环条件：方法为空 && 异常类型!=Throwable
        while (handler == null && exceptionClass != Throwable.class) {
            //获取异常的父类型
            exceptionClass = exceptionClass.getSuperclass();
            //从缓存中查找异常对应的处理方法
            handler = this.exceptionHandlerMap.get(exceptionClass);
        }
        //将查找结果返回
        return handler;
    }

    /**
     *  通过反射调用异常通知中的异常方法
     * @param mi
     * @param ex
     * @param method
     * @throws Throwable
     */
    private void invokeHandlerMethod(MethodInvocation mi, Throwable ex, Method method) throws Throwable {
        //构建方法请求参数
        Object[] handlerArgs;
        //若只有1个参数，参数为：异常对象
        if (method.getParameterCount() == 1) {
            handlerArgs = new Object[]{ex};
        } else {
            //4个参数（方法、方法请求参数、目标对象、异常对象）
            handlerArgs = new Object[]{mi.getMethod(), mi.getArguments(), mi.getThis(), ex};
        }

        try {
            //通过反射调用异常通知中的方法
            method.invoke(this.throwsAdvice, handlerArgs);
        } catch (InvocationTargetException tx) {
            throw tx.getTargetException();
        }
    }
}

从上面可以看出，异常通知，自定义处理异常的方法有几个特点

  1. 方法名称必须为 afterThrowing
  2. 方法参数必须1个或4个，最后一个参数是 Throwable 类型或其子类型
  3. 可以在异常处理中记录一些异常信息，这个还是比较有用的，但是注意一点目标方法抛出的异常最后还是会向外继续抛出 @1
切入点(PointCut)相关类

通知（Advice）用来指定需要增强的逻辑，但是哪些类的哪些方法中需要使用这些通知呢？这个就是通过切入点来配置的。


image.png 
public interface Pointcut {

    //匹配所有对象的 Pointcut，内部的2个过滤器默认都会返回true
    Pointcut TRUE = TruePointcut.INSTANCE;

    /**
     * 类过滤器, 可以知道哪些类需要拦截
     * @return
     */
    ClassFilter getClassFilter();

    /**
     * 方法匹配器, 可以知道哪些方法需要拦截
     * @return
     */
    MethodMatcher getMethodMatcher();
}

ClassFilter接口
类过滤器

@FunctionalInterface
public interface ClassFilter {
    ClassFilter TRUE = TrueClassFilter.INSTANCE;

    boolean matches(Class var1);
}

MethodMatcher接口
方法过滤器


package org.springframework.aop;
import java.lang.reflect.Method;

public interface MethodMatcher {
    
    //匹配所有方法，这个内部的2个matches方法任何时候都返回true
    org.springframework.aop.MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;

    /**
     * 执行静态检查给定方法是否匹配
     * @param method 目标方法
     * @param targetClass 目标对象类型
     * @return 是否通过
     */
    boolean matches(Method method, Class targetClass);

    /**
     *
     * @return 是否是动态匹配，即是否每次执行目标方法的时候都去验证一下
     */
    boolean isRuntime();

    /**
     *  动态匹配验证的方法，比第一个matches方法多了一个参数args，这个参数是调用目标方法传入的参数
     * @param method 目标方法
     * @param targetClass 目标对象类型
     * @param args 方法参数
     * @return 是否通过
     */
    boolean matches(Method method, Class targetClass, Object... args);
}

其实从字面意思我们都可以看出来，isRuntime这个标记是判断要不要根据方法参数动态的拦击。所以这个是第二层判断而已。

顾问(Advisor) 也就是切面

通知定义了需要做什么，切入点定义了在哪些类的哪些方法中执行通知，那么需要将他们2个组合起来才有效啊。
顾问（Advisor）就是做这个事情的。
在spring aop中，你可以将advisor理解为切面，切面中通常有2个关键信息：

  • 需要增强的目标方法列表，这个通过切入点(Pointcut)来指定
  • 需要在目标方法中增强的逻辑，这个通过(Advice)通知来指定
package org.springframework.aop;

import org.aopalliance.aop.Advice;

/**
 * 包含AOP通知（在joinpoint处执行的操作）和确定通知适用性的过滤器（如切入点[PointCut]）的基
 * 本接口。
 */
public interface Advisor {
    Advice EMPTY_ADVICE = new Advice() {
    };

    /**
     * 
     * @return 返回引用的通知
     */
    Advice getAdvice();

    boolean isPerInstance();
}

上面这个接口通常不会直接使用，这个接口有2个子接口，通常我们会和这2个子接口来打交道，下面看一下这2个子接口
PointcutAdvisor接口
通过名字就能看出来，这个和Pointcut有关，内部有个方法用来获取 Pointcut ，AOP使用到的大部分Advisor都属于这种类型的。
在目标方法中实现各种增强功能基本上都是通过PointcutAdvisor来实现的。

package org.springframework.aop;

public interface PointcutAdvisor extends Advisor {
    /**
     * 
     * @return 获取顾问中使用的切入点
     */
    Pointcut getPointcut();
}

DefaultPointcutAdvisor类
PointcutAdvisor的默认实现，这是最常用的Advisor实现，它可以用于任何Pointcut和Advice类型，代码相当简单，里面定义了2个属性：pointcut和advisor，由使用者指定。

IntroductionAdvisor接口
这个接口，估计大家比较陌生，干什么的呢？
一个Java类，没有实现A接口，在不修改Java类的情况下，使其具备A接口的功能。可以通过IntroductionAdvisor给目标类引入更多接口的功能，这个功能是不是非常牛逼。

下面开始2个重点工作。

  • 通过源码介绍aop中代理创建过程
  • 通过源码介绍代理方法的调用执行过程

创建代理3大步骤

  1. 创建代理所需参数配置
  2. 根据代理参数获取AopProxy对象
  3. 通过AopProxy获取代理对象

创建代理所需参数配置
创建代理所需参数配置主要是通过 AdvisedSupport 这个类来做的，看一下类图，下面一个个来介绍。

image.png

TargetClassAware接口
比较简单的一个接口，定义了一个方法，用来获取目标对象类型。
所谓目标对象：就是被代理对象。

package org.springframework.aop;
public interface TargetClassAware {
    @Nullable
     Class getTargetClass();
}

ProxyConfig类
这个类比较关键了，代理配置类，内部包含了创建代理时需要配置的各种参数。

package org.springframework.aop.framework;

import java.io.Serializable;
import org.springframework.util.Assert;

/**
 * 对外提供统一的代理参数配置类，以确保所有代理创建程序具有一致的属性
 */
public class ProxyConfig implements Serializable {
    private static final long serialVersionUID = -8409359707199703185L;
    //标记是否直接对目标类进行代理，而不是通过接口产生代理
    private boolean proxyTargetClass = false;
    /**
     * 标记是否对代理进行优化。启动优化通常意味着在代理对象被创建后，增强的修改将不会生效，因此
     * 默认值为false,
     * todo 如果exposeProxy设置为true，即使optimize为true也会被忽略。
     */
    private boolean optimize = false;
    //标记是否需要阻止通过该配置创建的代理对象转换为Advised类型，默认值为false，表示代理对象
    //可以被转换为Advised类型
    boolean opaque = false;
    /**
     * 标记代理对象是否应该被aop框架通过AopContext以ThreadLocal的形式暴露出去。
     * 当一个代理对象需要调用它自己的另外一个代理方法时，这个属性将非常有用。默认是是false，以
     * 避免不必要的拦截。
     */
    boolean exposeProxy = false;
    /**
     * 标记该配置是否需要被冻结，如果被冻结，将不可以修改增强的配置。
     * 当我们不希望调用方修改转换成Advised对象之后的代理对象时，这个配置将非常有用。
     */
    private boolean frozen = false;

    //...省略了属性的get set方法

    
}

Advised接口
这个接口中定义了操作Aop代理配置的各种方法（比如指定被代理的目标对象、添加通知、添加顾问等等）。
所有由spring aop创建的代理对象默认都会实现这个接口。


package org.springframework.aop.framework;

import org.aopalliance.aop.Advice;
import org.springframework.aop.Advisor;
import org.springframework.aop.TargetClassAware;
import org.springframework.aop.TargetSource;

public interface Advised extends TargetClassAware {
    /**
     *
     * @return 返回配置是否已冻结，被冻结之后，无法修改已创建好的代理对象中的通知
     */
    boolean isFrozen();

    /**
     * 是否对目标类直接创建代理，而不是对接口创建代理，通俗点讲：
     * @return 如果是通过cglib创建代理，此方法返回true，否则返回false
     */
    boolean isProxyTargetClass();

    /**
     *
     * @return 获取配置中需要代理的接口列表
     */
    Class[] getProxiedInterfaces();

    /**
     *
     * @param intf
     * @return 判断某个接口是否被代理
     */
    boolean isInterfaceProxied(Class intf);

    /**
     * 设置被代理的目标源，创建代理的时候，通常需要传入被代理的对象，最终被代理的对象会被包装为
     * TargetSource类型的
     * @param targetSource
     */
    void setTargetSource(TargetSource targetSource);

    TargetSource getTargetSource();

    void setExposeProxy(boolean var1);

    /**
     * 设置是否需要将代理暴露在ThreadLocal中，这样可以在线程中获取到被代理对象，这个配置挺有
     * 用的，稍后会举例说明使用场景
     * @return isExposeProxy
     */
    boolean isExposeProxy();

    /**
     *  设置此代理配置是否经过预筛选，以便它只包含适用的顾问(匹配此代理的目标类)。
     *  默认设置是“假”。如果已经对advisor进行了预先筛选，则将其设置为“true”
     *  这意味着在为代理调用构建实际的advisor链时可以跳过ClassFilter检查。
     * @param preFiltered
     */
    void setPreFiltered(boolean preFiltered);

    boolean isPreFiltered();

    //返回代理配置中干掉所有Advisor列表
    Advisor[] getAdvisors();

    //添加一个Advisor
    void addAdvisor(Advisor advisor) throws AopConfigException;

    //指定的位置添加一个Advisor
    void addAdvisor(int index, Advisor advisor) throws AopConfigException;

    //移除一个Advisor
    boolean removeAdvisor(Advisor advisor);

    //移除指定位置的Advisor
    void removeAdvisor(int index) throws AopConfigException;

    //查找某个Advisor的位置
    int indexOf(Advisor advisor);

    //对advisor列表中的a替换为b
    boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;

    //添加一个通知
    void addAdvice(Advice advice) throws AopConfigException;

    //向指定的位置添加一个通知
    void addAdvice(int index, Advice advice) throws AopConfigException;

    //移除一个通知
    boolean removeAdvice(Advice advice);

    //获取通知的位置
    int indexOf(Advice advice);

    //将代理配置转换为字符串，这个方便排错和调试使用的
    String toProxyConfigString();
}

AdvisedSupport类
这个类是个重点，AOP代理配置管理器的基类，继承了 ProxyConfig 并且实现了 Advised 接口，创建 aop代理之前，所有需要配置的信息都是通过这个类来操作的。
比如：设置是否为目标类创建代理、设置目标对象、配置通知列表等等

import lombok.Getter;
import org.aopalliance.aop.Advice;
import org.springframework.aop.Advisor;
import org.springframework.aop.IntroductionAdvisor;
import org.springframework.aop.TargetSource;
import org.springframework.aop.framework.Advised;
import org.springframework.aop.framework.AdvisorChainFactory;
import org.springframework.aop.framework.AopConfigException;
import org.springframework.aop.framework.DefaultAdvisorChainFactory;
import org.springframework.aop.framework.ProxyConfig;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.target.EmptyTargetSource;
import org.springframework.aop.target.SingletonTargetSource;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 *
 *
 * 上面几个类有几个结论，这里说一下。
 * 1. 配置中添加的Advice对象最终都会被转换为DefaultPointcutAdvisor对象，此时
 * DefaultPointcutAdvisor未指定pointcut，大家可以去看一下DefaultPointcutAdvisor中pointcut有
 * 个默认值，默认会匹配任意类的任意方法。
 * 2. 当配置被冻结的时候，即frozen为true的时，此时配置中的Advisor列表是不允许修改的。
 * 3. 上面的 getInterceptorsAndDynamicInterceptionAdvice 方法，通过代理调用目标方法的时
 * 候，最后需要通过方法和目标类的类型，从当前配置中会获取匹配的方法拦截器列表，获取方法拦
 * 截器列表是由 AdvisorChainFactory 负责的。
 * getInterceptorsAndDynamicInterceptionAdvice 会在调用代理的方法时会执行，稍后在执行
 * 阶段会详解。
 * 4. 目标方法和其关联的方法拦截器列表会被缓存在 methodCache 中，当顾问列表有变化的时候，
 * methodCache 缓存会被清除。
 * @description: 自己的代理类
 *
 * @author: stone
 * @date: Created by 2021/6/3 16:55
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springmybatis.spring.aop.principle
 */
public class AdvisedSupport extends ProxyConfig implements Advised {


    public static final TargetSource EMPTY_TARGET_SOURCE =
            EmptyTargetSource.INSTANCE;
    public TargetSource targetSource = EMPTY_TARGET_SOURCE;
    /**
     * 建议器是否已经针对特定的目标类进行筛选
     */
    private boolean preFiltered = false;
    /**
     * 调用链工厂，用来获取目标方法的调用链
     */
    @Getter
    public AdvisorChainFactory advisorChainFactory = new DefaultAdvisorChainFactory();
    /**
     * 方法调用链缓存：以方法为键，以顾问链表为值的缓存。
     */
    private transient Map> methodCache;
    //代理对象需要实现的接口列表。保存在列表中以保持注册的顺序，以创建具有指定接口顺序的JDK代理。
    private List> interfaces = new ArrayList<>();
    //配置的顾问列表。所有添加的Advise对象都会被包装为Advisor对象
    private List advisors = new ArrayList<>();
    //数组更新了对advisor列表的更改，这更容易在内部操作。
    private Advisor[] advisorArray = new Advisor[0];

    //无参构造方法
    public AdvisedSupport() {
        this.methodCache = new ConcurrentHashMap<>(32);
    }

    //有参构造方法，参数为：代理需要实现的接口列表
    public AdvisedSupport(Class... interfaces) {
        this();
        this.setInterfaces(interfaces);

    }

    //设置目标对象
    public void setTarget(Object target) {
        this.setTargetSource(new SingletonTargetSource(target));

    }


    //todo 此方法先忽略，用来为目标类引入接口的
    private void validateIntroductionAdvisor(IntroductionAdvisor advisor) {
        advisor.validateInterfaces();
        // If the advisor passed validation, we can make the change.
        Class[] ifcs = advisor.getInterfaces();
        for (Class ifc : ifcs) {
            addInterface(ifc);
        }
    }

    //指定的位置添加顾问
    private void addAdvisorInternal(int pos, Advisor advisor) throws
            AopConfigException {
        Assert.notNull(advisor, "Advisor must not be null");
        if (isFrozen()) {
            throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
        }
        if (pos > this.advisors.size()) {
            throw new IllegalArgumentException(
                    "Illegal position " + pos + " in advisor list with size " +
                            this.advisors.size());
        }
        this.advisors.add(pos, advisor);
        updateAdvisorArray();
        adviceChanged();
    }

    //将advisorArray和advisors保持一致
    protected final void updateAdvisorArray() {
        this.advisorArray = this.advisors.toArray(new Advisor[0]);
    }

    //获取顾问列表
    protected final List getAdvisorsInternal() {
        return this.advisors;
    }

    //设置被代理的目标类
    public void setTargetClass(Class targetClass) {
        this.targetSource = EmptyTargetSource.forClass(targetClass);
    }

    //获取被代理的目标类型
    @Override
    public Class getTargetClass() {
        return this.targetSource.getTargetClass();
    }

    //设置代理对象需要实现的接口
    public void setInterfaces(Class... interfaces) {
        Assert.notNull(interfaces, "Interfaces must not be null");
        this.interfaces.clear();
        for (Class ifc : interfaces) {
            addInterface(ifc);
        }

    }

    /**
     * 为代理对象添加需要实现的接口
     *
     * @param intf
     */
    public void addInterface(Class intf) {
        Assert.notNull(intf, "Interface must not be null");
        if (!intf.isInterface()) {
            throw new IllegalArgumentException("[" + intf.getName() + "] is not an interface");
        } else {
            if (!this.interfaces.contains(intf)) {
                this.interfaces.add(intf);
                this.adviceChanged();
            }

        }
    }

    /**
     * 通知更改时调用，会清空当前方法调用链缓存
     */
    protected void adviceChanged() {
        this.methodCache.clear();
    }

    /**
     *   * 设置顾问链工厂，当调用目标方法的时候，需要获取这个方法上匹配的Advisor列表，
     * 获取目标方法上匹配的Advisor列表的功能就是AdvisorChainFactory来负责的
     */
    public void setAdvisorChainFactory(AdvisorChainFactory advisorChainFactory) {
        Assert.notNull(advisorChainFactory, "advisorChainFactory is must not null");
        this.advisorChainFactory = advisorChainFactory;
    }

    //移除代理对象需要实现的接口
    public boolean removeInterface(Class intf) {
        return this.interfaces.remove(intf);
    }

    /**
     * 获取代理对象需要实现的接口列表
     *
     * @return
     */
    @Override
    public Class[] getProxiedInterfaces() {
        return ClassUtils.toClassArray(this.interfaces);
    }

    /**
     * 判断代理对象是否需要实现某个接口
     *
     * @param aClass
     * @return
     */
    @Override
    public boolean isInterfaceProxied(Class aClass) {
        for (Class proxyIntf : this.interfaces) {
            if (aClass.isAssignableFrom(proxyIntf)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public void setTargetSource(@Nullable TargetSource targetSource) {
        this.targetSource = (targetSource == null ? EMPTY_TARGET_SOURCE : targetSource);
    }


    //获取被代理的目标源
    @Override
    public TargetSource getTargetSource() {
        return this.targetSource;
    }


    /**
     * todo
     * 设置此代理配置是否经过预筛选，这个什么意思呢：通过目标方法调用代理的时候，
     * 需要通过匹配的方式获取这个方法上的调用链列表，查找过程需要2个步骤：
     * 第一步：类是否匹配，第二步：方法是否匹配，当这个属性为true的时候，会直接跳过第一步，这个
     * 懂了不
     */
    @Override
    public void setPreFiltered(boolean preFiltered) {
        this.preFiltered = preFiltered;
    }

    // 返回preFiltered
    @Override
    public boolean isPreFiltered() {
        return this.preFiltered;
    }


    /**
     * 获取所有的顾问列表
     *
     * @return
     */
    @Override
    public Advisor[] getAdvisors() {
        return this.advisorArray;
    }

    /**
     * 添加顾问
     *
     * @param advisor
     * @throws AopConfigException
     */
    @Override
    public void addAdvisor(Advisor advisor) throws AopConfigException {
        int pos = this.advisors.size();
        this.addAdvisor(pos, advisor);
    }

    /**
     * 指定的位置添加顾问
     *
     * @param pos
     * @param advisor
     * @throws AopConfigException
     */
    @Override
    public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
        // todo 这块先忽略，以后讲解
        if (advisor instanceof IntroductionAdvisor) {
            validateIntroductionAdvisor((IntroductionAdvisor) advisor);
        }
        addAdvisorInternal(pos, advisor);
    }

    @Override
    public boolean removeAdvisor(Advisor advisor) {
        int index = indexOf(advisor);
        if (index == -1) {
            return false;
        }
        removeAdvisor(index);
        return true;
    }

    @Override
    public void removeAdvisor(int index) throws AopConfigException {
        //当配置如果是冻结状态，是不允许对顾问进行修改的，否则会抛出异常
        if (isFrozen()) {
            throw new AopConfigException("Cannot remove Advisor: Configuration is frozen.");
        }
        if (index < 0 || index > this.advisors.size() - 1) {
            throw new AopConfigException("Advisor index " + index + " is out of bounds:" +
                    "This configuration only has " + this.advisors.size() + " advisors. ");
        }
        //移除advisors中的顾问
        Advisor advisor = this.advisors.remove(index);
        if (advisor instanceof IntroductionAdvisor) {
            IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
            // We need to remove introduction interfaces.
            for (Class ifc : ia.getInterfaces()) {
                removeInterface(ifc);
            }
        }
        //更新advisorArray
        updateAdvisorArray();
        //通知已改变，内部会清除方法调用链缓存信息。
        adviceChanged();
    }

    @Override
    public int indexOf(Advisor advisor) {
        Assert.notNull(advisor, "Advisor must not be null");
        return this.advisors.indexOf(advisor);
    }

    @Override
    public boolean replaceAdvisor(Advisor replaceAdvisor, Advisor targetAdvisor) throws AopConfigException {
        Assert.notNull(replaceAdvisor, "Advisor a must not be null");
        Assert.notNull(targetAdvisor, "Advisor b must not be null");
        int index = indexOf(replaceAdvisor);
        if (index == -1) {
            return false;
        }
        removeAdvisor(index);
        addAdvisor(index, targetAdvisor);
        return true;
    }

    /**
     * 添加通知
     * @param advice
     * @throws AopConfigException
     */
    @Override
    public void addAdvice(Advice advice) throws AopConfigException {
        int pos = this.advisors.size();
        this.addAdvice(pos, advice);
    }

    /**
     * 添加指定位置的通知
     * @param index
     * @param advice
     * @throws AopConfigException
     */
    @Override
    public void addAdvice(int index, Advice advice) throws AopConfigException {
        //此处会将advice通知包装为DefaultPointcutAdvisor类型的Advisor
        addAdvisor(index, new DefaultPointcutAdvisor(advice));
    }

    /**
     * 移除通知
     * @param advice
     * @return
     */
    @Override
    public boolean removeAdvice(Advice advice) {
        int index = indexOf(advice);
        if (index == -1) {
            return false;
        }
        removeAdvisor(index);
        return true;
    }

    /**
     *
     * @param advice
     * @return
     */
    @Override
    public int indexOf(Advice advice) {
        Assert.notNull(advice, "Advice must not be null");

        for (int i = 0; i < this.advisors.size(); i++) {
            Advisor advisor = this.advisors.get(i);
            if (advisor.getAdvice() == advice) {
                return i;
            }
        }
        return -1;
    }

    //是否包含某个通知
    public boolean adviceIncluded(@Nullable Advice advice) {
        if (advice != null) {
            for (Advisor advisor : this.advisors) {
                if (advisor.getAdvice() == advice) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 获取某种类型的通知数量
     * @param adviceClass
     * @return
     */
    public int countAdvicesOfType(Class adviceClass) {
        int count = 0;
        if (adviceClass == null) {
            return count;
        }
        long count1 = this.advisors.stream().filter(e -> adviceClass.isInstance(e.getAdvice())).count();
        count = (int) count1;
        return count;
    }

    /**
     * 基于当前配置，获取给定方法的方法调用链列表（即
     * org.aopalliance.intercept.MethodInterceptor对象列表）
     *
     * @param method
     * @param targetClass
     * @return
     */
    public List getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) {
        MethodCacheKey methodCacheKey = new MethodCacheKey(method);
//        List objects = this.methodCache.get(methodCacheKey);
//        if (objects == null) {
//            objects = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
//                    this, method, targetClass);
//            this.methodCache.put(methodCacheKey, objects);
//        }

        return this.methodCache.computeIfAbsent(methodCacheKey, m -> this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                this, method, targetClass));
    }

    @Override
    public String toProxyConfigString() {
        return this.toString();
    }



    /**
     * 将other中的配置信息复制到当前对象中
     * @param other
     * @param targetSource
     * @param advisors
     */
    protected void copyConfigurationFrom(MyAdvisedSupport other, TargetSource
            targetSource, List advisors) {
        copyFrom(other);
        this.targetSource = targetSource;
        this.advisorChainFactory = other.advisorChainFactory;
        this.interfaces = new ArrayList<>(other.interfaces);
        for (Advisor advisor : advisors) {
            if (advisor instanceof IntroductionAdvisor) {
                validateIntroductionAdvisor((IntroductionAdvisor) advisor);
            }
            Assert.notNull(advisor, "Advisor must not be null");
            this.advisors.add(advisor);
        }
        updateAdvisorArray();
        adviceChanged();
    }

    //构建此AdvisedSupport的仅配置副本，替换TargetSource。

    /**
     * 构建此AdvisedSupport的仅配置副本，替换TargetSource。
     * @return
     */
    MyAdvisedSupport getConfigurationOnlyCopy() {
        MyAdvisedSupport copy = new MyAdvisedSupport();
        copy.copyFrom(this);
        copy.targetSource = EmptyTargetSource.forClass(getTargetClass(),
                getTargetSource().isStatic());
        copy.advisorChainFactory = this.advisorChainFactory;
        copy.interfaces = this.interfaces;
        copy.advisors = this.advisors;
        copy.updateAdvisorArray();
        return copy;
    }





    private static final class MethodCacheKey implements Comparable {
        private final Method method;
        private final int hashCode;

        public MethodCacheKey(Method method) {
            this.method = method;
            this.hashCode = method.hashCode();
        }

        public boolean equals(@Nullable Object other) {
            return this == other || other instanceof MyAdvisedSupport.MethodCacheKey && this.method == ((MyAdvisedSupport.MethodCacheKey) other).method;
        }

        public int hashCode() {
            return this.hashCode;
        }

        public String toString() {
            return this.method.toString();
        }

        public int compareTo(MethodCacheKey other) {
            int result = this.method.getName().compareTo(other.method.getName());
            if (result == 0) {
                result = this.method.toString().compareTo(other.method.toString());
            }

            return result;
        }
    }

}
 
 
上面几个类有几个结论，这里说一下。
 
 
     
  
  1. 配置中添加的Advice对象最终都会被转换为DefaultPointcutAdvisor对象，此时
     DefaultPointcutAdvisor未指定pointcut，大家可以去看一下DefaultPointcutAdvisor中pointcut有个默认值，默认会匹配任意类的任意方法。
    2.  
  
  2. 当配置被冻结的时候，即frozen为true的时，此时配置中的Advisor列表是不允许修改的。
    3.  
  
  3. 上面的 getInterceptorsAndDynamicInterceptionAdvice 方法，通过代理调用目标方法的时候，最后需要通过方法和目标类的类型，从当前配置中会获取匹配的方法拦截器列表，获取方法拦截器列表是由 AdvisorChainFactory 负责的。
     getInterceptorsAndDynamicInterceptionAdvice 会在调用代理的方法时会执行，稍后在执行阶段会详解。
    4.  
  
  4. 目标方法和其关联的方法拦截器列表会被缓存在 methodCache 中，当顾问列表有变化的时候，methodCache 缓存会被清除。
    5.  
 
 
 
配置阶段完成之后，下面进入AopProxy获取阶段。
 此阶段会根据AdvisedSupport中配置信息，判断具体是采用cglib的方式还是采用jdk动态代理的方式获取代理对象，先看一下涉及到的一些类。
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
AopProxy接口
 
 
package org.springframework.aop.framework;

import org.springframework.lang.Nullable;

public interface AopProxy {
    /**
     * 
     * @return 创建一个新的代理对象
     */
    Object getProxy();

    /**
     * 
     * @param classLoader
     * @return 创建一个新的代理对象
     */
    Object getProxy(@Nullable ClassLoader classLoader);
}

 
 
AopProxy的2个实现类，实现了上面定义的2个方法，稍后在代理的创建阶段详细介绍。
 
 
AopProxyFactory接口
 通过名称就可以看出来，是一个工厂，负责创建AopProxy，使用的是简单工厂模式。
 接口中定义了一个方法，会根据Aop的配置信息AdvisedSupport来获取AopProxy对象，主要是判断采用cglib的方式还是采用jdk动态代理的方式。
 
 
package org.springframework.aop.framework;
public interface AopProxyFactory {
    /**
    * 根据aop配置信息获取AopProxy对象
    */
    AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException;
}

 
 
DefaultAopProxyFactory类
 AopProxyFactory接口的默认实现，代码比较简单，我们来细看一下
 
 
/**
 * 默认AopProxyFactory实现，创建CGLIB代理或JDK动态代理。
 * 对于给定的AdvisedSupport实例，以下条件为真，则创建一个CGLIB代理:
 * optimize = true
 * proxyTargetClass = true
 * 未指定代理接口
 代理创建阶段
 到目前为止我们已经根据aop配置信息得到了AopProxy对象了，下面就可以调用AopProxy.getProxy方
 法获取代理对象了。
 AopProxy.createAopProxy方法返回的结果有2种情况
 JdkDynamicAopProxy：以jdk动态代理的方式创建代理
 ObjenesisCglibAopProxy：以cglib的方式创建动态代理
 项目详解这2个类的源码 。
 * 通常，指定proxyTargetClass来强制执行CGLIB代理，或者指定一个或多个接口来使用JDK动态代理。
 */
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    public DefaultAopProxyFactory() {
    }

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        // optimize==false && proxyTargetClass 为false && 配置中有需要代理的接口
        if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            return new JdkDynamicAopProxy(config);
        } else {
            Class targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
            } else {
                /**
                 * 如果被代理的类为接口 或者 被代理的类是jdk动态代理创建代理类，则采用
                 * JdkDynamicAopProxy的方式，否则采用cglib代理的方式
                 */
                return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
            }
        }
    }

    /**
     * 
     * @param config
     * @return 确定所提供的AdvisedSupport是否只指定了SpringProxy接口(或者根本没有指定代理接口)
     */
    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        Class[] ifcs = config.getProxiedInterfaces();
        return ifcs.length == 0 || ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0]);
    }
}

 
 
代理创建阶段
 到目前为止我们已经根据aop配置信息得到了AopProxy对象了，下面就可以调用AopProxy.getProxy方
 法获取代理对象了。
 AopProxy.createAopProxy方法返回的结果有2种情况
 
 
     
  
  • JdkDynamicAopProxy：以jdk动态代理的方式创建代理
    •  
  
  • ObjenesisCglibAopProxy：以cglib的方式创建动态代理
     篇幅较长，下回分解吧，88
    •  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring AOP核心源码、原理详解前篇)

        

            

                
    
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 那个抄袭的大张伟
                        猫小努

                        
    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
    
                    
    • 
                    
  • Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    
                    
    • 
                    
  • 直抒《紫罗兰永恒花园外传》
                        雷姆的黑色童话

                        
    没看过《紫罗兰永恒花园》的我莫名的看完了《紫罗兰永恒花园外传》，又莫名的被故事中的姐妹之情狠狠地感动了的一把。感动何在：困苦中相依为命的姐妹二人被迫分离，用一个人的自由换取另一个人的幸福。之后，虽相隔不知几许依旧心心念念彼此牵挂。这种深深的姐妹情谊就是令我为之动容的所在。贝拉和泰勒分别影片开始，海天之间一个孩童凭栏眺望，手中拿着折旧的信纸。镜头一转，挑灯伏案的薇尔莉特正在打字机前奋笔疾书。这些片段
    
                    
    • 
                    
  • 基于社交网络算法优化的二维最大熵图像分割
                        智能算法研学社（Jack旭）
智能优化算法应用图像分割算法php开发语言
                        
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
    
                    
    • 
                    
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    
                    
    • 
                    
  • 蘩漪：新女性？利己主义者
                        赮_红雨

                        
    蘩漪是曹禺《雷雨》笔下的女性形象。对于她的喜爱，曹禺在之前的访谈中，就已经表达得很清楚了，蘩漪是他所倾心的女子的“代替者”。在这个女性身上有着曹禺最精心的描写，但同时她的身上又存在着一些时代的问题。图片发自App首先，繁漪是追求自由和幸福的新女性形象。她是精神悲剧的核心人物，她对周朴园的反抗，具有典型意义。她是位资产阶级家庭出身的小姐，受过五四新思潮的影响，她任性、傲慢，追求人格独立、个性自由和爱
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                    
  • 四章-32-点要素的聚合
                        彩云飘过

                        
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 398顺境，逆境
                        戴骁勇

                        
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
    
                    
    • 
                    
  • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
    
                    
    • 
                    
  • 想明白这个问题，你才能写下去
                        文自拾

                        
    春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
    
                    
    • 
                    
  • 数组去重
                        好奇的猫猫猫

                        
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • git - Webhook让部署自动化
                        大猪大猪

                        
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
    
                    
    • 
                    
  • 121. 买卖股票的最佳时机
                        薄荷糖的味道_fb40

                        
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
    
                    
    • 
                    
  • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
    
                    
    • 
                    
  • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
                        高省APP珊珊

                        
    这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • 2022-11-17
                        无奇君

                        
    又去了一次社康，这次是急性支气管炎……太难了。半夜就猛咳，天天咳醒，还好他戴海绵耳塞睡吵不到他，要不然对他来说也是种煎熬。一累也会猛咳，希望这次是最后一次吃药，吃完就好。又想把头发剪短了，顺便染个色。可是刚刚去看人家还没开门，不是休息日老板好佛系。理发店是个夫妻店，一年多前刚搬来的时候老板还没对象呢，当时聊天老板就说希望能找个对象一起两个人守着店都比上班强。不久后再去他已经有对象了，而且在店里帮忙
    
                    
    • 
                    
  • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                                
  • [黑洞与暗粒子]没有光的世界
                                    comsci

                                    
         无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算 
 
     但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界.... 
 
     那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的 
 
&nbs
    
                                
    • 
                                
  • jQuery Lazy Load 图片延迟加载
                                    aijuans
jquery
                                    
    基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。 
对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。 
 
 版本： 
 

  jQuery v1.4.4+ 
 

  jQuery Lazy Load v1.7.2 
 
 
 注意事项： 
 
 
 需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
    
                                
    • 
                                
  • 使用Jodd的优点
                                    Kai_Ge
jodd
                                    
    1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。 
2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。 
3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。 
  
使用方法简介
    
                                
    • 
                                
  • jpa Query转hibernate Query
                                    120153216
Hibernate
                                    
    public List<Map> getMapList(String hql,
			Map map) {
		org.hibernate.Query jpaQuery = entityManager.createQuery(hql);
		if (null != map) {
			for (String parameter : map.keySet()) {
				jp
    
                                
    • 
                                
  • Django_Python3添加MySQL/MariaDB支持
                                    2002wmj
mariaDB
                                    
    现状 
首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案 
首先据MySQL文档[3]说，自从MySQL
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗IO最多的SQL
                                    357029540
SQL Server
                                    
    返回做IO数目最多的50条语句以及它们的执行计划。 
select top 50   
 
(total_logical_reads/execution_count) as avg_logical_reads,  
 
(total_logical_writes/execution_count) as avg_logical_writes,  
 
(tot
    
                                
    • 
                                
  • spring UnChecked 异常 官方定义！
                                    7454103
spring
                                    
      如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！ 
 
 
 
 
public static boolean isCheckedException(Throwable ex)
    {
   return !(ex instanceof RuntimeExcep
    
                                
    • 
                                
  • mongoDB 入门指南、示例
                                    adminjun
javamongodb操作
                                    
    一、准备工作 
1、 下载mongoDB 
下载地址：http://www.mongodb.org/downloads 
选择合适你的版本 
相关文档：http://www.mongodb.org/display/DOCS/Tutorial 
2、 安装mongoDB 
A、 不解压模式： 
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
    
                                
    • 
                                
  • CUDA 5 Release Candidate Now Available
                                    aijuans
CUDA
                                    
    The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
    
                                
    • 
                                
  • Essential Studio for WinRT网格控件测评
                                    Axiba
JavaScripthtml5
                                    
    Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。 
 
 
网格控件功能 
1、
    
                                
    • 
                                
  • java 获取windows系统安装的证书或证书链
                                    bewithme
windows
                                    
      
    有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。 
有关证书链的解释可以查看此处 。 
  
public static void main(String[] args) {
		SunMSCAPI providerMSCAPI = new SunMSCAPI();
		S
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(set类型和zset类型)
                                    bijian1013
redis数据库NoSQL
                                    
    4.sets类型 
        Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。 
        sadd：向名称为key的set中添加元
    
                                
    • 
                                
  • 异常捕获何时用Exception，何时用Throwable
                                    bingyingao

                                    
    用Exception的情况 
 try { 
       //可能发生空指针、数组溢出等异常 
        } catch (Exception e) { 
         
    
                                
    • 
                                
  • 【Kafka四】Kakfa伪分布式安装
                                    bit1129
kafka
                                    
    在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤 
  
Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
    
                                
    • 
                                
  • Project Euler
                                    bookjovi
haskell
                                    
    Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。 
    看看problem 1吧： 
 Add all the natural num
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-ArrayDeque
                                    BrokenDreams
Collections
                                    
            表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。 
        这篇要看一下java.util.ArrayDeque。从命名上看
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-装饰模式-Decorator
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.Fi
    
                                
    • 
                                
  • Maven学习(一)
                                    chenyu19891124
Maven私服
                                    
        学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
    
                                
    • 
                                
  • [原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充
                                    comsci
算法工作PHP搜索引擎嵌入式
                                    
    本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点 
 
 节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法) 
 
 需要解决的问题：已知分支
    
                                
    • 
                                
  • Linux中用shell获取昨天、明天或多天前的日期
                                    daizj
linuxshell上几年昨天获取上几个月
                                    
    在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年 
 
 
# 获取昨天 
date -d 'yesterday'  # 或 date -d 'last day' 
# 获取明天 
date -d 'tomorrow'   # 或 date -d 'next day' 
# 获取上个月 
date -d 'last month' 
# 
    
                                
    • 
                                
  • 我所理解的云计算
                                    dongwei_6688
云计算
                                    
          在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说： 
 
        Cloud computing is a phrase used to describe a variety of computing co
    
                                
    • 
                                
  • YII CMenu配置
                                    dcj3sjt126com
yii
                                    
    Adding id and class names to CMenu 
We use the id and htmlOptions to accomplish this. Watch.   
//in your view
$this->widget('zii.widgets.CMenu', array(
	'id'=>'myMenu',
	'items'=>$this-&g
    
                                
    • 
                                
  • 设计模式之静态代理与动态代理
                                    come_for_dream
设计模式
                                    
    静态代理与动态代理 
        代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
    
                                
    • 
                                
  • 【转】理解Javascript 系列
                                    gcc2ge
JavaScript
                                    
    理解Javascript_13_执行模型详解 
 
  摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
    
                                
    • 
                                
  • Subsets II
                                    hcx2013
set
                                    
    Given a collection of integers that might contain duplicates, nums, return all possible subsets. 
Note: 
 
 Elements in a subset must be in non-descending order. 
 The solution set must not conta
    
                                
    • 
                                
  • Spring4.1新特性——Spring缓存框架增强
                                    jinnianshilongnian
spring4
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • shell嵌套expect执行命令
                                    liyonghui160com

                                    
      
  
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧. 
  系统:centos 5.x 
  
1.先安装expect 
yum -y install expect 
  
2.脚本内容: 
cat auto_svn.sh 
  
#!/bin/bash

    
                                
    • 
                                
  • Linux实用命令整理
                                    pda158
linux
                                    
    0. 基本命令   　　linux 基本命令整理   　 
　1. 压缩 解压   　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz   　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a   　 
　2. vim小结   　　2.1 vim替换   　　:m,ns/word_1/word_2/gc  
    
                                
    • 
                                
  • 独立开发人员通向成功的29个小贴士
                                    shoothao
独立开发
                                    
      
 概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。  
   
 
 明白你从事独立开发的原因和目的。 
 保持坚持制定计划的好习惯。 
 万事开头难，第一份订单是关键。 
 培养多元化业务技能。 
 提供卓越的服务和品质。 
 谨小慎微。 
 营销是必备技能。 
 学会组织，有条理的工作才是最有效率的。 
 “独立
    
                                
    • 
                                
  • JAVA中堆栈和内存分配原理
                                    uule
java
                                    
    1、栈、堆  
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
    
                                
    •