秋水畏寒
秋水畏寒

Spring源码解析（九）-创建bean实例

Spring版本

5.2.5.RELEASE

参考

《芋道源码》

源码解读

在《Spring源码解析（八）-创建单例bean》
的doCreateBean方法中，第一步是调用了createBeanInstance方法来创建一个bean实例

1. AbstractAutowireCapableBeanFactory#createBeanInstance

    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        // Make sure bean class is actually resolved at this point.
        // 确保到了这一步beanClass已经被解析
        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());
        }

        // 存在Supplier回调方法，则使用Supplier回调方法进行创建
        Supplier instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }

        // 通过factory method方法进行实例化
        if (mbd.getFactoryMethodName() != null) {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }

        // Shortcut when re-creating the same bean...
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                // 判断bean是否解析过
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        // 如果解析过，使用缓存，避免下面选择构造方法的性能开销
        if (resolved) {
            // 如果需要自动注入，采用自动注入的构造方法
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                // 否则，使用默认实例bean方法
                return instantiateBean(beanName, mbd);
            }
        }

        // Candidate constructors for autowiring?
        // 通过参数个数、类型等，确定最合适的构造方法
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
            return autowireConstructor(beanName, mbd, ctors, args);
        }

        // Preferred constructors for default construction?
        // 没有参数的情况下，获取偏爱的构造方法（该方法内部实现返回null）
        ctors = mbd.getPreferredConstructors();
        if (ctors != null) {
            return autowireConstructor(beanName, mbd, ctors, null);
        }

        // No special handling: simply use no-arg constructor.
        // 使用无参构造方法作为兜底
        return instantiateBean(beanName, mbd);
    }

1、调用resolveBeanClass方法再次确保beanClass属性已经被解析，关于resolveBeanClass方法可以查看《Spring源码解析（八）-创建单例bean》
2、如果设置了Supplier回调方法，则使用Supplier回调方法进行创建
3、如果是静态工厂方法，通过FactoryBean的factory method方法进行实例化
4、抉择合适的构造方法，进行实例化

2.AbstractAutowireCapableBeanFactory#obtainFromSupplier

    protected BeanWrapper obtainFromSupplier(Supplier instanceSupplier, String beanName) {
        Object instance;

        // 使用临时变量保存currentlyCreatedBean当前值
        String outerBean = this.currentlyCreatedBean.get();
        // 将beanName设置到currentlyCreatedBean中，表示这是当前正在创建到bean
        // currentlyCreatedBean.get()在getObjectForBeanInstance中会被调用（通过对currentlyCreatedBean使用find Usages发现）
        this.currentlyCreatedBean.set(beanName);
        try {
            // 返回一个bean实例
            instance = instanceSupplier.get();
        }
        finally {
            // 还原原来的临时变量
            if (outerBean != null) {
                this.currentlyCreatedBean.set(outerBean);
            }
            else {
                this.currentlyCreatedBean.remove();
            }
        }

        if (instance == null) {
            instance = new NullBean();
        }
        // 构造一个bean包装器，BeanWrapperImpl内初始化了几个参数，无其他逻辑
        BeanWrapper bw = new BeanWrapperImpl(instance);
        initBeanWrapper(bw);
        return bw;
    }

核心点在于instanceSupplier.get()调用相应的回调方法进行返回一个bean实例，之后构造一个BeanWrapper对象，然后进行初始化，并返回该对象

3. AbstractAutowireCapableBeanFactory#instantiateUsingFactoryMethod

Demo：

源码：

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

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

3.1 ConstructorResolver#instantiateUsingFactoryMethod

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

        // 构造包装器对象
        BeanWrapperImpl bw = new BeanWrapperImpl();
        // 初始化
        this.beanFactory.initBeanWrapper(bw);

        Object factoryBean;
        Class factoryClass;
        boolean isStatic;

        String factoryBeanName = mbd.getFactoryBeanName();
        if (factoryBeanName != null) {
            // factoryBeanName和beanName相同的情况下，感觉就是一个蛋生鸡鸡生蛋的问题，所以要抛出异常进行拦截
            // 另外，如果实例化的是FactoryBean本身，name是以&开头，也不会命中这一层判断
            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);
            // 判断该bean实例是否已经创建
            // containsSingleton方法是判断singletonObjects是否包含该beanName
            if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
                throw new ImplicitlyAppearedSingletonException();
            }
            factoryClass = factoryBean.getClass();
            isStatic = false;
        }
        else {
            // 静态工厂方法，此时需要提供BeanClass
            // It's a static factory method on the bean class.
            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) {
                // 解析保存在mbd中的参数
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
            }
        }

        if (factoryMethodToUse == null || argsToUse == null) {
            // Need to determine the factory method...
            // Try all methods with this name to see if they match the given arguments.
            factoryClass = ClassUtils.getUserClass(factoryClass);

            List candidates = null;
            if (mbd.isFactoryMethodUnique) {
                if (factoryMethodToUse == null) {
                    factoryMethodToUse = mbd.getResolvedFactoryMethod();
                }
                if (factoryMethodToUse != null) {
                    candidates = Collections.singletonList(factoryMethodToUse);
                }
            }
            if (candidates == null) {
                candidates = new ArrayList<>();
                Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
                for (Method candidate : rawCandidates) {
                    // 如果方法被static关键字修饰，并且是factoryMethod，那么加入候选方法中
                    if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                        candidates.add(candidate);
                    }
                }
            }

            // 如果候选方法只有一个，并且没有要求参数，且有无参构造方法，那么，满足创建bean的要求，进行实例化
            if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
                Method uniqueCandidate = candidates.get(0);
                // 如果唯一的候选方法参数个数为=0，满足mbd的无参构造方法
                if (uniqueCandidate.getParameterCount() == 0) {
                    mbd.factoryMethodToIntrospect = uniqueCandidate;
                    synchronized (mbd.constructorArgumentLock) {
                        mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                        mbd.constructorArgumentsResolved = true;
                        mbd.resolvedConstructorArguments = EMPTY_ARGS;
                    }
                    bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
                    return bw;
                }
            }

            // 多于1个，进行排序，排序规则：public且参数多的优先
            if (candidates.size() > 1) {  // explicitly skip immutable singletonList
                candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
            }

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

            // 实例化bean所需要的最少参数个数
            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            }
            else {
                // We don't have arguments passed in programmatically, so we need to resolve the
                // arguments specified in the constructor arguments held in the bean definition.
                if (mbd.hasConstructorArgumentValues()) {
                    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                    resolvedValues = new ConstructorArgumentValues();
                    // 将mbd的构造参数解析进resolvedValues，比如解析下面的constructor-arg标签:
                    //    
                    //        
                    //    
                    // 或者
                    //    
                    //        
                    //        
                    //    
                    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
                }
                else {
                    minNrOfArgs = 0;
                }
            }

            LinkedList causes = null;

            for (Method candidate : candidates) {

                int parameterCount = candidate.getParameterCount();
                // 候选方法参数个数必须大于等于最小参数个数
                if (parameterCount >= minNrOfArgs) {
                    ArgumentsHolder argsHolder;

                    Class[] paramTypes = candidate.getParameterTypes();
                    if (explicitArgs != null) {
                        // Explicit arguments given -> arguments length must match exactly.
                        // 入参explicitArgs指定的情况下，这时候参数个数要求与入参explicitArgs的个数一致
                        if (paramTypes.length != explicitArgs.length) {
                            continue;
                        }
                        argsHolder = new ArgumentsHolder(explicitArgs);
                    }
                    else {
                        // Resolved constructor arguments: type conversion and/or autowiring necessary.
                        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, candidates.size() == 1);
                        }
                        catch (UnsatisfiedDependencyException ex) {
                            if (logger.isTraceEnabled()) {
                                logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
                            }
                            // Swallow and try next overloaded factory method.
                            if (causes == null) {
                                causes = new LinkedList<>();
                            }
                            causes.add(ex);
                            continue;
                        }
                    }

                    // 对比先前查找出的候选值，寻找出最合适的一个

                    // Lenient : 宽容
                    //
                    int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                            argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                    // Choose this factory method if it represents the closest match.
                    if (typeDiffWeight < minTypeDiffWeight) {
                        factoryMethodToUse = candidate;
                        argsHolderToUse = argsHolder;
                        argsToUse = argsHolder.arguments;
                        minTypeDiffWeight = typeDiffWeight;
                        ambiguousFactoryMethods = null;
                    }
                    // Find out about ambiguity: In case of the same type difference weight
                    // for methods with the same number of parameters, collect such candidates
                    // and eventually raise an ambiguity exception.
                    // However, only perform that check in non-lenient constructor resolution mode,
                    // and explicitly ignore overridden methods (with the same parameter signature).
                    // 如果存在多个相同值的候选方法，写入ambiguousFactoryMethods中，在后面会判断该集合，并抛出异常
                    else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
                            !mbd.isLenientConstructorResolution() &&
                            paramTypes.length == factoryMethodToUse.getParameterCount() &&
                            !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                        if (ambiguousFactoryMethods == null) {
                            ambiguousFactoryMethods = new LinkedHashSet<>();
                            ambiguousFactoryMethods.add(factoryMethodToUse);
                        }
                        ambiguousFactoryMethods.add(candidate);
                    }
                }
            }

            // 经过上面的步骤，依旧没能决定出合适的factoryMethodToUse或者argsToUse，那么根据情况抛出各种异常
            if (factoryMethodToUse == null || argsToUse == 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 if (resolvedValues != null) {
                    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()) {
                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) {
                mbd.factoryMethodToIntrospect = factoryMethodToUse;
                argsHolderToUse.storeCache(mbd, factoryMethodToUse);
            }
        }

        bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
        return bw;
    }

方法很长，但整个过程不外乎就是做四件事：

  • 找到需要进行实例化的factoryBean
  • 找到负责实例化的方法factoryMethodToUse
  • 找到负责实例化的方法所需要的参数argsToUse
  • 使用上述三者，进行实例化

围绕上述三点，拆成多个部分来看源码

3.1.1 确定factoryBean

如果factoryBeanName不为空，那根据factoryBeanName找到factoryBean，以factoryBean的class类型作为factoryClass，否则，意味着使用的是静态方法，此时使用mbd定义的beanClass，也就是spring.xml文件中bean声明的class属性

        Object factoryBean;
        Class factoryClass;
        boolean isStatic;

        String factoryBeanName = mbd.getFactoryBeanName();
        if (factoryBeanName != null) {
            // factoryBeanName和beanName相同的情况下，感觉就是一个蛋生鸡鸡生蛋的问题，所以要抛出异常进行拦截
            // 另外，如果实例化的是FactoryBean本身，name是以&开头，也不会命中这一层判断
            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);
            // 判断该bean实例是否已经创建
            // containsSingleton方法是判断singletonObjects是否包含该beanName
            if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
                throw new ImplicitlyAppearedSingletonException();
            }
            factoryClass = factoryBean.getClass();
            isStatic = false;
        }
        else {
            // 静态工厂方法，此时需要提供BeanClass
            // It's a static factory method on the bean class.
            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;
        }

3.1.2 确定实例化方法factoryMethodToUse及其构造参数argsToUse

如果instantiateUsingFactoryMethod方法入参指定了参数explicitArgs，那么直接使用explicitArgs作为argsToUse，否则，尝试从mbd中获取

        // 如果指定了参数，直接使用指定参数
        if (explicitArgs != null) {
            argsToUse = explicitArgs;
        }
        else {
            // 否则，尝试从mdb中获取（加入mbd已经解析出构造参数）
            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) {
                //  如果此时argsToResolve不为空，说明argsToResolve已经被赋值为mbd.preparedConstructorArguments，此时使用mbd.preparedConstructorArguments进行解析
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
            }
        }

如果factoryMethodToUse和argsToUse都未能解析成功，则挑选出合适的候选方法集合candidates：

            factoryClass = ClassUtils.getUserClass(factoryClass);

            List candidates = null;
            if (mbd.isFactoryMethodUnique) {
                if (factoryMethodToUse == null) {
                    factoryMethodToUse = mbd.getResolvedFactoryMethod();
                }
                if (factoryMethodToUse != null) {
                    candidates = Collections.singletonList(factoryMethodToUse);
                }
            }
            if (candidates == null) {
                candidates = new ArrayList<>();
                Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
                for (Method candidate : rawCandidates) {
                    // 如果方法被static关键字修饰，并且是factoryMethod，那么加入候选方法中
                    if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                        candidates.add(candidate);
                    }
                }
            }

如果candidates只有一个，并且没有要求参数，且有无参方法，那么，满足创建bean的要求，进行实例化

            // 如果候选方法只有一个，并且没有要求参数，且有无参方法，那么，满足创建bean的要求，进行实例化
            if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
                Method uniqueCandidate = candidates.get(0);
                // 如果唯一的候选方法参数个数为=0，满足mbd的无参方法
                if (uniqueCandidate.getParameterCount() == 0) {
                    mbd.factoryMethodToIntrospect = uniqueCandidate;
                    synchronized (mbd.constructorArgumentLock) {
                        mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                        mbd.constructorArgumentsResolved = true;
                        mbd.resolvedConstructorArguments = EMPTY_ARGS;
                    }
                    bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
                    return bw;
                }
            }

若是有多个，进行排序：

            // 多于1个，进行排序，排序规则：public且参数多的优先
            if (candidates.size() > 1) {  // explicitly skip immutable singletonList
                candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
            }

解析进行实例化的时候需要的最少参数个数minNrOfArgs：

            // 实例化bean所需要的最少参数个数
            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            }
            else {
                // We don't have arguments passed in programmatically, so we need to resolve the
                // arguments specified in the constructor arguments held in the bean definition.
                if (mbd.hasConstructorArgumentValues()) {
                    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                    resolvedValues = new ConstructorArgumentValues();
                    // 将mbd的构造参数解析进resolvedValues，比如解析下面的constructor-arg标签:
                    //    
                    //        
                    //    
                    // 或者
                    //    
                    //        
                    //        
                    //    
                    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
                }
                else {
                    minNrOfArgs = 0;
                }
            }

遍历candidates，挑选出最合适的方法，得到argsToUse

            for (Method candidate : candidates) {

                int parameterCount = candidate.getParameterCount();
                // 候选方法参数个数必须大于等于最小参数个数
                if (parameterCount >= minNrOfArgs) {
                    ArgumentsHolder argsHolder;

                    Class[] paramTypes = candidate.getParameterTypes();
                    if (explicitArgs != null) {
                        // Explicit arguments given -> arguments length must match exactly.
                        // 入参explicitArgs指定的情况下，这时候参数个数要求与入参explicitArgs的个数一致
                        if (paramTypes.length != explicitArgs.length) {
                            continue;
                        }
                        argsHolder = new ArgumentsHolder(explicitArgs);
                    }
                    else {
                        // Resolved constructor arguments: type conversion and/or autowiring necessary.
                        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, candidates.size() == 1);
                        }
                        catch (UnsatisfiedDependencyException ex) {
                            if (logger.isTraceEnabled()) {
                                logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
                            }
                            // Swallow and try next overloaded factory method.
                            if (causes == null) {
                                causes = new LinkedList<>();
                            }
                            causes.add(ex);
                            continue;
                        }
                    }

                    // 对比先前查找出的候选值，寻找出最合适的一个

                    // Lenient : 宽容
                    //
                    int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                            argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                    // Choose this factory method if it represents the closest match.
                    if (typeDiffWeight < minTypeDiffWeight) {
                        factoryMethodToUse = candidate;
                        argsHolderToUse = argsHolder;
                        argsToUse = argsHolder.arguments;
                        minTypeDiffWeight = typeDiffWeight;
                        ambiguousFactoryMethods = null;
                    }
                    // Find out about ambiguity: In case of the same type difference weight
                    // for methods with the same number of parameters, collect such candidates
                    // and eventually raise an ambiguity exception.
                    // However, only perform that check in non-lenient constructor resolution mode,
                    // and explicitly ignore overridden methods (with the same parameter signature).
                    // 如果存在多个相同值的候选方法，写入ambiguousFactoryMethods中，在后面会判断该集合，并抛出异常
                    else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
                            !mbd.isLenientConstructorResolution() &&
                            paramTypes.length == factoryMethodToUse.getParameterCount() &&
                            !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                        if (ambiguousFactoryMethods == null) {
                            ambiguousFactoryMethods = new LinkedHashSet<>();
                            ambiguousFactoryMethods.add(factoryMethodToUse);
                        }
                        ambiguousFactoryMethods.add(candidate);
                    }
                }
            }

如argsToUse和factoryMethodToUse依旧为空，那么抛出异常，此时实例化失败

            // 经过上面的步骤，依旧没能决定出合适的factoryMethodToUse或者argsToUse，那么根据情况抛出各种异常
            if (factoryMethodToUse == null || argsToUse == 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 if (resolvedValues != null) {
                    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()) {
                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);
            }

3.1.3 通过反射实例化

bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));

    private Object instantiate(String beanName, RootBeanDefinition mbd,
            @Nullable Object factoryBean, Method factoryMethod, Object[] args) {

        try {
            if (System.getSecurityManager() != null) {
                return AccessController.doPrivileged((PrivilegedAction) () ->
                        this.beanFactory.getInstantiationStrategy().instantiate(
                                mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args),
                        this.beanFactory.getAccessControlContext());
            }
            else {
                // 通过反射调用对应方法进行实例化
                return this.beanFactory.getInstantiationStrategy().instantiate(
                        mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean instantiation via factory method failed", ex);
        }
    }


    @Override
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
            @Nullable Object factoryBean, final Method factoryMethod, Object... args) {

        try {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction) () -> {
                    ReflectionUtils.makeAccessible(factoryMethod);
                    return null;
                });
            }
            else {
                ReflectionUtils.makeAccessible(factoryMethod);
            }

            Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
            try {
                currentlyInvokedFactoryMethod.set(factoryMethod);
                Object result = factoryMethod.invoke(factoryBean, args);
                if (result == null) {
                    result = new NullBean();
                }
                return result;
            }
            finally {
                if (priorInvokedFactoryMethod != null) {
                    currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
                }
                else {
                    currentlyInvokedFactoryMethod.remove();
                }
            }
        }
        // 略
    }


4. ConstructorResolver#autowireConstructor


    public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
            @Nullable Constructor[] chosenCtors, @Nullable Object[] explicitArgs) {

        BeanWrapperImpl bw = new BeanWrapperImpl();
        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) {
                    // Found a cached constructor...
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }
            // 如果此时argsToResolve不为空，说明argsToResolve已经被赋值为mbd.preparedConstructorArguments，此时使用mbd.preparedConstructorArguments进行解析
            if (argsToResolve != null) {
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
            }
        }

        if (constructorToUse == null || argsToUse == null) {
            // Take specified constructors, if any.
            // 如果入参指定了候选构造参数，则使用
            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);
                }
            }

            if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
                Constructor uniqueCandidate = candidates[0];
                if (uniqueCandidate.getParameterCount() == 0) {
                    synchronized (mbd.constructorArgumentLock) {
                        mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                        mbd.constructorArgumentsResolved = true;
                        mbd.resolvedConstructorArguments = EMPTY_ARGS;
                    }
                    bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
                    return bw;
                }
            }

            // Need to resolve the constructor.
            boolean autowiring = (chosenCtors != null ||
                    mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
            ConstructorArgumentValues resolvedValues = null;

            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            }
            else {
                ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                resolvedValues = new ConstructorArgumentValues();
                // 将mbd的参数解析到resolvedValues中
                minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
            }

            AutowireUtils.sortConstructors(candidates);
            int minTypeDiffWeight = Integer.MAX_VALUE;
            Set> ambiguousConstructors = null;
            LinkedList causes = null;

            for (Constructor candidate : candidates) {

                int parameterCount = candidate.getParameterCount();

                if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
                    // Already found greedy constructor that can be satisfied ->
                    // do not look any further, there are only less greedy constructors left.
                    break;
                }
                if (parameterCount < minNrOfArgs) {
                    continue;
                }

                ArgumentsHolder argsHolder;
                Class[] paramTypes = candidate.getParameterTypes();
                if (resolvedValues != null) {
                    try {
                        String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
                        if (paramNames == null) {
                            ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                            if (pnd != null) {
                                paramNames = pnd.getParameterNames(candidate);
                            }
                        }
                        argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
                                getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
                    }
                    catch (UnsatisfiedDependencyException ex) {
                        if (logger.isTraceEnabled()) {
                            logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
                        }
                        // Swallow and try next constructor.
                        if (causes == null) {
                            causes = new LinkedList<>();
                        }
                        causes.add(ex);
                        continue;
                    }
                }
                else {
                    // Explicit arguments given -> arguments length must match exactly.
                    if (parameterCount != explicitArgs.length) {
                        continue;
                    }
                    argsHolder = new ArgumentsHolder(explicitArgs);
                }

                int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                        argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                // Choose this constructor if it represents the closest match.
                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 != null) {
                argsHolderToUse.storeCache(mbd, constructorToUse);
            }
        }

        Assert.state(argsToUse != null, "Unresolved constructor arguments");
        bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
        return bw;
    }



该方法和第三点使用工厂方法实例化大部分代码是相似的，这里就无须多言了，主要看一下instantiate方法


4.1 ConstructorResolver#instantiate


    private Object instantiate(
            String beanName, RootBeanDefinition mbd, Constructor constructorToUse, Object[] argsToUse) {

        try {
            // 获取实例化策略，默认是CglibSubclassingInstantiationStrategy
            InstantiationStrategy strategy = this.beanFactory.getInstantiationStrategy();
            if (System.getSecurityManager() != null) {
                return AccessController.doPrivileged((PrivilegedAction) () ->
                        strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse),
                        this.beanFactory.getAccessControlContext());
            }
            else {
                // 选择合适的策略进行实例化
                return strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean instantiation via constructor failed", ex);
        }
    }


先获取实例化策略，再交由获取到的实例化策略去执行具体的实例化逻辑


4.2 SimpleInstantiationStrategy#instantiate


    @Override
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
            final Constructor ctor, Object... args) {

        // 如果没有replace-method、lookup-method，以及使用@Lookup注解，那么使用反射进行实例化
        if (!bd.hasMethodOverrides()) {
            if (System.getSecurityManager() != null) {
                // use own privileged to change accessibility (when security is on)
                AccessController.doPrivileged((PrivilegedAction) () -> {
                    ReflectionUtils.makeAccessible(ctor);
                    return null;
                });
            }
            // 使用cror构造方法通过反射实例化
            return BeanUtils.instantiateClass(ctor, args);
        }
        else {
            // 否则，创建cglib子类实例化
            return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
        }
    }


如果使用了replace-method、lookup-method、或者使用了@Lookup注解，则创建cglib子类进行实例化，否则直接使用反射进行实例化


4.3 BeanUtils#instantiateClass


反射进行实例化，核心代码如下：


            ReflectionUtils.makeAccessible(ctor);
            if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
                return KotlinDelegate.instantiateClass(ctor, args);
            }
            else {
                Class[] parameterTypes = ctor.getParameterTypes();
                Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
                Object[] argsWithDefaultValues = new Object[args.length];
                for (int i = 0 ; i < args.length; i++) {
                    if (args[i] == null) {
                        // 如果参数为空，获取对应类型的默认值
                        Class parameterType = parameterTypes[i];
                        argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
                    }
                    else {
                        argsWithDefaultValues[i] = args[i];
                    }
                }
                // 反射实例化对象
                return ctor.newInstance(argsWithDefaultValues);
            }



4.4 SimpleInstantiationStrategy#instantiateWithMethodInjection


创建cglib子类进行实例化


    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName,
            BeanFactory owner, @Nullable Constructor ctor, Object... args) {

        throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
    }



该方法默认没有实现，交由子类CglibSubclassingInstantiationStrategy来实现：


    @Override
    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        return instantiateWithMethodInjection(bd, beanName, owner, null);
    }

    @Override
    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
            @Nullable Constructor ctor, Object... args) {

        // Must generate CGLIB subclass...
        return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
    }



instantiate方法具体实现：


        public Object instantiate(@Nullable Constructor ctor, Object... args) {
            // 创建子类
            Class subclass = createEnhancedSubclass(this.beanDefinition);
            Object instance;
            if (ctor == null) {
                // 如果构造器为空，则通过反射获取实例
                instance = BeanUtils.instantiateClass(subclass);
            }
            else {
                try {
                    // 获取子类构造方法
                    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);
                }
            }
            // SPR-10785: set callbacks directly on the instance instead of in the
            // enhanced class (via the Enhancer) in order to avoid memory leaks.
            Factory factory = (Factory) instance;
            factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
                    new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
                    new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
            return instance;
        }



5. ConstructorResolver#instantiateBean


    protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
        try {
            Object beanInstance;
            final BeanFactory parent = this;
            if (System.getSecurityManager() != null) {
                beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
                        getInstantiationStrategy().instantiate(mbd, beanName, parent),
                        getAccessControlContext());
            }
            else {
                // 使用合适的实例化策略，默认是cglib
                beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
            }
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            initBeanWrapper(bw);
            return bw;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
        }
    }


大部分逻辑在第四点基本覆盖了


总结


可以看到，在创建bean实例这块上，因为创建bean可以有多种方式：


    

  • 通过Supplier 
    • 

  • 通过factory method 
    • 

  • 通过构造方法
    • 

  • 通过默认构造方法
     spring在这方面上花了很多精力，尤其是抉择合适的factory method和构造方法上，使用了大量代码来确定合适的方法和参数。
    • 

























你可能感兴趣的:(Spring源码解析（九）-创建bean实例)






    

  • SQLite数据库管理与Android应用集成
含老司开挖掘机

    本文还有配套的精品资源，点击获取简介：SQLite是一种轻量级的关系型数据库，适用于移动设备和单机应用。它内置了对SQL标准的支持，并提供丰富的数据操作功能。在Android开发中，SQLite是默认的数据库解决方案，可通过SQLiteOpenHelper和SQLiteDatabaseAPI进行管理。本教程将通过实践帮助理解SQLite数据库的创建、管理和使用，以及如何将其与Android应用集成
    

    • 

  • C# WinForm实现WebService接口进行图片上传下载
诡道荒行

    本文还有配套的精品资源，点击获取简介：本文深入介绍了在C#WinForm应用程序中使用WebService接口连接服务器，实现图片的上传和下载功能。通过理解WebService基础，利用WinForm工具创建用户界面，并实现客户端与WebService的连接，我们详细探讨了图片上传与下载的具体步骤，包括文件选择、数据转换、接口调用，以及异常处理和进度显示。同时，还强调了安全性与性能优化的重要性，确
    

    • 

  • linux系统下PostgreSQL的使用
敲代码的雪糕
linuxlinuxpostgresql运维

    文章目录前言一、安装pgsql数据库二、安装c和c++驱动三、使用1、头文件2、源文件3、main文件4、编译前言最近工作中使用到了pgsql,主要是使用其c++驱动完成数据库创建及增删改查等操作…一、安装pgsql数据库使用命令如下:sudoapt-getinstallpostgresql安装完成,使用如下命令,确认数据库版本:psql--version二、安装c和c++驱动使用如下命令安装c驱
    

    • 

  • 大数据平台--调度系统
小瓶盖的猪猪侠

    调度系统是数据仓库的重要组成部分，也是每个银行或公司一个基础软件或服务，需要在全行或全公司层面进行规划，在全行层面统一调度工具和规范，由于数据类系统调度作业较多，交易类系统批量优先级高，调度系统的整体架构如下：调度中心对调度批次和作业进行创建、管理、监控，它负责所有批量作业的调度和编排；在整个作业过程中，作业之间关系分为触发，依赖和互斥。1、触发触发关系表示一个作业完毕后，生成另一个作业的控制文件
    

    • 

  • 明天忙完就可以休息了
秋天的小白杨

    从九号上班到现在还没有休息过，明天公司会议终于是要召开了。忙完明天后面的事就不是太多了。这几天也主要是被广告公司坑了，老实说公司找的这广告公司感觉就是个不靠谱的打印店，什么都不会处理，量尺寸都拖时间，搞的很赶，，而且时间紧老怕出差错。公司领导也很烦，会议主题和内容不停的在变，明天就要开会了很多东西还没定下来，到时候就怕忙中出错。又是我们这些底层挨骂。希望明天一切顺利！
    

    • 

  • 类方法、类实例方法和类静态方法（Python）
Qh果壳
python开发语言

    目录1.类方法（ClassMethod）2.类实例方法（InstanceMethod）3.类静态方法（StaticMethod）在Python中，类方法、类实例方法和类静态方法是与类相关联的三种不同类型的方法。1.类方法（ClassMethod）：类方法是通过装饰器@classmethod来定义的，它的第一个参数是类本身（通常被命名为"cls"），而不是实例。类方法可以通过类名调用，也可以通过实例
    

    • 

  • 温暖心世界
ef93fc0a947d

    来到心世界给大家提供的沙龙，首先看到喜悦的九淳妹妹，马上被她感染，与她拥抱后马上感到心满满的爱…看到忙着让大家签到的青蕊，和她呆一起，总给人如沐春风之感，看到拿着话筒喜悦又有趣和大家玩耍的建华姐，那种画面，无法用语言表达了…来不及换换衣服，就地放下包，叭倒在白色软软的地毯上与地毯融为一体，来到这个充满爱的心世界，瞬间放下一切，感到温暖扑面而来感谢景新姐的用心付出，整场沙龙都是我们在玩，景新姐在付出
    

    • 

  • 【Python笔记】向量：@classmethod与 @staticmethod。零基础
万物皆可.C
Python笔记python

    类成员比较@classmethod与@staticmethod共同点：两个都是装饰器，装饰的成员函数可以通过类名.方法名(…)来调用区别：最显著的特点是classmethod需要传递一个参数cls，而staticmethod不需要。因此可以访问、修改类的属性，类的方法，实例化对象等，避免硬编码；而staticmethod不行，classmethod可以判断出自己是通过基类被调用，还是通过某个子类被
    

    • 

  • 今日杂感
玉蜻蜓的世界

    2021年11月19日星期五阴昨晚批完学生的第五单元作文，感觉整体写的不好，今天空中课堂还有一节作文讲评课，就打算学生先听空中课堂，再听我讲评作文，最后再次修改作文。因此昨晚就在班级群里发信息，今早九点半上作文讲评课。今早九点时哥又打电话，让我去附属医院，他要做CT必须得有家属签字才可以。嫂子上班脱不开身，哥就打电话让我过去。老公今早正好下夜班，我打电话让老公直接去医院给哥签字。上课时，老妈又打电
    

    • 

  • Docker部署Doris数据库
hai40587
docker数据库容器

    Docker部署Doris数据库是一个涉及多个步骤的过程，包括环境准备、Docker镜像拉取、配置文件创建、容器启动与配置、以及后续的数据库操作等。以下是一个详细的Docker部署Doris数据库的教程，旨在帮助用户成功在Docker环境中部署并运行Doris数据库。一、环境准备在部署Doris之前，需要确保你的系统已经安装了Docker。Docker是一个开源的容器化平台，可以帮助你轻松地部署和
    

    • 

  • 让孩子学会做饭
Lotus逝风

    又一个别人家的孩子，父母们集体酸了。近日，河南焦作的一位12岁男孩除夕夜大显身手，独自给爸妈做了九菜一汤的年夜饭。从蒜薹炒肉、炒杏鲍菇到健腐肉等，有些菜连我都不会，实在是有些汗颜。别人家的孩子小时候因为家里姊妹多，我又是老幺。每当做饭我都是打下手的那个，剥个蒜摘个葱打个鸡蛋什么的。导致到现在能独立完成的也就是个西红柿炒鸡蛋，偶尔想改善下伙食只能外卖走起。如果可以回到小时候，我一定要让自己学会做饭，
    

    • 

  • iOS——atomic、nonatomic、assign、_unsafe_unretain
糸师凛
ioscocoamacos

    atomic和nonatomic在iOS开发中，当你定义一个属性时，编译器会自动为你生成一个带下划线的成员变量（实例变量）以及对应的getter和setter方法。如果你使用atomic修饰这个属性，那么编译器在生成setter和getter方法时，会在这些方法的内部实现中加入加锁操作。但是加锁只能保证getter和setter方法内部的线程安全，并不能保证对该属性的所有操作都是线程安全的。具体的
    

    • 

  • SpringBoot自动装配中的Condition机制
hai40587
springbootjava后端

    SpringBoot自动装配中的Condition机制在SpringBoot中，自动装配（Auto-Configuration）是一个核心特性，它极大地简化了Spring应用的配置过程。自动装配通过条件判断（Condition）机制，根据应用的环境和依赖来决定是否创建和配置Bean。这一机制在Spring4.0中引入，主要通过@Conditional注解及其一系列变体实现。本文将详细探讨Sprin
    

    • 

  • 使用docker部署考试系统
汪公子492
docker

    web--拉取nginx--挂载项目文档dist--dockerrun-itd-v/root/pes/web/dist/:/usr/share/nginx/html-p80:80nginx:latest配置mysql服务--拉取mysql:5.7.44镜像--创建容器测试dockerrun-itd-p3306:3306-eMYSQL_ROOT_PASSWORD=rootmysql:5.7.44do
    

    • 

  • 【跟上黑马学sql】学习笔记-MySQL-DQL-排序查询
学扎娃的小白
mysqlsql学习

    DQL排序查询实例#创建一个表createtableemp4(idintcomment'编号',worknovarchar(10)comment'工号',namevarchar(5)comment'姓名',genderchar(1)comment'性别',agetinyintunsignedcomment'年龄',idcardchar(18)comment'身份证号',workaddressvar
    

    • 

  • Spring-bean的生命周期-中篇
码农小伙
Springspringjava后端

    阶段4：BeanDefinition合并阶段合并阶段是做什么的？可能我们定义bean的时候有父子bean关系，此时子BeanDefinition中的信息是不完整的，比如设置属性的时候配置在父BeanDefinition中，此时BeanDefinition中是没有这些信息的，需要将子bean的BeanDefinition和父beanBeanDefinition进行合并，得到最终的一个RootBean
    

    • 

  • 软考——简单记忆设计模式
Yeira
设计模式pythonjava

    抽象工厂模式（AbstractFactory）:提供一个接口，可以创建一系列相关或相互依赖的对象，而无需指定它们具体的类。（一个接口创建相关对象，无需具体的类）构建器模式（Builder）：将一个复杂类的表示与其构造相分离，使得相同的构建过程能够得出不同的表示。（相同是构造，不同的表示）工厂方法模式（FactoryMethod）：定义一个创建对象的接口，但由子类决定需要实例化哪一个类。工厂方法使得
    

    • 

  • mysql日期加间隔_MySQL DATE_ADD和ADDDATE函数实现向日期添加指定时间间隔
风花雪月不等人
mysql日期加间隔

    MySQLDATE_ADD(date,INTERVALexprtype)和ADDDATE(date,INTERVALexprtype)两个函数的作用相同，都是用于执行日期的加运算。DATE_ADD()和ADDDATE()函数有两个参数：date是DATE或DATETIME的起始值。INTERVALexprtype是要添加到起始日期值的间隔值。【实例1】使用DATE_ADD(date,INTERVA
    

    • 

  • Java 设计模式-状态模式
动物园首领
Java设计模式java设计模式状态模式

    目录一.概述二.主要角色三.代码示例四.优缺点优点：缺点：五.常见应用场景一.概述状态模式是一种行为设计模式，它允许一个对象在其内部状态改变时改变它的行为。对象看起来好像修改了它的类。状态模式把所有的与一个特定的状态相关的行为放到一个类中，并且将请求委托给当前状态对象来执行。在状态模式中，我们创建表示各种状态的对象和一个行为随状态对象改变而改变的Context对象。二.主要角色状态模式主要包含三个
    

    • 

  • 掌握Go语言邮件发送：net/smtp实用教程与最佳实践
walkskyer
golang标准库golanggithub开发语言

    掌握Go语言邮件发送：net/smtp实用教程与最佳实践概述基本配置与初始化导入`net/smtp`包设置SMTP服务器基本信息创建SMTP客户端实例身份验证发送简单文本邮件配置发件人信息构建邮件头部信息编写邮件正文使用`SendMail`方法发送邮件示例代码发送带附件的邮件邮件多部分格式简介构建带有附件的邮件体使用`SendMail`方法发送邮件发送HTML格式的邮件HTML邮件的优势和应用场景
    

    • 

  • 第九章 炼药师公会
温逍遥

    “砰”一声爆响传来，让所有人目瞪口呆的是，龙尘不知道什么时候，已经出现在李浩的身前，宛如鬼魅，那正是疾风步的效果，速度奇快，尤其近距离爆发，更是让人防不胜防。李浩双爪停在半空，龙尘的一脚狠狠提踢在他的两腿中间，狂暴的力量，将他整个人都踢上了半空。王莽正幻想着李浩如何将龙尘折磨的生不如死呢，但是眼前的一幕，一下子让他目瞪口呆起来。擂台上，李浩死死地捂着自己的裆部，脸色已经抽搐的变形，如果不是先前就用
    

    • 

  • 【软考】设计模式之抽象工厂模式
王佑辉
软考设计模式软考

    目录1.说明2.应用场景3.结构图4.构成5.适用性6.优点7.缺点8.java示例1.说明1.提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。2.抽象工厂模式（AbstractFactoryPattern）是一种创建型设计模式。3.抽象工厂模式用于系统的产品族，而不仅仅是一个等级结构；一个等级的抽象类只能创建一个等级的产品，而抽象工厂模式能创建多个等级的产品。2.应用场景1.
    

    • 

  • 微信小程序-云开发（1）常用的一些数据操作
Christoles

    在微信小程序-云开发创建的时候，它自动替我们创建了cloudfunctions和miniprogram文件，并且在project.config.json中定义好了这两个文件的名称和路径。如果我们要更改这两个文件名的话，相应的也要修改project.config.json里面的。image.png下面来讲一下关于云开发那些常用的数据方法吧微信小程序-云开发可以前后端一起操作，在做项目时，通常搭建两个
    

    • 

  • 软考-常见的23种设计模式整理
ppliu600
软件架构数据仓库数据库数据挖掘

    参考：23种设计模式总结设计模式可以将复用别人的解决方案。一、设计模式的分类创建型模式，共5种：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。结构型模式，共7种：适配器模式、组合模式、代理模式、享元模式、外观模式、桥接模式、装饰器模式、行为型模式，共11种：观察者模式、策略模式、模板方法模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
    

    • 

  • ToList()和ToArray()的区别
微微的猪食小窝
.Net进阶.net后端开发语言linqc#

    以下是具体分析：1.返回类型ToList()：返回一个泛型列表List，其中T是列表中元素的类型。ToArray()：返回一个Object类型的数组。如果需要特定类型的数组，必须使用重载的ToArray(T[]a)方法，并传入一个该类型的数组作为参数。2.内部处理ToList()：直接创建一个新的List，并将元素添加到这个List中。ToArray()：根据传入的数组参数情况，可能会创建新数组或
    

    • 

  • 如何使用Spring Boot进行单元测试
好哈优学编程
springboot单元测试java

    1.添加依赖:确保pom.xml中包含spring-boot-starter-test依赖。它包括JUnit、AssertJ、Hamcrest等测试框架。org.springframework.bootspring-boot-starter-testtest2.编写测试类:在src/test/java目录下创建一个测试类。确保该类位于与待测试类相同的包或其子包中。@SpringBootTestpu
    

    • 

  • 婆婆的故事--三兄弟--上学篇（九）
淡妆浓抹两相宜

    五一假期，老三带我去医院做了白内障手术。手术后医生要求多平躺，不能侧卧，不能低头，害怕安装的晶体移位。回到家，我听从医生的吩咐乖乖的躺在床上，老三每隔十分钟给我滴一次眼药水。大概是怕我无聊，老三和他媳妇都坐在床边陪我聊天。床头写字桌上的相框里有许多老照片，老三拿出他的毕业照给他老婆看，“看的出来哪个是我吗？”我躺在床上闭着眼睛听他两口子说话。小双说：“这个是你。”老三说：“嗯。我是个分界线，从我往
    

    • 

  • Rust模块std::thread
夏天又到了
Rust编程与项目实战rustjava算法

    【图书介绍】《Rust编程与项目实战》-CSDN博客《Rust编程与项目实战》(朱文伟，李建英)【摘要书评试读】-京东图书(jd.com)Rust到底值不值得学，之一-CSDN博客Rust到底值不值得学，之二-CSDN博客Rust多线程编程概述-CSDN博客12.3.2等待所有线程完成在前面的实例中，主线程没等到派生线程执行完毕就结束了，从而整个进程就会结束。那么怎么让派生线程执行完毕呢？答案是通
    

    • 

  • 浅谈C#之485通讯
CN.LG
C#网络

    一、基本介绍C#中实现485通讯，通常指的是使用RS-485串行通信接口。RS-485是一种半双工通信标准，常用于工业环境中的设备之间的通信。二、简单示例打开串口：首先，你需要创建一个SerialPort对象，并设置其参数，如端口名、波特率、数据位、停止位和奇偶校验位。然后打开串口。SerialPortsp=newSerialPort();sp.PortName="COM1";//串口名称sp.B
    

    • 

  • 2.1、matlab绘图汇总(图例、标题、坐标轴、线条格式、颜色和散点格式设置)
逼子歌
matlab开发语言算法

    1、前言在MATLAB中进行绘图是一种非常常见且实用的操作，可以用来可视化数据、结果展示、分析趋势等。通过MATLAB的绘图功能，用户可以创建各种类型的图形，包括线图、散点图、柱状图、曲线图等，以及三维图形、动画等复杂的可视化效果。在绘图之前，通常需要先准备好要展示的数据，并对数据进行必要的处理和分析。在开始绘图之前，建议考虑以下几点：数据准备：确保数据已经被正确导入到MATLAB中，并进行了初步
    

    • 

  • 强大的销售团队背后 竟然是大数据分析的身影
蓝儿唯美
数据分析

    Mark Roberge是HubSpot的首席财务官，在招聘销售职位时使用了大量数据分析。但是科技并没有挤走直觉。
大家都知道数理学家实际上已经渗透到了各行各业。这些热衷数据的人们通过处理数据理解商业流程的各个方面，以重组弱点，增强优势。
Mark Roberge是美国HubSpot公司的首席财务官，HubSpot公司在构架集客营销现象方面出过一份力——因此他也是一位数理学家。他使用数据分析 
    

    • 

  • Haproxy+Keepalived高可用双机单活
bylijinnan
负载均衡keepalivedhaproxy高可用

    我们的应用MyApp不支持集群，但要求双机单活（两台机器：master和slave）：
1.正常情况下，只有master启动MyApp并提供服务
2.当master发生故障时，slave自动启动本机的MyApp，同时虚拟IP漂移至slave，保持对外提供服务的IP和端口不变
F5据说也能满足上面的需求，但F5的通常用法都是双机双活，单活的话还没研究过
服务器资源
10.7
    

    • 

  • eclipse编辑器中文乱码问题解决
0624chenhong
eclipse乱码

    使用Eclipse编辑文件经常出现中文乱码或者文件中有中文不能保存的问题，Eclipse提供了灵活的设置文件编码格式的选项，我们可以通过设置编码 格式解决乱码问题。在Eclipse可以从几个层面设置编码格式：Workspace、Project、Content Type、File
本文以Eclipse 3.3（英文）为例加以说明：
1. 设置Workspace的编码格式：
Windows-&g
    

    • 

  • 基础篇--resources资源
不懂事的小屁孩
android

    最近一直在做java开发，偶尔敲点android代码，突然发现有些基础给忘记了，今天用半天时间温顾一下resources的资源。
String.xml    字符串资源   涉及国际化问题 
http://www.2cto.com/kf/201302/190394.html  
string-array
    

    • 

  • 接上篇补上window平台自动上传证书文件的批处理问卷
酷的飞上天空
window

    
@echo off
: host=服务器证书域名或ip，需要和部署时服务器的域名或ip一致 ou=公司名称, o=公司名称
set host=localhost
set ou=localhost
set o=localhost
set password=123456
set validity=3650
set salias=s
    

    • 

  • 企业物联网大潮涌动：如何做好准备？
蓝儿唯美
企业

    物联网的可能性也许是无限的。要找出架构师可以做好准备的领域然后利用日益连接的世界。
尽管物联网（IoT）还很新，企业架构师现在也应该为一个连接更加紧密的未来做好计划，而不是跟上闸门被打开后的集成挑战。“问题不在于物联网正在进入哪些领域，而是哪些地方物联网没有在企业推进，” Gartner研究总监Mike Walker说。
Gartner预测到2020年物联网设备安装量将达260亿，这些设备在全
    

    • 

  • spring学习——数据库（mybatis持久化框架配置）
a-john
mybatis

    Spring提供了一组数据访问框架，集成了多种数据访问技术。无论是JDBC，iBATIS(mybatis)还是Hibernate，Spring都能够帮助消除持久化代码中单调枯燥的数据访问逻辑。可以依赖Spring来处理底层的数据访问。
mybatis是一种Spring持久化框架，要使用mybatis，就要做好相应的配置：
1，配置数据源。有很多数据源可以选择，如：DBCP，JDBC，aliba
    

    • 

  • Java静态代理、动态代理实例
aijuans
Java静态代理

    
采用Java代理模式，代理类通过调用委托类对象的方法，来提供特定的服务。委托类需要实现一个业务接口，代理类返回委托类的实例接口对象。
按照代理类的创建时期，可以分为：静态代理和动态代理。
所谓静态代理：　指程序员创建好代理类，编译时直接生成代理类的字节码文件。
所谓动态代理：　在程序运行时，通过反射机制动态生成代理类。
 
一、静态代理类实例：
1、Serivce.ja
    

    • 

  • Struts1与Struts2的12点区别
asia007
Struts1与Struts2

    1) 在Action实现类方面的对比：Struts 1要求Action类继承一个抽象基类；Struts 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口，也可以实现其他接口，使可选和定制的服务成为可能。Struts 2提供一个ActionSupport基类去实现常用的接口。即使Action接口不是必须实现的，只有一个包含execute方法的P
    

    • 

  • 初学者要多看看帮助文档 不要用js来写Jquery的代码
百合不是茶
jqueryjs

    解析json数据的时候需要将解析的数据写到文本框中,  出现了用js来写Jquery代码的问题;
 
1, JQuery的赋值  有问题
   代码如下: data.username 表示的是:  网易
 
         $("#use
    

    • 

  • 经理怎么和员工搞好关系和信任
bijian1013
团队项目管理管理

            产品经理应该有坚实的专业基础，这里的基础包括产品方向和产品策略的把握，包括设计，也包括对技术的理解和见识，对运营和市场的敏感，以及良好的沟通和协作能力。换言之，既然是产品经理，整个产品的方方面面都应该能摸得出门道。这也不懂那也不懂，如何让人信服？如何让自己懂？就是不断学习，不仅仅从书本中，更从平时和各种角色的沟通
    

    • 

  • 如何为rich:tree不同类型节点设置右键菜单
sunjing
contextMenutreeRichfaces

    组合使用target和targetSelector就可以啦，如下： <rich:tree id="ruleTree" value="#{treeAction.ruleTree}" var="node" nodeType="#{node.type}"
selectionChangeListener=&qu
    

    • 

  • 【Redis二】Redis2.8.17搭建主从复制环境
bit1129
redis

    开始使用Redis2.8.17
Redis第一篇在Redis2.4.5上搭建主从复制环境，对它的主从复制的工作机制，真正的惊呆了。不知道Redis2.8.17的主从复制机制是怎样的，Redis到了2.4.5这个版本，主从复制还做成那样，Impossible is nothing! 本篇把主从复制环境再搭一遍看看效果，这次在Unbuntu上用官方支持的版本。   Ubuntu上安装Red
    

    • 

  • JSONObject转换JSON--将Date转换为指定格式
白糖_
JSONObject

    项目中，经常会用JSONObject插件将JavaBean或List<JavaBean>转换为JSON格式的字符串，而JavaBean的属性有时候会有java.util.Date这个类型的时间对象，这时JSONObject默认会将Date属性转换成这样的格式：
 
{"nanos":0,"time":-27076233600000,
    

    • 

  • JavaScript语言精粹读书笔记
braveCS
JavaScript

    【经典用法】：
 
//①定义新方法
Function .prototype.method=function(name, func){
this.prototype[name]=func;
return this;
}
//②给Object增加一个create方法，这个方法创建一个使用原对
    

    • 

  • 编程之美-找符合条件的整数 用字符串来表示大整数避免溢出
bylijinnan
编程之美

    
import java.util.LinkedList;
public class FindInteger {
/**
* 编程之美 找符合条件的整数 用字符串来表示大整数避免溢出
* 题目：任意给定一个正整数N，求一个最小的正整数M(M>1)，使得N*M的十进制表示形式里只含有1和0
*
* 假设当前正在搜索由0，1组成的K位十进制数
    

    • 

  • 读书笔记
chengxuyuancsdn
读书笔记

    1、Struts访问资源
2、把静态参数传递给一个动作
3、<result>type属性
4、s:iterator、s:if c:forEach
5、StringBuilder和StringBuffer
6、spring配置拦截器
1、访问资源
(1)通过ServletActionContext对象和实现ServletContextAware,ServletReque
    

    • 

  • [通讯与电力]光网城市建设的一些问题
comsci
问题

    
      信号防护的问题,前面已经说过了,这里要说光网交换机与市电保障的关系
      我们过去用的ADSL线路,因为是电话线,在小区和街道电力中断的情况下,只要在家里用笔记本电脑+蓄电池,连接ADSL,同样可以上网........
    
    

    • 

  • oracle 空间RESUMABLE
daizj
oracle空间不足RESUMABLE错误挂起

    空间RESUMABLE操作  转
Oracle从9i开始引入这个功能，当出现空间不足等相关的错误时，Oracle可以不是马上返回错误信息，并回滚当前的操作，而是将操作挂起，直到挂起时间超过RESUMABLE TIMEOUT，或者空间不足的错误被解决。
这一篇简单介绍空间RESUMABLE的例子。
第一次碰到这个特性是在一次安装9i数据库的过程中，在利用D
    

    • 

  • 重构第一次写的线程池
dieslrae
线程池 python

    最近没有什么学习欲望,修改之前的线程池的计划一直搁置,这几天比较闲,还是做了一次重构,由之前的2个类拆分为现在的4个类.
1、首先是工作线程类:TaskThread,此类为一个工作线程,用于完成一个工作任务,提供等待(wait),继续(proceed),绑定任务(bindTask)等方法
#!/usr/bin/env python
# -*- coding:utf8 -*-

    

    • 

  • C语言学习六指针
dcj3sjt126com
c

    初识指针，简单示例程序：
/*
指针就是地址，地址就是指针
地址就是内存单元的编号
指针变量是存放地址的变量
指针和指针变量是两个不同的概念
但是要注意： 通常我们叙述时会把指针变量简称为指针，实际它们含义并不一样
*/
# include <stdio.h>
int main(void)
{
int * p; // p是变量的名字， int * 
    

    • 

  • yii2 beforeSave afterSave beforeDelete
dcj3sjt126com
delete

    public function afterSave($insert, $changedAttributes)
{
parent::afterSave($insert, $changedAttributes);
if($insert) {
//这里是新增数据
} else {
//这里是更新数据
}
}
 
    

    • 

  • timertask
shuizhaosi888
timertask

    java.util.Timer timer = new java.util.Timer(true);
// true 说明这个timer以daemon方式运行（优先级低，
// 程序结束timer也自动结束），注意，javax.swing
// 包中也有一个Timer类，如果import中用到swing包，
// 要注意名字的冲突。
TimerTask task = new
    

    • 

  • Spring Security（13）——session管理
234390216
sessionSpring Security攻击保护超时

    session管理
目录
 
1.1     检测session超时
1.2     concurrency-control
1.3     session 固定攻击保护
 
      
    

    • 

  • 公司项目NODEJS实践0.3[ mongo / session ...]
逐行分析JS源代码
mongodbsessionnodejs

       
http://www.upopen.cn
 
一、前言
        书接上回，我们搭建了WEB服务端路由、模板等功能，完成了register 通过ajax与后端的通信，今天主要完成数据与mongodb的存取，实现注册 / 登录 /
    

    • 

  • pojo.vo.po.domain区别
LiaoJuncai
javaVOPOJOjavabeandomain

    　　POJO = "Plain Old Java Object"，是MartinFowler等发明的一个术语，用来表示普通的Java对象，不是JavaBean, EntityBean 或者 SessionBean。POJO不但当任何特殊的角色，也不实现任何特殊的Java框架的接口如，EJB， JDBC等等。
　　
　　即POJO是一个简单的普通的Java对象，它包含业务逻辑
    

    • 

  • Windows Error Code
OhMyCC
windows

    0 操作成功完成.
1 功能错误.
2 系统找不到指定的文件.
3 系统找不到指定的路径.
4 系统无法打开文件.
5 拒绝访问.
6 句柄无效.
7 存储控制块被损坏.
8 存储空间不足, 无法处理此命令.
9 存储控制块地址无效.
10 环境错误.
11 试图加载格式错误的程序.
12 访问码无效.
13 数据无效.
14 存储器不足, 无法完成此操作.
15 系
    

    • 

  • 在storm集群环境下发布Topology
roadrunners
集群stormtopologyspoutbolt

    storm的topology设计和开发就略过了。本章主要来说说如何在storm的集群环境中，通过storm的管理命令来发布和管理集群中的topology。
 
1、打包
打包插件是使用maven提供的maven-shade-plugin，详细见maven-shade-plugin。
<plugin>
<groupId>org.apache.maven.
    

    • 

  • 为什么不允许代码里出现“魔数”
tomcat_oracle
java

    　　在一个新项目中，我最先做的事情之一，就是建立使用诸如Checkstyle和Findbugs之类工具的准则。目的是制定一些代码规范，以及避免通过静态代码分析就能够检测到的bug。 　　迟早会有人给出案例说这样太离谱了。其中的一个案例是Checkstyle的魔数检查。它会对任何没有定义常量就使用的数字字面量给出警告，除了-1、0、1和2。 　　很多开发者在这个检查方面都有问题，这可以从结果
    

    • 

  • zoj 3511 Cake Robbery(线段树)
阿尔萨斯
线段树

     题目链接：zoj 3511 Cake Robbery
题目大意：就是有一个N边形的蛋糕，切M刀，从中挑选一块边数最多的，保证没有两条边重叠。
解题思路：有多少个顶点即为有多少条边，所以直接按照切刀切掉点的个数排序，然后用线段树维护剩下的还有哪些点。
#include <cstdio>
#include <cstring>
#include <vector&
    

    •