chyohn
chyohn

Spring4.3.x 容器中bean的创建过程（2）——实例化Bean

概述

在Spring4.3.x 容器中bean的创建过程（1）——走进初始化bean的主要战场一篇中我们找到了初始化bean的主要场所在AbstractAutowireCapableBeanFactory类中的doCreateBean方法中，在这个方法中首先调用createBeanInstance方法创建bean的实例；然后调用populateBean方法设置bean的属性；接着调用initializeBean方法执行Bean后处理器和InitializingBean对象的afterPropertiesSet方法以及init-method方法；最后调用registerDisposableBeanIfNecessary方法注册bean的销毁方法。它的每一步都比较繁琐，所以我把他们分开来探讨，在这一篇我们只讨论第一步bean的实例化过程中会遇到哪些情况，以及如何处理各个情况。

创建对象有两种方式，其一是直接使用构造器创建对象；其二是使用工厂模式间接创建对象，这中方式又分为静态工厂、工厂方法和抽象工厂3类。在spring中，从纯XML配置的角度出发有四种方式，第一种是使用默认构造器，第二种是使用带参构造器，第三种是使用静态工厂，第四种是使用实例工厂。

    
    <bean id="studentServiceDefault" class="com.chyohn.service.StudentService">
        <property name="name" value="默认构造器"/>
    bean>

    
    <bean id="studentServiceArgs" class="com.chyohn.service.StudentService">
        <constructor-arg name="name" value="带参构造器"/>
    bean>

    
    <bean id="studentServiceStaticF" class="com.chyohn.factory.StudentServiceFactory" factory-method="createSudentService" />

    
    <bean id="studentServiceFactoryBean" class="com.chyohn.factory.StudentServiceFactory"/>
    <bean id="studentServiceSimpleF" factory-bean="studentServiceFactoryBean" factory-method="createSudentService">
        <constructor-arg name="name" value="简单工厂"/>
    bean>

Spring中不管是工厂方法还是抽象工厂，只要需要实例化工厂对象的都需要通过第四种配置方式创建bean。下面我们看看Spring如何创建这四种配置方式的bean。

实例化bean

AbstractAutowireCapableBeanFactory类中的doCreateBean方法调用它的createBeanInstance方法实例化bean并返回bean的包装器BeanWrapper对象，源码如下。

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
        // 获取bean的Class对象
        Class beanClass = resolveBeanClass(mbd, beanName);

        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }

        if (mbd.getFactoryMethodName() != null)  {
            // 使用指定的工厂方法创建bean示例
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        // 再一次创建已经创建过的bean
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                return instantiateBean(beanName, mbd);
            }
        }

        // 获取bean的构造器
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
            // 通过带参构造器创建bean对象
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // 通过无参构造器创建bean对象
        return instantiateBean(beanName, mbd);
    }

createBeanInstance方法所做的事情非常清晰，它根据bean的定义选择bean采用何种方式创建，这个方法把bean的创建分成3种方式，其一是通过指定的工厂创建bean，这个包括使用实例工厂或静态工厂；其二是通过带参构造器创建bean；其三是通过无参构造器创建bean。下面我们分别探讨这三种方式。

1. 使用工厂创建bean

createBeanInstance方法调用AbstractAutowireCapableBeanFactory对象的instantiateUsingFactoryMethod方法通过使用工厂方法创建bean实例的入口，源码如下。

    protected BeanWrapper instantiateUsingFactoryMethod(
            String beanName, RootBeanDefinition mbd, Object[] explicitArgs) {

        return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
    }

instantiateUsingFactoryMethod方法首先创建一个ConstructorResolver对象后，调用这个对象的instantiateUsingFactoryMethod方法来实例化bean。instantiateUsingFactoryMethod方法的源码如下。

    public BeanWrapper instantiateUsingFactoryMethod(
            final String beanName, final RootBeanDefinition mbd, final Object[] explicitArgs) {

        BeanWrapperImpl bw = new BeanWrapperImpl();
        // 向BeanWrapper对象中添加ConversionService对象和属性编辑器PropertyEditor对象
        this.beanFactory.initBeanWrapper(bw);

        Object factoryBean;
        Class factoryClass;
        boolean isStatic;

        String factoryBeanName = mbd.getFactoryBeanName();
        if (factoryBeanName != null) {
            if (factoryBeanName.equals(beanName)) {
                throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                        "factory-bean reference points back to the same bean definition");
            }
            // 获取工厂实例
            factoryBean = this.beanFactory.getBean(factoryBeanName);
            if (factoryBean == null) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "factory-bean '" + factoryBeanName + "' (or a BeanPostProcessor involved) returned null");
            }
            if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
                throw new IllegalStateException("About-to-be-created singleton instance implicitly appeared " +
                        "through the creation of the factory bean that its bean definition points to");
            }
            factoryClass = factoryBean.getClass();
            isStatic = false;
        } else {
            // 静态工厂创建bean，必须要提供工厂的全类名
            if (!mbd.hasBeanClass()) {
                throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                        "bean definition declares neither a bean class nor a factory-bean reference");
            }
            factoryBean = null;
            factoryClass = mbd.getBeanClass();
            isStatic = true;
        }

        Method factoryMethodToUse = null;
        ArgumentsHolder argsHolderToUse = null;
        Object[] argsToUse = null;

        // 获取工厂方法的参数
        if (explicitArgs != null) {
            argsToUse = explicitArgs;
        } else {
            Object[] argsToResolve = null;
            synchronized (mbd.constructorArgumentLock) {
                factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
                if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
                    // Found a cached factory method...
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }
            if (argsToResolve != null) {
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
            }
        }

        // 获取工厂方法，和工厂方法所需要的参数
        if (factoryMethodToUse == null || argsToUse == null) {
            // 工厂对象可能是一个被代理的对象，那么需要获取正确的工厂类全名称
            factoryClass = ClassUtils.getUserClass(factoryClass);

            // 获取所有待定的工厂方法
            Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
            List candidateSet = new ArrayList();
            for (Method candidate : rawCandidates) {
                if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                    candidateSet.add(candidate);
                }
            }
            Method[] candidates = candidateSet.toArray(new Method[candidateSet.size()]);
            AutowireUtils.sortFactoryMethods(candidates);

            ConstructorArgumentValues resolvedValues = null;
            boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
            int minTypeDiffWeight = Integer.MAX_VALUE;
            Set ambiguousFactoryMethods = null;

            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            } else {
                ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            }

            LinkedList causes = null;

            for (Method candidate : candidates) {
                Class[] paramTypes = candidate.getParameterTypes();

                if (paramTypes.length >= minNrOfArgs) {
                    ArgumentsHolder argsHolder;

                    if (resolvedValues != null) {
                        try {
                            String[] paramNames = null;
                            ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                            if (pnd != null) {
                                paramNames = pnd.getParameterNames(candidate);
                            }
                            argsHolder = createArgumentArray(
                                    beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
                        } catch (UnsatisfiedDependencyException ex) {
                            if (this.beanFactory.logger.isTraceEnabled()) {
                                this.beanFactory.logger.trace("Ignoring factory method [" + candidate +
                                        "] of bean '" + beanName + "': " + ex);
                            }
                            if (causes == null) {
                                causes = new LinkedList();
                            }
                            causes.add(ex);
                            continue;
                        }
                    } else {
                        // 如果在配置的时候，参数个数必须要与方法的参数个数相同
                        if (paramTypes.length != explicitArgs.length) {
                            continue;
                        }
                        argsHolder = new ArgumentsHolder(explicitArgs);
                    }

                    int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                            argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                    if (typeDiffWeight < minTypeDiffWeight) {
                        // 查找到完全匹配的工厂方法
                        factoryMethodToUse = candidate;
                        argsHolderToUse = argsHolder;
                        argsToUse = argsHolder.arguments;
                        minTypeDiffWeight = typeDiffWeight;
                        ambiguousFactoryMethods = null;
                    } else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
                            !mbd.isLenientConstructorResolution() &&
                            paramTypes.length == factoryMethodToUse.getParameterTypes().length &&
                            !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                        // 查找到多个可匹配的方法
                        if (ambiguousFactoryMethods == null) {
                            ambiguousFactoryMethods = new LinkedHashSet();
                            ambiguousFactoryMethods.add(factoryMethodToUse);
                        }
                        ambiguousFactoryMethods.add(candidate);
                    }
                }
            }

            if (factoryMethodToUse == null) {
                // 没有查找到可执行的工厂方法，抛出异常
                if (causes != null) {
                    UnsatisfiedDependencyException ex = causes.removeLast();
                    for (Exception cause : causes) {
                        this.beanFactory.onSuppressedException(cause);
                    }
                    throw ex;
                }
                List argTypes = new ArrayList(minNrOfArgs);
                if (explicitArgs != null) {
                    for (Object arg : explicitArgs) {
                        argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
                    }
                } else {
                    Set valueHolders = new LinkedHashSet(resolvedValues.getArgumentCount());
                    valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
                    valueHolders.addAll(resolvedValues.getGenericArgumentValues());
                    for (ValueHolder value : valueHolders) {
                        String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
                                (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
                        argTypes.add(argType);
                    }
                }
                String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "No matching factory method found: " +
                        (mbd.getFactoryBeanName() != null ?
                            "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
                        "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
                        "Check that a method with the specified name " +
                        (minNrOfArgs > 0 ? "and arguments " : "") +
                        "exists and that it is " +
                        (isStatic ? "static" : "non-static") + ".");
            } else if (void.class == factoryMethodToUse.getReturnType()) {
                // 查找到的工厂方法的返回类型为void，抛出异常
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Invalid factory method '" + mbd.getFactoryMethodName() +
                        "': needs to have a non-void return type!");
            } else if (ambiguousFactoryMethods != null) {
                // 查找到多个匹配的工厂方法，抛出异常
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Ambiguous factory method matches found in bean '" + beanName + "' " +
                        "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                        ambiguousFactoryMethods);
            }

            if (explicitArgs == null && argsHolderToUse != null) {
                // 没有传入参数且
                argsHolderToUse.storeCache(mbd, factoryMethodToUse);
            }
        }

        try {
            // 实例化bean
            Object beanInstance;

            if (System.getSecurityManager() != null) {
                final Object fb = factoryBean;
                final Method factoryMethod = factoryMethodToUse;
                final Object[] args = argsToUse;
                beanInstance = AccessController.doPrivileged(new PrivilegedAction() {
                    @Override
                    public Object run() {
                        // 通过执行工厂方法来创建bean示例
                        return beanFactory.getInstantiationStrategy().instantiate(
                                mbd, beanName, beanFactory, fb, factoryMethod, args);
                    }
                }, beanFactory.getAccessControlContext());
            } else {
                // 通过执行工厂方法来创建bean示例
                beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
                        mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);
            }

            if (beanInstance == null) {
                return null;
            }
            // 让BeanWraper对象保存bean实例
            bw.setBeanInstance(beanInstance);
            return bw;
        } catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean instantiation via factory method failed", ex);
        }
    } 
  
instantiateUsingFactoryMethod方法首先获取工厂对象，然后获取工厂方法及其参数，最后调用InstantiationStrategy对象的instantiate方法来创建bean实例。Spring bean工厂默认的InstantiationStrategy对象是CglibSubclassingInstantiationStrategy，这个instantiate方法在CglibSubclassingInstantiationStrategy的父类SimpleInstantiationStrategy中有实现，代码如下。
 
  
    @Override
    public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
            Object factoryBean, final Method factoryMethod, Object... args) {

        try {
            // 设置方法的访问权限为可访问
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    @Override
                    public Object run() {
                        ReflectionUtils.makeAccessible(factoryMethod);
                        return null;
                    }
                });
            } else {
                ReflectionUtils.makeAccessible(factoryMethod);
            }

            Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
            try {
                currentlyInvokedFactoryMethod.set(factoryMethod);
                // 执行工厂方法，并返回实例
                return factoryMethod.invoke(factoryBean, args);
            } finally {
                if (priorInvokedFactoryMethod != null) {
                    currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
                } else {
                    currentlyInvokedFactoryMethod.remove();
                }
            }
        } catch (IllegalArgumentException ex) {
            throw new BeanInstantiationException(factoryMethod,
                    "Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
                    "args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
        } catch (IllegalAccessException ex) {
            throw new BeanInstantiationException(factoryMethod,
                    "Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
        } catch (InvocationTargetException ex) {
            String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
            if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
                    ((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) {
                msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
                        "declaring the factory method as static for independence from its containing instance. " + msg;
            }
            throw new BeanInstantiationException(factoryMethod, msg, ex.getTargetException());
        }
    } 
  
instantiate方法最主要的目的，就是通过java反射执行工厂方法并返回创建好的实例。
 
  
2. 使用带参构造器创建bean
 
  
createBeanInstance方法调用AbstractAutowireCapableBeanFactory对象的autowireConstructor方法是使用带参构造器创建bean实例的入口，源码如下。
 
  
    protected BeanWrapper autowireConstructor(
            String beanName, RootBeanDefinition mbd, Constructor[] ctors, Object[] explicitArgs) {

        return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
    }
 
  
autowireConstructor方法首先创建一个ConstructorResolver对象后，调用这个对象的autowireConstructor方法来实例化bean。autowireConstructor方法的源码如下。
 
  
    public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
            Constructor[] chosenCtors, final Object[] explicitArgs) {

        BeanWrapperImpl bw = new BeanWrapperImpl();
        // 向BeanWrapper对象中添加ConversionService对象和属性编辑器PropertyEditor对象
        this.beanFactory.initBeanWrapper(bw);

        Constructor constructorToUse = null;
        ArgumentsHolder argsHolderToUse = null;
        Object[] argsToUse = null;

        if (explicitArgs != null) {
            argsToUse = explicitArgs;
        } else {
            Object[] argsToResolve = null;
            synchronized (mbd.constructorArgumentLock) {
                constructorToUse = (Constructor) mbd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                    // 从缓存中获取构造器和参数
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }
            if (argsToResolve != null) {
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
            }
        }

        if (constructorToUse == null) {
            // 相应的构造器不能从缓存中获取时
            // 获取正确的构造器及其参数
            boolean autowiring = (chosenCtors != null ||
                    mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
            ConstructorArgumentValues resolvedValues = null;

            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            } else {
                ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            }

            Constructor[] candidates = chosenCtors;
            if (candidates == null) {
                Class beanClass = mbd.getBeanClass();
                try {
                    candidates = (mbd.isNonPublicAccessAllowed() ?
                            beanClass.getDeclaredConstructors() : beanClass.getConstructors());
                } catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                            "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
                }
            }
            AutowireUtils.sortConstructors(candidates);
            int minTypeDiffWeight = Integer.MAX_VALUE;
            Set> ambiguousConstructors = null;
            LinkedList causes = null;

            for (Constructor candidate : candidates) {
                Class[] paramTypes = candidate.getParameterTypes();

                if (constructorToUse != null && argsToUse.length > paramTypes.length) {
                    // 找到匹配的构造器，这终止循环
                    break;
                }
                if (paramTypes.length < minNrOfArgs) {
                    // 当前循环的构造器参数个数小于要求的最小参数个数，那么不匹配，继续从匹配下一个
                    continue;
                }

                ArgumentsHolder argsHolder;
                if (resolvedValues != null) {
                    // 没有提供构造器参数时执行此段代码
                    // 这段代码的作用是获取构造器的参数，可能需要自动装配，比如@Autowire、@Value注解的参数
                    try {
                        // 从@ConstructorProperties注解中获取构造器的参数名称列表
                        String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
                        if (paramNames == null) {
                            // 通过ParameterNameDiscoverer对象获取构造器的参数名称列表
                            ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                            if (pnd != null) {
                                paramNames = pnd.getParameterNames(candidate);
                            }
                        }
                        // 获取构造器参数值列表
                        // 在这一步会先把未初始化的参数初始化
                        argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
                                getUserDeclaredConstructor(candidate), autowiring);
                    } catch (UnsatisfiedDependencyException ex) {
                        if (this.beanFactory.logger.isTraceEnabled()) {
                            this.beanFactory.logger.trace(
                                    "Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
                        }
                        if (causes == null) {
                            causes = new LinkedList();
                        }
                        causes.add(ex);
                        continue;
                    }
                } else {
                    // 当前循环的构造器参数个数必须等于提供的参数个数，否则继续查找下一个
                    if (paramTypes.length != explicitArgs.length) {
                        continue;
                    }
                    argsHolder = new ArgumentsHolder(explicitArgs);
                }

                int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                        argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                if (typeDiffWeight < minTypeDiffWeight) {
                    // 完全匹配构造器
                    constructorToUse = candidate;
                    argsHolderToUse = argsHolder;
                    argsToUse = argsHolder.arguments;
                    minTypeDiffWeight = typeDiffWeight;
                    ambiguousConstructors = null;
                } else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
                    // 多个可匹配的构造器
                    if (ambiguousConstructors == null) {
                        ambiguousConstructors = new LinkedHashSet>();
                        ambiguousConstructors.add(constructorToUse);
                    }
                    ambiguousConstructors.add(candidate);
                }
            }

            if (constructorToUse == null) {
                // 没有找到匹配的构造器
                if (causes != null) {
                    UnsatisfiedDependencyException ex = causes.removeLast();
                    for (Exception cause : causes) {
                        this.beanFactory.onSuppressedException(cause);
                    }
                    throw ex;
                }
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Could not resolve matching constructor " +
                        "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
            } else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
                // 查找到多个构造器
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Ambiguous constructor matches found in bean '" + beanName + "' " +
                        "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                        ambiguousConstructors);
            }

            if (explicitArgs == null) {
                // 没有提供构造器参数的情况，保存到缓存中以方便下次构造的时候直接取用
                // 其他情况参数个数和类型变动性大、不确认因素多，没有必要存缓存
                argsHolderToUse.storeCache(mbd, constructorToUse);
            }
        }

        try {
            // 拿到构造器对象和其所需参数后
            // 实例化bean
            Object beanInstance;

            if (System.getSecurityManager() != null) {
                final Constructor ctorToUse = constructorToUse;
                final Object[] argumentsToUse = argsToUse;
                beanInstance = AccessController.doPrivileged(new PrivilegedAction() {
                    @Override
                    public Object run() {
                        // 通过构造器实例化bean
                        return beanFactory.getInstantiationStrategy().instantiate(
                                mbd, beanName, beanFactory, ctorToUse, argumentsToUse);
                    }
                }, beanFactory.getAccessControlContext());
            } else {
                // 通过构造器实例化bean
                beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
                        mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
            }

            // 让BeanWraper对象保存bean实例
            bw.setBeanInstance(beanInstance);
            return bw;
        } catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean instantiation via constructor failed", ex);
        }
    } 
  
autowireConstructor方法首先获取构造器的参数列表对象和构造器对象，最后执行初始化策略器InstantiationStrategy对象的instantiate方法，这个方法的实现在SimpleInstantiationStrategy类中，源码如下。
 
  
    @Override
    public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
            final Constructor ctor, Object... args) {

        if (bd.getMethodOverrides().isEmpty()) {
            // 没有配置lookup-method或者replaced-method标签或者@Lookup注解
            if (System.getSecurityManager() != null) {
                // use own privileged to change accessibility (when security is on)
                AccessController.doPrivileged(new PrivilegedAction() {
                    @Override
                    public Object run() {
                        ReflectionUtils.makeAccessible(ctor);
                        return null;
                    }
                });
            }
            // 通过BeanUtils直接使用构造器对象实例化bean
            return BeanUtils.instantiateClass(ctor, args);
        } else {
            // 生成CGLIB创建的子类对象
            return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
        }
    } 
  
如果bean的配置没有lookup-method或者replaced-method标签或者@Lookup注解，则直接使用构造器创建bean，否则调用SimpleInstantiationStrategy类或者其子类的instantiateWithMethodInjection方法。这个方法在SimpleInstantiationStrategy类的实现如下。
 
  
    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner,
            Constructor ctor, Object... args) {

        throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
    }
 
  
下面是CglibSubclassingInstantiationStrategy类实现的instantiateWithMethodInjection方法的源码。
 
  
    @Override
    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner,
            Constructor ctor, Object... args) {

        // 通过CGLIB生成一个子类对象
        return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
    }
 
  
CglibSubclassCreator类是CglibSubclassingInstantiationStrategy的私有静态类，下面是它的instantiate方法源码。
 
  
        public Object instantiate(Constructor ctor, Object... args) {
            // 通过Cglib创建一个代理类
            Class subclass = createEnhancedSubclass(this.beanDefinition);
            Object instance;
            if (ctor == null) {
                // 没有提供构造器对象，通过BeanUtils工具类使用默认构造器创建一个bean实例
                instance = BeanUtils.instantiateClass(subclass);
            } else {
                try {
                    // 获取代理类对应的构造器对象，并实例化bean
                    Constructor enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
                    instance = enhancedSubclassConstructor.newInstance(args);
                } catch (Exception ex) {
                    throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
                            "Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
                }
            }
            // 为了避免memory leaks异常，直接在bean实例上设置回调对象
            Factory factory = (Factory) instance;
            factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
                    new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
                    new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
            return instance;
        }
 
  
CglibSubclassCreator类对象通过调用它的createEnhancedSubclass方法来创建一个Cglib代理的子类，源码如下。
 
  
        private Class createEnhancedSubclass(RootBeanDefinition beanDefinition) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(beanDefinition.getBeanClass());
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            if (this.owner instanceof ConfigurableBeanFactory) {
                ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
                enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
            }
            enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
            enhancer.setCallbackTypes(CALLBACK_TYPES);
            return enhancer.createClass();
        }
 
  
3. 使用无参构造器创建bean
 
  
createBeanInstance方法调用AbstractAutowireCapableBeanFactory对象的instantiateBean方法是使用无参构造器创建bean实例的入口，源码如下。
 
  
    protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
        try {
            Object beanInstance;
            final BeanFactory parent = this;
            if (System.getSecurityManager() != null) {
                beanInstance = AccessController.doPrivileged(new PrivilegedAction() {
                    @Override
                    public Object run() {
                        return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                    }
                }, getAccessControlContext());
            } else {
                beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
            }
            // 创建BeanWrapper对象
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            // 初始化BeanWrapper,向BeanWrapper对象中添加ConversionService对象和属性编辑器PropertyEditor对象
            initBeanWrapper(bw);
            return bw;
        } catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
        }
    } 
  
instantiateBean方法通过调用InstantiationStrategy对象的instantiateBean方法创建bean实例，这个instantiateBean方法在SimpleInstantiationStrategy类中的实现代码如下。
 
  
    @Override
    public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
        // Don't override the class with CGLIB if no overrides.
        if (bd.getMethodOverrides().isEmpty()) {
            // 没有配置lookup-method或者replaced-method标签或者@Lookup注解
            Constructor constructorToUse;
            synchronized (bd.constructorArgumentLock) {
                constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                    final Class clazz = bd.getBeanClass();
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }
                    try {
                        // 获取默认构造器对象
                        if (System.getSecurityManager() != null) {
                            constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction>() {
                                @Override
                                public Constructor run() throws Exception {
                                    return clazz.getDeclaredConstructor((Class[]) null);
                                }
                            });
                        } else {
                            constructorToUse =  clazz.getDeclaredConstructor((Class[]) null);
                        }
                        // 缓存默认构造器对象
                        bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                    } catch (Throwable ex) {
                        throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                    }
                }
            }
            return BeanUtils.instantiateClass(constructorToUse);
        } else {
            // 生成CGLIB创建的子类对象
            return instantiateWithMethodInjection(bd, beanName, owner);
        }
    }
 
  
关于生成CGLIB创建的子类对象调用调用的方法和使用带参构造器实例化bean一节的一样，这里就不重复说了。
 
  
总结
 
  
（1）Spring通过实例化策略接口InstantiationStrategy的派生类创建bean，这个接口的源码如下。
 
  
public interface InstantiationStrategy {

    /**
     * 使用默认构造器创建bean实例
     * @param bd bean定义信息
     * @param beanName bean名称，可以为空
     * @param owner bean工厂
     * @return
     * @throws BeansException
     */
    Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner)
            throws BeansException;

    /**
     * 通过指定的构造器创建bean实例
     * @param bd bean定义信息
     * @param beanName bean名称，可以为空
     * @param owner bean工厂
     * @param ctor 构造器对象
     * @param args 构造器所需参数
     * @return 
     * @throws BeansException
     */
    Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
            Constructor ctor, Object... args) throws BeansException;

    /**
     * 根据指定的工厂方法创建bean实例
     * @param bd bean的定义信息
     * @param beanName bean名称，可以为空
     * @param owner bean工厂
     * @param factoryBean 工厂对象，如果为静态工厂，此参数为null
     * @param factoryMethod 工厂方法对象
     * @param args 工厂方法所需参数
     * @return 
     * @throws BeansException 
     */
    Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
            Object factoryBean, Method factoryMethod, Object... args) throws BeansException;

}
 
  
Spring默认的实例bean策略类为CglibSubclassingInstantiationStrategy。
 
  
（2）使用了lookup-method或者replaced-method标签或者@Lookup注解的bean，Spring使用Cglib的Enhancer类创建它们的代理子类。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring4源码解读)

        

            

                
    
                    
  • K8S源码及定制化系列-源码解读第一步Kubectl(三)
                        申专
Golang云原生kubernetes容器云原生
                        
    本节重点介绍:kubectl的职责和kubectl的代码原理cobra库的使用简介kubectl的职责主要的工作是处理用户提交的东西（包括，命令行参数，yaml文件等）然后其会把用户提交的这些东西组织成一个数据结构体然后把其发送给APIServerKubectl系统架构图kubectl的代码原理从命令行和yaml文件中获取信息通过Builder模式并把其转成一系列的资源最后用Visitor模式模式
    
                    
    • 
                    
  • Spring Cache sync属性
                        你这个代码我看不懂
Springspringjava后端
                        
    在SpringCache中，@Cacheable注解用于标记一个方法，使其返回值可以被缓存。sync属性是Spring4.3引入的一个新特性，用于控制缓存的同步行为。sync属性sync属性的默认值是false，表示异步缓存。如果将sync设置为true，则表示同步缓存。异步缓存（sync=false）当sync属性为false时，如果多个线程同时请求同一个缓存键，并且该键在缓存中不存在，所有线程
    
                    
    • 
                    
  • SpringBoot自动装配中的Condition机制
                        hai40587
springbootjava后端
                        
    SpringBoot自动装配中的Condition机制在SpringBoot中，自动装配（Auto-Configuration）是一个核心特性，它极大地简化了Spring应用的配置过程。自动装配通过条件判断（Condition）机制，根据应用的环境和依赖来决定是否创建和配置Bean。这一机制在Spring4.0中引入，主要通过@Conditional注解及其一系列变体实现。本文将详细探讨Sprin
    
                    
    • 
                    
  • netty源码解读三（NioEventLoop）
                        orcharddd_real
nettyjavanetty
                        
    NioEventLoop初始化EventExecutor类型的数组数组大小默认为cpu数量的两倍，遍历数组，通过newNioEventLoop(xxx)往数组中添加元素，NioEventLoop继承了EventExecutor；每次需要线程时，执行chooser的next方法从数组中取出一个线程；关键代码打开netty源码，找到example包下的EchoService类，追溯创建boss线程组和
    
                    
    • 
                    
  • 三、RestController注解
                        hungteshun
springbootspringboot
                        
    一、了解即可@RestController注解，代表返回的是json格式的数据，这个注解是Spring4之后新加的注解，原来返回json格式的数据需要@ResponseBody配合@Controller一起使用；如果我们在项目中使用的是@Conrtroller注解的话，不加@Response注解，则当直接返回一个字符串的时候，就好比返回的是一个模板页面，类似我们返回一个jsp页面一样。所以我们需要
    
                    
    • 
                    
  • 在windows服务器上部署spring boot项目
                        Joinyo
springbootjava
                        
    前言写下这篇文章是为了记录第一次发布SpringBoot项目的过程。初步认识SpringBootSpringBoot是由Pivotal团队在2013年开始研发、2014年4月发布第一个版本的全新开源的轻量级框架。它基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。SpringBoot所具备的特征（1）可以创建
    
                    
    • 
                    
  • Java源码解读-数据容器都是如何实现同步的
                        问道飞鱼
Java开发Java源码解读数据容器同步机制
                        
    用Java的同学可能在自己使用或者面试的时候经常遇到这么一个问题，哪些数据结构或者容器是同步的，是怎么实现的同步？其实很多的数据同步原理都比较简单，我把目前知道的数据容器的同步方式稍微梳理了一下1.线程安全容器StringBuffer(太明显，synchronized关键字）@OverridepublicsynchronizedStringBufferappend(Stringstr){toStr
    
                    
    • 
                    
  • Java编程开发新手学习：数组方法的应用猜字母游戏
                        Java小辰

                        
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。给你学习路线：html-css-js-jq-javase-数据库-jsp-servlet-Struts2-hibernate-mybatis-spring4-springmv
    
                    
    • 
                    
  • Vue 源码解读（10）—— 编译器 之 生成渲染函数
                        xuhss_com
计算机udplinuxc语言计算机
                        
    Python微信订餐小程序课程视频https://edu.csdn.net/course/detail/36074Python实战量化交易理财系统https://edu.csdn.net/course/detail/35475前言这篇文章是Vue编译器的最后一部分，前两部分分别是：Vue源码解读（8）——编译器之解析、Vue源码解读（9）——编译器之优化。从HTML模版字符串开始，解析所有标签以及
    
                    
    • 
                    
  • Spring 源码解读：实现单例与原型的Bean作用域
                        捕风捉你
spring源码解读springjava后端
                        
    引言在Spring框架中，Bean的作用域（Scope）定义了Bean的生命周期和访问范围。Spring提供了多种作用域，包括常用的单例（Singleton）和原型（Prototype）。了解并正确使用这些作用域对于管理应用的资源和性能至关重要。本篇文章将通过手动实现单例和原型作用域的Bean管理机制，并对比Spring中的@Scope注解，帮助你理解不同Bean作用域的使用场景和实现细节。Bea
    
                    
    • 
                    
  • MyBatis 源码解读：专栏导读与学习路线
                        捕风捉你
MyBatis源码解读mybatis学习java
                        
    前言MyBatis是Java开发中广泛使用的持久层框架，其简洁的配置和强大的功能使得它在开发人员中备受欢迎。然而，MyBatis的背后隐藏着许多设计巧妙的架构和复杂的实现逻辑。通过源码解读，我们可以更深入地理解MyBatis的设计思想和工作原理，从而更好地应用它。本专栏将以源码分析为主线，结合实际应用场景，带你一步步深入了解MyBatis的内部实现。无论你是MyBatis的新手还是有经验的开发者，
    
                    
    • 
                    
  • PostgreSQL 源码解读（89）- 查询语句#74（SeqNext函数#2）
                        EthanHe

                        
    本节是SeqNext函数介绍的第二部分，主要介绍了SeqNext->heap_getnext函数的实现逻辑。一、数据结构TupleTableSlotTupleTableSlot,用于存储元组相关信息/*basetupletableslottype*/typedefstructTupleTableSlot{NodeTagtype;//Node标记#defineFIELDNO_TUPLETABLESL
    
                    
    • 
                    
  • Java 通过反射获取实体类对应的注释
                        guicai_guojia
java开发语言
                        
    一、使用@ApiModelProperty获取注释信息需要引入swagger依赖①先引入swagger依赖com.spring4allswagger-spring-boot-starter1.9.1.RELEASE②准备实体类注意(swagger依赖没有加载无法使用@ApiModelProperty注解)@DatapublicclassOrderCsvimplementsSerializable{
    
                    
    • 
                    
  • Spring 源码解读专栏：从零到一深度掌握 Spring 框架
                        捕风捉你
spring源码解读springjava后端
                        
    前言Spring是Java世界中无可争议的王者框架，它以其灵活、轻量、强大而著称，成为企业级开发的首选工具。然而，很多开发者在使用Spring时，往往只停留在会用的层面，对于其内部实现和设计原理知之甚少。本专栏旨在通过系统化的Spring源码解读，从实践到源码分析，再到设计模式的探讨，带你逐步揭开Spring的神秘面纱，真正掌握这款框架的精髓。专栏目标在这个专栏中，我们将通过以下几个步骤，帮助你深
    
                    
    • 
                    
  • Spring的三种注入方式的优缺点分析
                        爱敲代码的罗根
JavaEEspringjava后端java-eespringbootintellij-ideaeclipse
                        
    在Spring中，提供了三种依赖注入（也被称之为"对象注入"，"属性装配"等）的方式，这篇博客我们来分析一下这三种方式各有哪些优缺点。一、属性注入优点简洁，使用方便。缺点▪只能用于IoC容器，如果是非IoC容器不可用，并且只有在使用的时候才会出现NPE（空指针异常）；▪不能注入⼀个Final修饰的属性。二、构造函数注入此方式推荐Spring4.X进行使用优点▪可以注入final修饰的属性；▪注入的
    
                    
    • 
                    
  • springboot中get post put delete 请求区别详解
                        developerFBI
JAVASpringbootjava
                        
    Spring4.3中引进了｛@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PatchMapping｝来帮助简化常用的HTTP方法的映射并更好地表达被注解方法的语义。1.@GetMapping：处理get请求，传统的RequestMapping来编写应该是@RequestMapping(value=“/get/{id}”,method=Re
    
                    
    • 
                    
  • 【深度学习】COCO API源码解读
                        CS_Zero
深度学习人工智能
                        
    COCOAPI从C、cython，到PythonAPI：实现语义分割标注mask的解析，从具体实现cocoapi/common/maskApi.hcocoapi/common/maskApi.c到Cython封装实现pycocotools._maskcocoapi/PythonAPI/pycocotools/_mask.pyx#distutils:language=c#distutils:sour
    
                    
    • 
                    
  • Spring4+Hibernate4+Mybatis Maven的pom配置
                        wanhf11
Maven
                        
    4.0.0org.digdataswustoj30.0.1-SNAPSHOTwarswustoj3UTF-84.0.4.RELEASE1.7.41.7.134.3.8.Final3.3javaxjavaee-api7.0providedorg.glassfish.webjavax.servlet.jsp.jstl1.2.2providedjavax.servletservlet-api2.5pro
    
                    
    • 
                    
  • springMVC 使用统一异常注解拦截@ExceptionHandle遇到的问题解决
                        mobile18600007978
springspringExceptionHandle异常
                        
    项目使用spring框架（spring4.3版本），MVC模式，接口是restful方式，通过json格式进行数据交互，controller层通过注解@ResponseBody返回json数据；在架构设计中的异常处理是service层及更底层有问题就向上抛异常，Controller层捕获所有异常，为了省去每个方法处理逻辑时try…catch的冗余及代码的复杂性，通过使用springMvc注解@Ex
    
                    
    • 
                    
  • Spring AOP 笔记
                        里昂_79ce

                        
    精通Spring4.x企业级应用》学习笔记Aop适合具有横切逻辑的应用场合：性能监测、访问控制、事务管理、日志记录；Aop通过横向抽取机制为这类无法通过纵向继承体系进行抽象的重复性代码提供了解决方案。Aop术语：1.Joinpoint连接点:程序执行的某个特定位置，两个信息确定连接点：程序执行点和相对位置，spring使用切点对执行点进行定位，而方位则在增强类型中定义。2.Poincut切点:连接
    
                    
    • 
                    
  • 深入浅出 spring-data-elasticsearch 之 ElasticSearch 架构初探（一）
                        Julian Wong
springelasticsearch架构java后端
                        
    本文目录一、Elasticsearch基本术语1.1文档(Document)、索引(Index)、类型(Type)文档三要素1.2集群(Cluster)、节点(Node)、分片(Shard)分布式三要素二、Elasticsearch工作原理2.1文档存储的路由2.2如何健康检查2.3如何水平扩容三、小结欢迎来SpringForAll,和我探讨Spring相关的分享。http://spring4al
    
                    
    • 
                    
  • javaweb、spring、springmvc和springboot是什么及其之间的区别与联系
                        java抽象带篮子
Springspringspringbootjava
                        
    文章目录具体介绍1.JavaWeb2.Spring3.SpringMVC1.Spring和SpringMVC的区别？2.SpringBoot和springMVC的区别？4.SpringBoot5.SpringCloud总结具体介绍Spring是一个“引擎”；SpringMVC是基于Spring的一个MVC框架；SpringBoot是基于Spring4的条件注册的一套快速开发整合包；SpringCl
    
                    
    • 
                    
  • java 进销存 销售报表 库存管理 商户管理 springmvc SSM crm 项目
                        非得起个昵称

                        
    系统介绍：1.系统采用主流的SSM框架jspJSTLbootstraphtml5(PC浏览器使用)2.springmvc+spring4.3.7+mybaits3.3SSM普通javaweb（非maven,附赠pom.xml文件）数据库：mysql3.开发工具：myeclipseeclipseidea均可,没有限制.我这边myeclipse2014导出来的项目源码-----------------
    
                    
    • 
                    
  • opencv源码---imread、cvLoadImage、waitKey、imshow函数源码解读
                        hairuiJY
Opencv学习计算机视觉opencv计算机视觉图像处理
                        
    参考：https://blog.csdn.net/hujingshuang/article/details/47184717https://blog.csdn.net/kuweicai/article/details/73395018
    
                    
    • 
                    
  • SpringBoot源码解读与原理分析(五)SpringBoot的装配机制
                        灰色孤星A
springbootjava后端spring开发语言
                        
    文章目录2.5SpringBoot的装配机制[email protected]@ComponentScan的基本使用方法2.5.1.2TypeExcludeFilter(类型排除过滤器)2.5.1.3AutoConfigurationExcludeFilter(自动配置类排除过滤器)[email protected]@EnableAutoConf
    
                    
    • 
                    
  • Spring MVC(基于 Spring4.x)基础学习
                        程序员的人生K
Springspringmvc学习
                        
    一、SpringMVC概述二、SpringMVC的HelloWorld三、使用@RequestMapping映射请求四、映射请求参数&请求头五、处理模型数据六、视图和视图解析器七、RESTfulCRUD八、SpringMVC表单标签&处理静态资源九、数据转换&数据格式化&数据校验十、处理JSON:使用HttpMessageConverter十一、国际化十二、文件的上传十三、使用拦截器十四、异常处理
    
                    
    • 
                    
  • Flink 细粒度滑动窗口性能优化
                        hyunbar
Flink大数据flinkjava数据库
                        
    大数据技术AIFlink/Spark/Hadoop/数仓，数据分析、面试，源码解读等干货学习资料118篇原创内容公众号1、概述1.1细粒度滑动的影响当使用细粒度的滑动窗口（窗口长度远远大于滑动步长）时，重叠的窗口过多，一个数据会属于多个窗口，性能会急剧下降。以1分钟的频率实时计算App内各个子模块近24小时的PV和UV。我们需要用粒度为1440/1=1440的滑动窗口来实现它，但是细粒度的滑动窗口
    
                    
    • 
                    
  • Transformer实战-系列教程19：DETR 源码解读6（编码器：TransformerEncoder类/TransformerEncoderLayer类）
                        机器学习杨卓越
Transformer实战transformer深度学习pytorchDETR人工智能计算机视觉
                        
    Transformer实战-系列教程总目录有任何问题欢迎在下面留言本篇文章的代码运行界面均在Pycharm中进行本篇文章配套的代码资源已经上传点我下载源码DETR算法解读DETR源码解读1（项目配置/CocoDetection类/ConvertCocoPolysToMask类）DETR源码解读2（DETR类）DETR源码解读3（位置编码：Joiner类/PositionEmbeddingSine类
    
                    
    • 
                    
  • Transformer实战-系列教程20：DETR 源码解读7（解码器：TransformerDecoder类/TransformerDecoderLayer类）
                        机器学习杨卓越
Transformer实战transformer深度学习计算机视觉DETR人工智能物体检测
                        
    Transformer实战-系列教程总目录有任何问题欢迎在下面留言本篇文章的代码运行界面均在Pycharm中进行本篇文章配套的代码资源已经上传点我下载源码DETR算法解读DETR源码解读1（项目配置/CocoDetection类/ConvertCocoPolysToMask类）DETR源码解读2（DETR类）DETR源码解读3（位置编码：Joiner类/PositionEmbeddingSine类
    
                    
    • 
                    
  • Transformer实战-系列教程18：DETR 源码解读5（Transformer类）
                        机器学习杨卓越
Transformer实战transformer深度学习人工智能pytorchDETR物体检测
                        
    Transformer实战-系列教程总目录有任何问题欢迎在下面留言本篇文章的代码运行界面均在Pycharm中进行本篇文章配套的代码资源已经上传点我下载源码DETR算法解读DETR源码解读1（项目配置/CocoDetection类/ConvertCocoPolysToMask类）DETR源码解读2（DETR类）DETR源码解读3（位置编码：Joiner类/PositionEmbeddingSine类
    
                    
    • 
                                
  • springmvc 下 freemarker页面枚举的遍历输出
                                    杨白白
enumfreemarker
                                    
    spring mvc freemarker 中遍历枚举 
 
1枚举类型有一个本地方法叫values（），这个方法可以直接返回枚举数组。所以可以利用这个遍历。 
 

enum

public enum BooleanEnum {  
    TRUE(Boolean.TRUE, "是"), FALSE(Boolean.FALSE, "否");  

    
                                
    • 
                                
  • 实习简要总结
                                    byalias
工作
                                    
    来白虹不知不觉中已经一个多月了，因为项目还在需求分析及项目架构阶段，自己在这段 
时间都是在学习相关技术知识，现在对这段时间的工作及学习情况做一个总结： 
 
（1）工作技能方面 
大体分为两个阶段，Java Web 基础阶段和Java EE阶段 
 
1）Java Web阶段 
在这个阶段，自己主要着重学习了 JSP, Servlet, JDBC, MySQL，这些知识的核心点都过 
了一遍，也
    
                                
    • 
                                
  • Quartz——DateIntervalTrigger触发器
                                    eksliang
quartz
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2208559 一.概述 
simpleTrigger 内部实现机制是通过计算间隔时间来计算下次的执行时间，这就导致他有不适合调度的定时任务。例如我们想每天的 1：00AM 执行任务，如果使用 SimpleTrigger，间隔时间就是一天。注意这里就会有一个问题，即当有 misfired 的任务并且恢复执行时，该执行时间
    
                                
    • 
                                
  • Unix快捷键
                                    18289753290
unixUnix；快捷键;
                                    
    复制，删除，粘贴： 
dd:删除光标所在的行                             &nbs
    
                                
    • 
                                
  • 获取Android设备屏幕的相关参数
                                    酷的飞上天空
android
                                    
    包含屏幕的分辨率  以及 屏幕宽度的最大dp 高度最大dp   
  
        TextView text = (TextView)findViewById(R.id.text);
        DisplayMetrics dm = new DisplayMetrics();
        text.append("getResources().ge
    
                                
    • 
                                
  • 要做物联网？先保护好你的数据
                                    蓝儿唯美
数据
                                    
    根据Beecham Research的说法，那些在行业中希望利用物联网的关键领域需要提供更好的安全性。 
在Beecham的物联网安全威胁图谱上，展示了那些可能产生内外部攻击并且需要通过快速发展的物联网行业加以解决的关键领域。 
Beecham Research的技术主管Jon Howes说：“之所以我们目前还没有看到与物联网相关的严重安全事件，是因为目前还没有在大型客户和企业应用中进行部署，也就
    
                                
    • 
                                
  • Java取模（求余）运算
                                    随便小屋
java
                                    
            整数之间的取模求余运算很好求，但几乎没有遇到过对负数进行取模求余，直接看下面代码： 
/**
 * 
 * @author Logic
 *
 */
public class Test {

	public static void main(String[] args) {
		// TODO A
    
                                
    • 
                                
  • SQL注入介绍
                                    aijuans
sql注入
                                    
    二、SQL注入范例 
  
 这里我们根据用户登录页面 
  <form action="" > 用户名：<input type="text" name="username"><br/> 密 码：<input type="password" name="passwor
    
                                
    • 
                                
  • 优雅代码风格
                                    aoyouzi
代码
                                    
    总结了几点关于优雅代码风格的描述： 
 
 代码简单：不隐藏设计者的意图，抽象干净利落，控制语句直截了当。 
 接口清晰：类型接口表现力直白，字面表达含义，API 相互呼应以增强可测试性。 
 依赖项少：依赖关系越少越好，依赖少证明内聚程度高，低耦合利于自动测试，便于重构。 
 没有重复：重复代码意味着某些概念或想法没有在代码中良好的体现，及时重构消除重复。 
 战术分层：代码分层清晰，隔离明确，
    
                                
    • 
                                
  • 布尔数组
                                    百合不是茶
java布尔数组
                                    
      
androi中提到了布尔数组; 
  
布尔数组默认的是false,  并且只会打印false或者是true 
  
布尔数组的例子;  根据字符数组创建布尔数组 
		char[] c = {'p','u','b','l','i','c'};
		//根据字符数组的长度创建布尔数组的个数
		boolean[] b = new bool
    
                                
    • 
                                
  • web.xml之welcome-file-list、error-page
                                    bijian1013
javaweb.xmlservleterror-page
                                    
    welcome-file-list 
1.定义： 
<welcome-file-list>
    <welcome-file>login.jsp</welcome>
</welcome-file-list> 
 2.作用：用来指定WEB应用首页名称。 
  
error-page1.定义： 
<error-page&g
    
                                
    • 
                                
  • richfaces 4 fileUpload组件删除上传的文件
                                    sunjing
clearRichfaces 4fileupload
                                    
     页面代码       
        <h:form id="fileForm">            <rich:
    
                                
    • 
                                
  • 技术文章备忘
                                    bit1129
技术文章
                                    
    Zookeeper 
http://wenku.baidu.com/view/bab171ffaef8941ea76e05b8.html 
http://wenku.baidu.com/link?url=8thAIwFTnPh2KL2b0p1V7XSgmF9ZEFgw4V_MkIpA9j8BX2rDQMPgK5l3wcs9oBTxeekOnm5P3BK8c6K2DWynq9nfUCkRlTt9uV
    
                                
    • 
                                
  • org.hibernate.hql.ast.QuerySyntaxException: unexpected token: on near line 1解决方案
                                    白糖_
Hibernate
                                    
    文章摘自：http://blog.csdn.net/yangwawa19870921/article/details/7553181 
  
在编写HQL时，可能会出现这种代码： 
  
select a.name,b.age from TableA a left join TableB b on a.id=b.id 
 如果这是HQL，那么这段代码就是错误的，因为HQL不支持
    
                                
    • 
                                
  • sqlserver按照字段内容进行排序
                                    bozch
按照内容排序
                                    
    在做项目的时候，遇到了这样的一个需求： 
          从数据库中取出的数据集，首先要将某个数据或者多个数据按照地段内容放到前面显示，例如:从学生表中取出姓李的放到数据集的前面； 
         select * fro
    
                                
    • 
                                
  • 编程珠玑-第一章-位图排序
                                    bylijinnan
java编程珠玑
                                    
    

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Random;

public class BitMapSearch {

  
    
                                
    • 
                                
  • Java关于==和equals
                                    chenbowen00
java
                                    
    关于==和equals概念其实很简单，一个是比较内存地址是否相同，一个比较的是值内容是否相同。虽然理解上不难，但是有时存在一些理解误区，如下情况： 
1、 
 
String a = "aaa"; 
a=="aaa"; 
==> true 
2、 
 
new String("aaa")==new String("aaa
    
                                
    • 
                                
  • [IT与资本]软件行业需对外界投资热情保持警惕
                                    comsci
it
                                    
     
      我还是那个看法,软件行业需要增强内生动力,尽量依靠自有资金和营业收入来进行经营,避免在资本市场上经受各种不同类型的风险,为企业自主研发核心技术和产品提供稳定,温和的外部环境... 
 
      如果我们在自己尚未掌握核心技术之前,企图依靠上市来筹集资金,然后使劲往某个领域砸钱,然
    
                                
    • 
                                
  • oracle 数据块结构
                                    daizj
oracle块数据块块结构行目录
                                    
    oracle 数据块是数据库存储的最小单位，一般为操作系统块的N倍。其结构为： 
 
块头－－〉空行－－〉数据，其实际为纵行结构。 
 
块的标准大小由初始化参数DB_BLOCK_SIZE指定。具有标准大小的块称为标准块（Standard Block）。块的大小和标准块的大小不同的块叫非标准块（Nonstandard Block）。同一数据库中，Oracle9i及以上版本支持同一数据库中同时使用标
    
                                
    • 
                                
  • github上一些觉得对自己工作有用的项目收集
                                    dengkane
github
                                    
    github上一些觉得对自己工作有用的项目收集  
   
技能类 
 
 markdown语法中文说明 
  
回到顶部 
   
全文检索 
 
  elasticsearch  
  bigdesk elasticsearch管理插件  
  
回到顶部 
   
nosql 
 
  mapdb 支持亿级别map, list, 支持事务. 可考虑做为缓存使用  
  C
    
                                
    • 
                                
  • 初二上学期难记单词二
                                    dcj3sjt126com
englishword
                                    
    dangerous 危险的 
panda 熊猫 
lion 狮子 
elephant 象 
monkey 猴子 
tiger 老虎 
deer 鹿 
snake 蛇 
rabbit 兔子 
duck 鸭 
horse 马 
forest 森林 
fall 跌倒；落下 
climb 爬；攀登 
finish 完成；结束 
cinema 电影院；电影 
seafood 海鲜；海产食品 
bank 银行
    
                                
    • 
                                
  • 8、mysql外键(FOREIGN KEY)的简单使用
                                    dcj3sjt126com
mysql
                                    
    一、基本概念 
1、MySQL中“键”和“索引”的定义相同，所以外键和主键一样也是索引的一种。不同的是MySQL会自动为所有表的主键进行索引，但是外键字段必须由用户进行明确的索引。用于外键关系的字段必须在所有的参照表中进行明确地索引，InnoDB不能自动地创建索引。 
2、外键可以是一对一的，一个表的记录只能与另一个表的一条记录连接，或者是一对多的，一个表的记录与另一个表的多条记录连接。 
3、如
    
                                
    • 
                                
  • java循环标签 Foreach
                                    shuizhaosi888
标签java循环foreach
                                    
    1. 简单的for循环 
	public static void main(String[] args) {
		for (int i = 1, y = i + 10; i < 5 && y < 12; i++, y = i * 2) {

			System.err.println("i=" + i + "    y=" 
    
                                
    • 
                                
  • Spring Security（05）——异常信息本地化
                                    234390216
exceptionSpring Security异常信息本地化
                                    
    异常信息本地化 
  
       Spring Security支持将展现给终端用户看的异常信息本地化，这些信息包括认证失败、访问被拒绝等。而对于展现给开发者看的异常信息和日志信息（如配置错误）则是不能够进行本地化的，它们是以英文硬编码在Spring Security的代码中的。在Spring-Security-core-x
    
                                
    • 
                                
  • DUBBO架构服务端告警Failed to send message Response
                                    javamingtingzhao
架构DUBBO
                                    
     废话不多说，警告日志如下，不知道有哪位遇到过，此异常在服务端抛出(服务器启动第一次运行会有这个警告)，后续运行没问题，找了好久真心不知道哪里错了。 
  
 WARN 2015-07-18 22:31:15,272 com.alibaba.dubbo.remoting.transport.dispatcher.ChannelEventRunnable.run(84)
    
                                
    • 
                                
  • JS中Date对象中几个用法
                                    leeqq
JavaScriptDate最后一天
                                    
    近来工作中遇到这样的两个需求 
1. 给个Date对象，找出该时间所在月的第一天和最后一天 
2. 给个Date对象，找出该时间所在周的第一天和最后一天 
  
需求1中的找月第一天很简单，我记得api中有setDate方法可以使用 
使用setDate方法前，先看看getDate 
var date = new Date();
console.log(date);
// Sat J
    
                                
    • 
                                
  • MFC中使用ado技术操作数据库
                                    你不认识的休道人
sqlmfc
                                    
    1.在stdafx.h中导入ado动态链接库 
 
#import"C:\Program Files\Common Files\System\ado\msado15.dll" no_namespace rename("EOF","end")2.在CTestApp文件的InitInstance()函数中domodal之前写::CoIniti
    
                                
    • 
                                
  • Android Studio加速
                                    rensanning
android studio
                                    
    Android Studio慢、吃内存！启动时后会立即通过Gradle来sync & build工程。 
 
 
（1）设置Android Studio 
a) 禁用插件 
File -> Settings...  Plugins 去掉一些没有用的插件。 
比如：Git Integration、GitHub、Google Cloud Testing、Google Cloud
    
                                
    • 
                                
  • 各数据库的批量Update操作
                                    tomcat_oracle
javaoraclesqlmysqlsqlite
                                    
    MyBatis的update元素的用法与insert元素基本相同，因此本篇不打算重复了。本篇仅记录批量update操作的 
sql语句，懂得SQL语句，那么MyBatis部分的操作就简单了。   　　注意：下列批量更新语句都是作为一个事务整体执行，要不全部成功，要不全部回滚。   
MSSQL的SQL语句   
　WITH R AS（
　　SELECT 'John' as name, 18 as
    
                                
    • 
                                
  • html禁止清除input文本输入缓存
                                    xp9802
input
                                    
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。如果不想让浏览器缓存input的值，有2种方法： 
方法一： 在不想使用缓存的input中添加 autocomplete="off"; eg: <input type="text" autocomplete="off" name
    
                                
    •