stubborn_ugly
stubborn_ugly

Spring AOP源码解读

目录

一、概述

二、SpringAOP运行时增强

三、Spring AOP的常用类

四、Spring AOP源码分析

1.XML 配置

2.ProxyFactoryBean生成AOP代理对象

3.具体的两种代理对象生成源码

1、 JDK动态代理：

2、CGLIB动态代理

五、切点和切面分析

六、参考

一、概述

  1. AOP（Aspect Orient Programming）：面向切面编程；
    用途：用于系统中的横切关注点，比如日志管理，事务管理；
    实现：利用代理模式，通过代理对象对被代理的对象增加功能。所以，关键在于AOP框架自动创建AOP代理对象，代理模式分为静态代理和动态代理；
    框架：
    AspectJ使用静态代理，编译时增强，在编译期生成代理对象；
    SpringAOP使用动态代理，运行时增强，在运行时，动态生成代理对象；
  2. AspectJ框架；
    经过AspectJ的编译器编译后的java字节码，会比java源码多一些代码，即在编译阶段，将定义的Aspect切面织入Java字节码中，运行时就是已经被增强过的类了；支持到方法、字段，构造器级别；
  3. SpringAOP框架；
    区别于AspectJ，Spring AOP使用的是动态代理，不修改字节码，而是运行时在内存中临时创建一个AOP代理对象，AOP对象包含了被代理对象的全部方法，并在特定的切点做了增强处理，回调被代理对象的方法；支持到方法级别；

二、SpringAOP运行时增强

Spring AOP动态代理主要是两种方式，JDK动态代理和CGLIB动态代理。

  • JDK动态代理：通过反射来接收被代理的类，并且被代理的类必须实现接口；
    核心是：java.lang.reflect.InvocationHandler接口 与 java.lang.reflect.Proxy类；
  • CGLIB动态代理：目标类没有实现接口，Spring AOP会选择使用CGLIB在运行时动态的生成某个类的子类，因此，CGLIB是通过继承的方式，用子类实现对目标类的增强，final class不可继承的类，无法使用CGLIB做动态代理。
  • Spring的AOP与IOC：Spring AOP对象由Spring IOC容器自动生成、管理，其依赖关系也由IOC容器负责管理，那么AOP对象可以直接使用容器中的其他Bean实例作为被代理对象，所以此时使用SpringAOP只需要定义切点（pointcut）和 增强（advice）即可。
  • AOP代理的方法通过在目标对象的切入点动态的织入增强处理，完成对目标方法的增强。

三、Spring AOP的常用类

Spring AOP源码解读_第1张图片 ProxyConfig类的继承结构
  • ProxyConfig类：所有Spring AOP生成的代理对象的基类，主要为其AOP代理对象工厂实现类提供配置属性。
public class ProxyConfig implements Serializable {

    private boolean proxyTargetClass = false;
    private boolean optimize = false;
    boolean opaque = false;
    boolean exposeProxy = false;
    private boolean frozen = false;

    public void copyFrom(ProxyConfig other) {
        Assert.notNull(other, "Other ProxyConfig object must not be null");
        this.proxyTargetClass = other.proxyTargetClass;
        this.optimize = other.optimize;
        this.exposeProxy = other.exposeProxy;
        this.frozen = other.frozen;
        this.opaque = other.opaque;
    }
}
  • AdvisedSupport类：ProxyConfig类的子类，封装了AOP中通用的对增强（Advice）和通知器（Advisor）的相关操作，对于所有生成AOP代理对象都通用，而代理对象的生成由子类完成；
  • ProxyCreatorSupport类：AdvisedSupport类的子类，一个AOP对象创建的辅助类，提供不同的AOP代理对象生成的通用方法，而代理对象的生成由其子类完成。
  • 实际创建AOP对象的类：AspectJProxyFactory、ProxyFactory、ProxyFactoryBean；工厂类；ProxyCreatorSupport的子类；
  1. AspectJProxyFactory：创建AspectJ的AOP对象，用于Spring集成AspectJ的作用，此时，就不需要使用AspectJ特定的编译器了。
  2. ProxyFactory：创建编程式的AOP对象；
  3. ProxyFactoryBean：创建声明式的AOP对象，通过配置创建AOP对象；

四、Spring AOP源码分析

以ProxyFactoryBean为例，分析Spring AOP的实现原理。

1.XML 配置





    
    
        com.test.Request
    

    
    
        
    

    
    
        
            logAdvice

2.ProxyFactoryBean生成AOP代理对象

ProxyFactoryBean配置目标对象和切面行为Advice，通过其配置的拦截器名称interceptorNames即通知器Advisor将切面应用到目标对象中。

ProxyFactoryBean的功能：

  1. 初始化通知器链
  2. 获取单例、原型的Aop代理对象

public class ProxyFactoryBean extends ProxyCreatorSupport
        implements FactoryBean, BeanClassLoaderAware, BeanFactoryAware {

    // 标记通知器的为全局通知器
    public static final String GLOBAL_SUFFIX = "*";

    // 通知器链是否已经初始化
    private boolean advisorChainInitialized = false;

    // 如果是单例，缓存单例对象
    private Object singletonInstance;

    // 实际上是：new DefaultAdvisorAdapterRegistry();Advisor适配器注册，将Advice适配成Advisor
    private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();


     // 创建AOPProxy代理对象的入口
    public Object getObject() throws BeansException {
        // 初始化通知器链
        initializeAdvisorChain();

        if (isSingleton()) { // 单例
            return getSingletonInstance();
        }
        else { // 原型
            if (this.targetName == null) {
                logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
                        "Enable prototype proxies by setting the 'targetName' property.");
            }
            return newPrototypeInstance();
        }
    }

    // 初始化通知器链（同步方法）
    private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
        if (this.advisorChainInitialized) {
            // 如果通知器链已经初始化，直接返回
            return;
        }

        if (!ObjectUtils.isEmpty(this.interceptorNames)) { // 如果配置的拦截器名称存在
            // 如果没有bean容器，抛出异常
            if (this.beanFactory == null) {
                throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
                        "- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
            }

            // 全局通知器不能是通知器链中最后一个，除非显示的指定了目标
            if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&
                    this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
                throw new AopConfigException("Target required after globals");
            }

            // 遍历通知器链名称
            for (String name : this.interceptorNames) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Configuring advisor or advice '" + name + "'");
                }
                // 如果通知器是全局的
                if (name.endsWith(GLOBAL_SUFFIX)) {
                    if (!(this.beanFactory instanceof ListableBeanFactory)) {
                        throw new AopConfigException(
                                "Can only use global advisors or interceptors with a ListableBeanFactory");
                    }
                    // 向容器中添加全局通知器
                    addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
                            name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
                }
                // 否则，不是全局的
                else {
                    // 判断 通知器是否为单例
                    Object advice;
                    if (this.singleton || this.beanFactory.isSingleton(name)) { // 单例模式
                        // 添加实际的 Advisor/Advice 到链中
                        advice = this.beanFactory.getBean(name);
                    }
                    else { // 原型模式
                        // 如果是原型的 Advice or Advisor: 创建新的
                        // 避免通知器链初始化时没有必要的对象创建
                        advice = new PrototypePlaceholderAdvisor(name);
                    }
                    // 将Advice or Advisor添加的链中
                    addAdvisorOnChainCreation(advice, name);
                }
            }
        }

        // 设置通知器链初始化标识：已初始化
        this.advisorChainInitialized = true;
    }

    // 将Advice or Advisor添加的链中
    private void addAdvisorOnChainCreation(Object next, String name) {
        // 将提供的Advice、advisor转换为Advisor，以便匹配超类
        Advisor advisor = namedBeanToAdvisor(next);
        if (logger.isTraceEnabled()) {
            logger.trace("Adding advisor with name '" + name + "'");
        }
        // 加入到通知器链中
        addAdvisor(advisor);
    }

    // 将提供的Advice、Advisor转换为Advisor
    private Advisor namedBeanToAdvisor(Object next) {
        try {
            // 包装成Advisor通知器
            return this.advisorAdapterRegistry.wrap(next);
        }
        catch (UnknownAdviceTypeException ex) {
            // 如果提供的不是 Advisor or Advice, 抛出异常
            throw new AopConfigException("Unknown advisor type " + next.getClass() +
                    "; Can only include Advisor or Advice type beans in interceptorNames chain except for last entry," +
                    "which may also be target or TargetSource", ex);
        }
    }

    // 单例对象的 代理对象 构造
    private synchronized Object getSingletonInstance() {
        // singletonInstance 没有缓存单例代理对象，则创建，否则直接返回
        if (this.singletonInstance == null) {
            // 获取要代理的目标源
            this.targetSource = freshTargetSource();
            // 如果ProxyFactoryBean设置了自动探测接口属性（默认为True），且没有配置代理接口，且不是目标类的直接代理（ProxyConfig中默认为false）
            if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
                // 获取要代理对象的目标类
                Class targetClass = getTargetClass();
                if (targetClass == null) {
                    throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
                }
                // 获取目标类的接口
                setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
            }
            //初始化共享的单例对象
            // 设置是否使用ProxyConfig的默认配置：false，默认使用
            super.setFrozen(this.freezeProxy);
            // 创建AopProxy对象
            this.singletonInstance = getProxy(createAopProxy());
        }

        return this.singletonInstance;
    }

    // 原型对象的 代理对象 构造
    private synchronized Object newPrototypeInstance() {
        // In the case of a prototype, we need to give the proxy
        // an independent instance of the configuration.
        // In this case, no proxy will have an instance of this object's configuration,
        // but will have an independent copy.
        if (logger.isTraceEnabled()) {
            logger.trace("Creating copy of prototype ProxyFactoryBean config: " + this);
        }
        // 根据当前的工厂类，创建一个代理生成辅助类
        ProxyCreatorSupport copy = new ProxyCreatorSupport(getAopProxyFactory());
        // 辅助类需要一个新的通知器链和一个新的目标源
        TargetSource targetSource = freshTargetSource();
        // 代理生成辅助类，复制当前代理生成类的配置，新的目标源和通知器链
        copy.copyConfigurationFrom(this, targetSource, freshAdvisorChain());
        if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
            // 辅助类，设置接口
            copy.setInterfaces(
                    ClassUtils.getAllInterfacesForClass(targetSource.getTargetClass(), this.proxyClassLoader));
        }
        // 设置是否冻结默认配置
        copy.setFrozen(this.freezeProxy);

        if (logger.isTraceEnabled()) {
            logger.trace("Using ProxyCreatorSupport copy: " + copy);
        }
        // 通过辅助类创建代理对象，由此可见，每次原型的代理类，都是创建了一个新的copy
        return getProxy(copy.createAopProxy());
    }

}

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry {
    
    // 默认注册三类通知适配器
    public DefaultAdvisorAdapterRegistry() {
        registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
        registerAdvisorAdapter(new AfterReturningAdviceAdapter());
        registerAdvisorAdapter(new ThrowsAdviceAdapter());
    }

    // 将Advice接口类适配为Advisor接口类，即将Advice包装成Advisor
    public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
        // 如果指定的类型已经是通知器，直接返回
        if (adviceObject instanceof Advisor) {
            return (Advisor) adviceObject;
        }
        // 如果指定的类型不是Advice类型，直接抛出异常
        if (!(adviceObject instanceof Advice)) {
            throw new UnknownAdviceTypeException(adviceObject);
        }
        // 获取Advice
        Advice advice = (Advice) adviceObject;
        // 如果Advice是MethodInterceptor类型的
        if (advice instanceof MethodInterceptor) {
            // 直接返回默认的切点通知器
            return new DefaultPointcutAdvisor(advice);
        }
        // 否则使用注册的Advisor适配器对Advice核查（可自定义）
        for (AdvisorAdapter adapter : this.adapters) {
            // 核查是否支持
            if (adapter.supportsAdvice(advice)) {
                return new DefaultPointcutAdvisor(advice);
            }
        }
        // 不支持的通知类型，抛出异常
        throw new UnknownAdviceTypeException(advice);
    }

    protected Object getProxy(AopProxy aopProxy) {
        return aopProxy.getProxy(this.proxyClassLoader);
    }
    
}

 由源码可知，ProxyFactoryBean继承了ProxyCreatorSupport类，所以其本身就是创建AopProxy的工厂bean，其有个属性：AopProxyFactory，默认为DefaultAopProxyFactory；调用createAopProxy方法；

public class ProxyCreatorSupport extends AdvisedSupport {
    
    // AOP proxy 工厂类
    private AopProxyFactory aopProxyFactory;

    //当第一个AOPProxy代理对象被创建时，设置为true  
    private boolean active = false;

    // 默认使用DefaultAopProxyFactory生成代理对象
    public ProxyCreatorSupport() {
        this.aopProxyFactory = new DefaultAopProxyFactory();
    }

    // 通过子类的调用
    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        // 调用DefaultAopProxyFactory生成代理对象
        return getAopProxyFactory().createAopProxy(this);
    }

    // 激活代理配置，向容器注册代理回调监听器，第一次创建AOP代理时调用
    private void activate() {
        this.active = true;
        for (AdvisedSupportListener listener : this.listeners) {
            listener.activated(this);
        }
    }
}

接下来，看下默认工厂的创建方法：

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        // ProxyConfig : optimize=false;
        // AOP显示优化 或 配置了目标类 或 使用了Spring支持的代理接口
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            // 获取AOP配置的目标类
            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.");
            }
            // 如果配置的AOP目标类是接口，或者目标类已经是代理类，使用JDK动态代理
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            // 否则使用CGLIB动态代理
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            // 没有显示优化且没有配置目标类且没有使用代理接口，默认使用JDK动态代理
            return new JdkDynamicAopProxy(config);
        }
    }

    // 确定AdvisedSupport提供的配置，是否只配置了SpringProxy接口或者根本没有实现任何接口
    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        // 获取AOP配置的所有接口
        Class[] ifcs = config.getProxiedInterfaces();
        return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
    }
}

至此，SpringAOP的代理对象生成的流程走完了。

3.具体的两种代理对象生成源码

1、 JDK动态代理：

Spring AOP在invoke方法中，调用配置的通知器链；

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    
    // 代理对象使用的配置
    private final AdvisedSupport advised;

    // 通过 AdvisedSupport 配置构造一个JDK AOP代理对象
    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");
        }
        // 初始化AOP配置
        this.advised = config;
    }

    // 获取AOP代理对象的入口类
    public Object getProxy() {
        return getProxy(ClassUtils.getDefaultClassLoader());
    }

    // 创建AOP代理对象
    public Object getProxy(ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }
        // 获取AOP配置的代理接口
        Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        // 查找代理目标的接口是否定义equals和hashcode方法
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        // 使用JDK动态代理创建AOP对象
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

    // 通过内省去判断代理接口，是否有equals 和 hashCode方法
    private void findDefinedEqualsAndHashCodeMethods(Class[] proxiedInterfaces) {
        for (Class proxiedInterface : proxiedInterfaces) {
            Method[] methods = proxiedInterface.getDeclaredMethods();
            for (Method method : methods) {
                if (AopUtils.isEqualsMethod(method)) {
                    this.equalsDefined = true;
                }
                if (AopUtils.isHashCodeMethod(method)) {
                    this.hashCodeDefined = true;
                }
                if (this.equalsDefined && this.hashCodeDefined) {
                    return;
                }
            }
        }
    }

    // 实现 InvocationHandler，回调的方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;
        // 通知的目标对象源
        TargetSource targetSource = this.advised.targetSource;
        Class targetClass = null;
        Object target = null;

        try {
            // 如果目标对象没有实现equals方法且当前调用equals方法
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // 使用 提供的
                return equals(args[0]);
            }
            // 如果目标对象没有实现hashCode方法且当前调用hashCode方法
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                return hashCode();
            }
            // 如果目标方法只是DecoratingProxy，重定向到代理配置
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            // 如果AOP配置了通知，使用反射机制调用同名方法
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;
            // 如果当前通知暴露了代理，将当前代理变为可用代理
            if (this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            target = targetSource.getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }

            // 获取目标方法的拦截器链
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // 如果没有连接器
            if (chain.isEmpty()) {
                // 使用反射直接调用目标方法
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // 创建方法回调对象
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // 沿着拦截器链，执行通知
                retVal = invocation.proceed();
            }

            // 如果方法有返回值，则将代理对象作为方法返回
            Class returnType = method.getReturnType();
            if (retVal != null && retVal == target &&
                    returnType != Object.class && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                retVal = proxy;
            }
            // 如果返回不为void，返回为空，抛出异常
            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {
                // 释放目标对象
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                // 存储当前代理对象
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
}

调用AopUtils.invokeJoinpointUsingReflection()方法，回调目标类的方法

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

    // 利用反射回调目标方法
    try {
        ReflectionUtils.makeAccessible(method);
        return method.invoke(target, args);
    }
}

2、CGLIB动态代理

class CglibAopProxy implements AopProxy, Serializable {
    
    // 获取代理对象
    public Object getProxy(ClassLoader classLoader) {
        try {
            // 获取要代理的目标类
            Class rootClass = this.advised.getTargetClass();
            // 将目标类做为基类（父类）
            Class proxySuperClass = rootClass;
            if (ClassUtils.isCglibProxyClass(rootClass)) { // 核查目标类是否已经是CGLIB动态代理对象
                // 获取其父类
                proxySuperClass = rootClass.getSuperclass();
                // 获取目标类的接口
                Class[] additionalInterfaces = rootClass.getInterfaces();
                // 将目标类的接口添加到AOP配置的接口中
                for (Class additionalInterface : additionalInterfaces) {
                    this.advised.addInterface(additionalInterface);
                }
            }

            // 验证基类
            validateClassIfNecessary(proxySuperClass, classLoader);

            // 配置CGLIB的Enhancer(CGLIB的主要操作类)
            Enhancer enhancer = createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader &&
                        ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }
            // 配置
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

            Callback[] callbacks = getCallbacks(rootClass);
            Class[] types = new Class[callbacks.length];
            for (int x = 0; x < types.length; x++) {
                types[x] = callbacks[x].getClass();
            }
            // 设置回调过滤器
            enhancer.setCallbackFilter(new ProxyCallbackFilter(
                    this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
            // 设置回调方法的类型
            enhancer.setCallbackTypes(types);

            // 生成字节码流并创建代理对象
            return createProxyClassAndInstance(enhancer, callbacks);
        }
    }

    // 获取目标类的回调通知
    private Callback[] getCallbacks(Class rootClass) throws Exception {
        // 优化参数
        boolean exposeProxy = this.advised.isExposeProxy();
        boolean isFrozen = this.advised.isFrozen();
        boolean isStatic = this.advised.getTargetSource().isStatic();

        // 根据AOP配置创建一个动态通知拦截器，CGLIB创建的动态代理会自动调用  
        // DynamicAdvisedInterceptor类的intercept方法对目标对象进行拦截处理
        Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

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

        Callback targetDispatcher = isStatic ?
                new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp();
        // 创建目标分发器  
        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;
        // 如果目标是静态的，并且通知链被冻结，则使用优化AOP调用，直接对方法使用
        if (isStatic && isFrozen) {
            Method[] methods = rootClass.getMethods();
            Callback[] fixedCallbacks = new Callback[methods.length];
            this.fixedInterceptorMap = new HashMap(methods.length);

            for (int x = 0; x < methods.length; x++) {
                List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);
                fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
                        chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
                this.fixedInterceptorMap.put(methods[x].toString(), x);
            }
            //将固定回调和主要回调拷贝到回调数组中
            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 {
            //如果目标不是静态的，或者通知链不被冻结，则使用AOP主要的通知  
            callbacks = mainCallbacks;
        }
        return callbacks;
    }

}

看下： CglibAopProxy.DynamicAdvisedInterceptor，动态通知拦截器；回调目标类的方法；

private static class DynamicAdvisedInterceptor implements MethodInterceptor {
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        Class targetClass = null;
        Object target = null;
        try {
            if (this.advised.exposeProxy) { // 如果通知暴露了代理
                // 当前代理对象也要被拦截
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }
            // 获取目标对象
            target = getTarget();
            if (target != null) {
                targetClass = target.getClass();
            }
            // 获取通知器链
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
            Object retVal;
            
            if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                // 没有通知，直接调用目标方法
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = methodProxy.invoke(target, argsToUse);
            }
            else {
                // 否则，创建方法执行器来回调方法
                retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
            }
            //获取目标对象对象方法的回调结果，如果有必要则封装为代理
            retVal = processReturnType(proxy, target, method, retVal);
            return retVal;
        }
        finally {
            if (target != null) {
                releaseTarget(target);
            }
            if (setProxyContext) {
                // 存储代理
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
}

五、切点和切面分析

其实，有点分不清Spring 中Advice和Advisor的概念；

接下来分析一下：

5.1 切点和切面

Spring AOP中包含5中增强或者说通知：

  • 方法执行前：org.apringframework.aop.MethodBeforeAdvice
  • 方法返回后： org.springframework.aop.AfterReturningAdvice
  • 异常抛出后：org.springframework.aop.ThrowsAdvice
  • 环绕（方法前后）： org.aopaliance.intercept.MethodInterceptor
  • 引介（不常用） ：org.springframework.aop.IntroductionInterceptor

有选择地织入到目标类某些特定的方法中，就需要使用切点进行目标连接点的定位，描述连接点；

Advice（org.aopalliance.aop.Advice接口）：描述了增强的位置，方法前、后等；

PointCut（org.springframework.aop.Pointcut接口）：描述了具体的哪些类、哪些方法上；Pointcut由ClassFilter和MethodMatcher构成；

public interface Pointcut {
    Pointcut TRUE = TruePointcut.INSTANCE;
    // 类过滤器，定位到特定的类上
    ClassFilter getClassFilter();
    // 方法匹配器，定位到特定的方法上
    MethodMatcher getMethodMatcher();
}

Spring 提供6中切点类型：

  1. 静态方法切点类型（org.springframework.aop.support.StaticMethodMatcherPointcut）：抽象类；默认匹配所有的类；
    子类：NameMatchMethodPointcut（简单字符串匹配方法签名）和 AbstractRegexpMethodPointcut（正则表达式匹配方法签名）；
  2. 动态方法切点类型（org.springframework.aop.support.DynamicMethodMatcherPointcut）：抽象类；
  3. 注解切点类型（org.springframework.aop.support.annotation.AnnotationMatchingPointcut）：JDK5以后，通过注解方式声明切点；
  4. 表达式切点类型（org.springframework.aop.support.ExpressionPointcut）：通过表达式匹配，用于支持AspectJ的表达式；
  5. 流程切点（org.springframework.aop.support.ControlFlowPointcut）：没用过；
  6. 复合切点（org.springframework.aop.support.ComposablePointcut）：没用过；

切面由切点（pointcut）和增强（advice）组成，而advice中包含了增强的横切代码，pointcut包含了连接点的描述信息；

其实Spring中提供的增强MethodBeforeAdvice、AfterReturningAdvice等，也包含了连接点信息，就是一个切面，最终都会被AdvisorRegister转换成Advisor；

所以说，Spring 中的Advisor就是横切面的抽象，包含切点和增强；

Spring中的切面类型：

  1. Advisor：代表一般切面，它仅包含一个Advice，因为Advice包含了横切代码和连接点的信息，所以Advice本身就是一个简单的切面，只不过它代表的横切的连接点是所有目标类的所有方法。
  2. PointcutAdvisor：代表具有切点的切面，它包含Advice和Pointcut两个类，这样就可以通过类、方法名以及方法方位等信息灵活地定义切面的连接点，提供更具适用性的切面。
    其由6种实现类：
  • DefaultPointcutAdvisor：最常用的切面类型，它可以通过任意Pointcut和Advice定义一个切面，唯一不支持的是引介的切面类型，一般可以通过扩展该类实现自定义的切面；
  • NameMatchMethodPointcutAdvisor：通过该类可以定义，按方法名定义切点的切面；
  • RegexpMethodPointcutAdvisor：按正则表达式匹配方法名进行切点定义的切面；
  • StaticMethodMatcherPointcutAdvisor：静态方法匹配器切点定义的切面；
  • AspecJExpressionPointcutAdvisor：Aspecj切点表达式定义切点的切面；
  • AspecJPointcutAdvisor：使用AspecJ语法定义切点的切面；

多个Advisor通过org.springframework.core.Ordered接口，来确定增强的顺序；

5.2 Spring 自动代理机制

之前，是通过ProxyFactoryBean，生成targetClass的代理对象，从容器中获取使用，但是对于众多bean需要代理的情况下，就需要Spring的自动代理机制了。

Spring通过org.springframework.beans.factory.config.BeanPostProcessor自动地完成这项工作。其实现类有3种：

Spring AOP源码解读_第2张图片

  1. BeanNameAutoProxyCreator（基于Bean配置名规则的自动代理创建器）：允许为一组特定配置名的Bean自动创建代理实例的代理创建器；
  2. DefaultAdvisorAutoProxyCreator（基于Advisor匹配机制的自动代理创建器）：对容器中所有的Advisor进行扫描，自动将这些切面应用到匹配的Bean中（即为目标Bean创建代理实例）；
  3. AnnotationAwareAspectjAutoProxyCreator（基于Bean中AspectJ注解标签的自动代理创建器）：为包含AspectJ注解的Bean自动创建代理实例；

 
 

5.3 日常用Spring AOP

两种方式：

1.XML配置：aop标签；

2.注解方式：需要aspectjrt.jar，aspectjweaver.jar提供的AspectJ注解；

 

六、参考

  1. https://www.cnblogs.com/zhangxufeng/p/9160869.html 切点表达式用法

你可能感兴趣的:(个人学习)

  • 个人学习笔记7-6：动手学深度学习pytorch版-李沐 浪子L 深度学习深度学习笔记计算机视觉python人工智能神经网络pytorch
    #人工智能##深度学习##语义分割##计算机视觉##神经网络#计算机视觉13.11全卷积网络全卷积网络（fullyconvolutionalnetwork，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换。引入l转置卷积（transposedconvolution）实现的，输出的类别预测与输入图像在像素级别上具有一一对应关系：通道维的输出即该位置对应像素的类别预测。13.11.1构造模型下
  • 致即将逝去的2020年 斯丹钰
    婚姻生活没有想象中那么完美…有时候特别痛恨小时候受的那些教育为什么要被灌输：结婚就好了结婚根本不是那么一件容易的事情…结婚是一种全新生活方式的开始是每一个人学习的新课程很讨厌传统思想中：女人的价值不就是为了生儿育女的吗！我觉得女人哪怕你不是想走所谓的事业型但是你一定要拥有一技之长无论你身在职场，还是想退隐江湖哪天再回来…至少你能在这个时代和这个社会生存下去那时候再来谈你的精神你要的所有其它的东西不
  • 学习的方法 山河枕入梦
    最好的学习是教别人所得的知识。这样可以掌握估计90％以上，而传统的自己学习，看书，最多吸收30％，且容易遗忘。听老师上课，和人讨论就更高效。如果实在只能一个人学习时，就输出所学知识，学会用自己的话转述出来，想象自己在教一个人。时间的新理解，深度思考的时间，和思考的深度对学习才是最重要的，不能浮在表面。学会提问式学习，列目标，并细致划分大小目标和时间界限。回溯所学知识，利用艾宾浩斯记忆曲线，不过这需
  • 浏览器渲染流程解析 dqqbl
    前言大家可能经常会听到css动画比js动画性能更好这样的论断，或者是“硬件加速”，“层提升”这样的字眼；要了解这些内容就需要对浏览器的渲染流程有个大致的了解，本文就是我个人对这些内容的一个总结梳理需要注意的是：本文仅个人学习总结梳理，如有错漏，望指正本文以谷歌浏览器Blink内核为例，参考内容链接大多需要科学上网随着谷歌浏览器的更新迭代，有些渲染流程或对象名词可能发生变化（如，RenderObje
  • 【Spring Boot 3】【Web】处理跨域资源共享 CORS 又言又语 Springspringspringbootcors跨域
    【SpringBoot3】【Web】处理跨域资源共享CORS背景介绍开发环境开发步骤及源码工程目录结构总结背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的时间精力。因此本文旨在通过一篇文章即能还
  • 【Spring Boot 3】【Web】返回MP4视频流 又言又语 Springspringbootmp4视频流
    【SpringBoot3】【Web】返回MP4视频流背景介绍开发环境开发步骤及源码工程目录结构总结背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的时间精力。因此本文旨在通过一篇文章即能还原出可工
  • 【Spring Boot 3】【Web】配置HTTPS 又言又语 Springspringboothttps
    【SpringBoot3】【Web】配置HTTPS背景介绍开发环境开发步骤及源码工程目录结构背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的时间精力。因此本文旨在通过一篇文章即能还原出可工作的、
  • 开放麒麟操作系统能打动嵌入式软件工程师吗？ 物联网_区块链_边缘计算_人工智能 嵌入式硬件soclinuxqtiot
    国产操作系统大部分客户其实是toB的，内核以外的源码也是不开源的，比如麒麟系、统信UOS等，个人学习、小企业基本不会用。7月5日开放麒麟操作系统v1.0版正式发布，不同点是这个操作系统从内核到桌面系统源代码都是开源的，由不同的组织集体打造出生自带兼容性和统一标准。嵌入式软件工程师最常用的操作系统有RTOS、Linux、安卓。rtos虽然高度碎片化，各种操作系统都有，但是渐渐的大家用的都是两个规模比
  • 大模型--个人学习心得 挚爱清&虚 人工智能
    大模型LLM定义大模型LLM，全称LargeLanguageModel，即大型语言模型LLM是一种基于Transformer架构模型，它通过驯良大量文本数据，学习语言的语法、语义和上下文信息，从而能够对自然语言文本进行建模这种模型在自然语言处理(NLP)领域具有广泛应用常见的13个大模型BERT、GPT系列、T5、Meta的Llama系列、华为盘古模型、阿里巴巴通义大模型、科大讯飞星火大模型、百度
  • 数学建模之插值算法 阿米诺s 数学建模数学建模算法
    注：本文面向应用，参考了清风大大的资料以及司守奎老师的《数学建模算法与应用》，属作者的个人学习总结。一.算法应用背景当已知函数点非常少的时候，我们经常要模拟产生一些新的函数值来支撑后续数据分析。这就是插值算法的应用目的。*插值算法还可以用来实现短期预测，但我们往往使用拟合算法以及时间序列算法来实现预测。二.插值问题的分类插值问题一般分为一维插值问题和多维插值问题。三.插值法(一)数学定义设函数f(
  • Django----Form的来龙去脉（-）使用篇 墨痕_777 python
    Django----Form的来龙去脉（-）使用篇（注：个人学习总结，仅供参考）####Form表单的功能自动生成HTML表单元素检查表单数据的合法性如果验证错误，重新显示表单（数据不会重置）数据类型转换（字符类型的数据转换成相应的Python类型）####Form相关的对象包括Widget：用来渲染成HTML元素的工具，如：forms.Textarea对应HTML中的标签Field：Form对象
  • 【Spring Boot 3】【Web】国际化 又言又语 Springspringbootweb国际化i18n
    【SpringBoot3】【Web】国际化背景介绍开发环境开发步骤及源码工程目录结构总结背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的时间精力。因此本文旨在通过一篇文章即能还原出可工作的、甚至
  • 【Spring Boot 3】自定义拦截器 又言又语 Springspringboot拦截器interceptor
    【SpringBoot3】自定义拦截器背景介绍开发环境开发步骤及源码工程目录结构总结背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的时间精力。因此本文旨在通过一篇文章即能还原出可工作的、甚至可用
  • 时序预测相关论文阅读笔记 能力越小责任越小YA 论文阅读笔记时序预测Transformer
    笔记链接：【有道云笔记】读论文（记录）https://note.youdao.com/s/52ugLbot用于个人学习记录。
  • 家书感悟 快乐老家
    读陈歌老师家书感悟看了陈歌老师的家书真的特别佩服，一年中真的是收获满满，自从学习圣贤文化来，处处都有很大变化，不论是从家庭，工作，还是从个人学习成长，真的是突飞猛进,学习上自己输入那么多课程，又做了那么多的志愿服务服,真的是太棒了，在家庭中很好的感召到先生和孩子，在工作上,达到了时间自由和财富自由，真让我很羡慕啊,同时在新的一年已经有非常明确的工作，学习，家庭目标了，这说明陈歌老师已经非常好的总结
  • Day28：学习王阳明心学有感 白的羊
    王阳明心学有三大主题。第一是“心即理”，主张“吾性自足，不假外求”，即万物的道理都在我的心中，不需要向外求取，只要用心，就可在自己的内在找到。第二是“知行合一”，即在心中知道了道理，但没有去实践，道理就是空的，如果实践了，却没有做好，是“知”不足够。结合第一点，在自己内在找到的道理要运用于实践，从实践当中再学习、再思考，知行互为表里，才能得到“真知”，才能称“善”。第三是“致良知”，认为个人学习最
  • 中原焦点团队吴瑕瑜焦点解决初级第18期坚持分享第267+322天 2021年6月18号 卿安
    中原焦点团队吴瑕瑜焦点解决初级第18期坚持分享第267+322天2021年6月18号为什么我鼓励家长最好能够找伙伴一起学习、成长？首先，知识需要内化，从知道到做到的第一步就是内化，输出是强化内化的一种方式，和伙伴一起学习、成长，可以互相分享，讲给别人听或者写出来一起看，这也是输出的过程，输出的过程也是梳理、整理的过程。第二，可以更加丰富我们的看法和想法。个人学习的理解是有限的，多听听其他人的想法，
  • 2019-01-12 柠檬and橙子
    大家好！我是来自曙光幼儿园的王蒙，今天是我的日精进行动第21天，给大家分享我今天的进步。1.比学习：将自律有条不紊地坚持下去，你就会拥有更好的生活方式。2.比付出:早上接孩子入园，环创，午饭午休，环创，打扫卫生送孩子放学。3.比改变:从现在开始，蜕变成一个自爱自律的人，活得越来越优秀，越来越让你为自己感到骄傲。4.比谦虚:向身边每一个人学习。5.比感恩:感谢身边的每一个人。6.比坚持:坚持每天学习
  • 【Spring Boot 3】【Web】自定义过滤器 又言又语 Springspringboot过滤器Filter
    【SpringBoot3】【Web】自定义过滤器背景介绍开发环境开发步骤及源码工程目录结构总结背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的时间精力。因此本文旨在通过一篇文章即能还原出可工作的
  • 【Spring Boot 3】【Web】同时启用 HTTP 和 HTTPS 又言又语 Springspringboothttphttps
    【SpringBoot3】【Web】同时启用HTTP和HTTPS背景介绍开发环境开发步骤及源码工程目录结构背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的时间精力。因此本文旨在通过一篇文章即能还
  • 5月复盘 Sabrina_fc6f
    说实在的，极不愿意开启这月的复盘之路。因为，每个星期都未记录。但是如果不剖析，不留痕迹，就没法改进，因而，虽然复盘血淋淋，但必须要做！个人学习生活篇从个人学习发展看来，看书和听书太少。一本青少年版的上下五千年中国历史，看了一个多月。5月开启的《瓦尔登湖》，没有每日坚持阅读。第二，零碎时间几乎未利用起来听书。那在校的空余时间几乎读用来打球与练琴，处理学生问题。看书少，输入少，能感觉整个人很浮躁。静下
  • 2018-12-18 静待花开80后
    2018年12月18日晨间日志生命：日行一善：给云南的孩子们购买了44双鞋子已寄走。2.健康：早起：7.10分。晚上00.00入睡.午休：0/次3.运动：1次，在月亮湾每天倒走25分钟。4.一日三餐:吃的有些过饱，不易消化，胃难受。5.冥想：0次。生存：心智锻炼/阅读、写作、学习。1.个人学习：听财富自由之路一课，叶武斌时间管理一节。孩子学习:完成古筝、围棋、阅读打卡。做语文和数学的单元试卷。2工
  • 若依AI(VUE3 个人学习记录--更新中) 涉世尚浅哇 学习javamybatismavenvue.jsnode.jsmysql
    一、环境搭建1.若依Vue前后端代码拉取前端仓库地址：https://gitee.com/ys-gitee/RuoYi-Vue3后端仓库地址：https://gitee.com/y_project/RuoYi-Vue2.后端.yml文件（admin模块下）2.1.修改数据库账号密码以及路径2.2.修改redis密码3.新建数据库ry-vue并导入数据库表数据4.下载前端依赖在导入的RuoYi-Vu
  • 【可视化大屏系列】DataV的使用 元气满满的大咸鱼 可视化大屏系列可视化大屏数据看板DataV
    以下内容为近期个人学习总结，若有错误之处，欢迎指出！可视化大屏开发系列——DataV的使用一、介绍二、注意事项1、技术支持2、兼容性3、状态更新三、实现效果四、使用（在vue2项目中）1.npm安装2.main.js中引入3.开启愉快地玩耍（1）全屏容器（2）边框（3）装饰（4）图表（5）其它图表推荐A.水位图B.轮播表C.胶囊柱图D.排名轮播表E.锥形柱图一、介绍DataV是一款用来做大屏数据展
  • 彭华勇：厌学叛逆不读书，孩子爸爸/妈妈不学习怎么办？ 彭华勇
    不少孩子家长加我微信，透过学习了解，逐步清晰，孩子的问题来源于家庭系统，要想孩子改变，必须家长先学习。这是一个很好的开始，一个很好的思维转变。但是有些家长可能又会有一些犹豫纠结，孩子问题来源于家庭系统，但是只有我一个人学习，孩子他爸又不学习，怎么办，有用吗？有些孩子爸爸愿意学习，但也会有疑惑，我一个人学习，孩子他妈不愿意学习，而且主要是孩子他妈在管教孩子，我学习有用吗？我常常说青春期的教育问题都是
  • 1201每日一省Day16（重启Day9） 吾心1108
    今日继续居家工作、陪豆豆、个人学习，忙忙碌碌的对了一天的数据，最大的感受是方法比努力更重要。只有学习才能不断更新自己的数据库，随时应对不同的状况。豆豆今天又是腻妈妈的一天，围着妈妈求陪伴玩耍，最近爸爸、妈妈都比较忙，顾不上豆豆，每次看着他失落的走开，然后自己跟自己玩，自己给自己讲道理时，妈妈好难受。工作是为了提升自己，提升家人的生活质量。现在豆豆最需要陪伴的时候爸爸妈妈忙，等爸爸妈妈闲暇之时再去干
  • 【深度学习笔记】1 数据操作 RIKI_1 深度学习深度学习笔记人工智能
    注：本文为《动手学深度学习》开源内容，仅为个人学习记录，无抄袭搬运意图数据操作在深度学习中，我们通常会频繁地对数据进行操作。作为动手学深度学习的基础，本节将介绍如何对内存中的数据进行操作。在PyTorch中，torch.Tensor是存储和变换数据的主要工具。如果你之前用过NumPy，你会发现Tensor和NumPy的多维数组非常类似。然而，Tensor提供GPU计算和自动求梯度等更多功能，这些使
  • 【Spring Boot 3】【Camel 4】动态路由 又言又语 SpringApacheCamelspringbootcamel
    【SpringBoot3】【Camel4】动态路由背景介绍开发环境开发步骤及源码工程目录结构总结背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的时间精力。因此本文旨在通过一篇文章即能还原出可工作
  • 【Spring Boot 3】动态注入和移除Bean 又言又语 Springspringboot
    【SpringBoot3】动态注入和移除Bean背景介绍开发环境开发步骤及源码工程目录结构总结动态注入Bean的方法动态移除Bean的方法注意事项背景软件开发是一门实践性科学，对大多数人来说，学习一种新技术不是一开始就去深究其原理，而是先从做出一个可工作的DEMO入手。但在我个人学习和工作经历中，每次学习新技术总是要花费或多或少的时间、检索不止一篇资料才能得出一个可工作的DEMO，这占用了我大量的
  • 【深度学习模型】6_3 语言模型数据集 RIKI_1 深度学习深度学习语言模型人工智能
    注：本文为《动手学深度学习》开源内容，部分标注了个人理解，仅为个人学习记录，无抄袭搬运意图6.3语言模型数据集（周杰伦专辑歌词）本节将介绍如何预处理一个语言模型数据集，并将其转换成字符级循环神经网络所需要的输入格式。为此，我们收集了周杰伦从第一张专辑《Jay》到第十张专辑《跨时代》中的歌词，并在后面几节里应用循环神经网络来训练一个语言模型。当模型训练好后，我们就可以用这个模型来创作歌词。6.3.1
  • redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSourceexpire/delincr/lpush数据库分区redis
    最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷）   1、关于JedisPool.returnSource(Jedis jeids)   这个方法是从red
  • SQL性能优化-持续更新中。。。。。。 atongyeye oraclesql
    1 通过ROWID访问表--索引 你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
  • [JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
         如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？ 那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
  • lvs- real 男人50 LVS
    #!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #.  /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
  • 生成公钥和私钥 oloz DSA安全加密
    package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
  • UIView 中加入的cocos2d，背景透明 374016526 cocos2dglClearColor
    要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
  • mysql常用命令 香水浓 mysql
    连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
  • 我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScriptjquerycsshtml5
    系统层面： 高可用性 所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
  • 利用ant进行远程tomcat部署 aijuans tomcat
    在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
  • 获取复利总收入 baalwolf 获取
           public static void main(String args[]){         int money=200;         int year=1;         double rate=0.1; &
  • eclipse.ini解释 BigBird2012 eclipse
    大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
  • AngularJS实现分页功能 bijian1013 JavaScriptAngularJS分页
            对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。   &nbs
  • [Maven学习笔记三]Maven archetype bit1129 ArcheType
    archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等.   mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式，   mvn archetype   1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
  • 【Java命令三】jps bit1129 Java命令
    jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看   [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
  • ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
    zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点 客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
  • unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学unity教程unity视频unity资料unity
    unity 3d还是cocos2dx哪个适合游戏？ 问：unity 3d还是cocos2dx哪个适合游戏？ 答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
  • 百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java算法面试百度招聘
    import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
  • 获取checkbox复选框的值 chiangfai checkbox
    <title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
  • MySQLdb用户指南 chenchao051 mysqldb
    原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
  • HIVE 窗口及分析函数 daizj hive窗口函数分析函数
    窗口函数应用场景： （1）用于分区排序 （2）动态Group By （3）Top N （4）累计计算 （5）层次查询 一、分析函数 用于等级、百分点、n分片等。 函数             说明 RANK()     &nbs
  • PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHPzip
    PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。 一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
  • 精彩英语贺词 dcj3sjt126com 英语
    I'm always here              我会一直在这里支持你                &nb
  • 基于Java注解的Spring的IoC功能 e200702084 javaspringbeanIOCOffice
                                      
  • java模拟post请求 geeksun java
    一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。 此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
  • Swift语法之 ---- ?和!区别 hongtoushizi ?swift!
    转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html   Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
  • centos7安装jdk1.7 jisonami jdkcentos
    安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量 在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
  • 数据源架构模式之数据映射器 home198979 PHP架构数据映射器datamapper
    前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。   一、概念 数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
  • 在Python中使用MYSQL pda158 mysqlpython
    缘由 　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到 数据库中。 　　了解到 Python在这方面有优势，便选用之。 　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里 记录一下，大家共勉。 　　 python中mysql的调用 　　 百度之后能够通过MySQLdb进行数据库操作。
  • 单例模式 hxl1988_0311 java单例设计模式单件
    package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
  • 27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
    1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。