一只老实的程序猿
一只老实的程序猿

bean加载三：bean创建

接下来以单例模式为例，一起看看在前面那么多的准备工作后，现在是如何创建 bean 对象的。

if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, () -> {
        try {
            return createBean(beanName, mbd, args);
        }
        catch (BeansException ex) {
            // Explicitly remove instance from singleton cache: It might have been put there
            // eagerly by the creation process, to allow for circular reference resolution.
            // Also remove any beans that received a temporary reference to the bean.
            // 显式从单例缓存中删除 Bean 实例
            // 因为单例模式下为了解决循环依赖，可能他已经存在了，所以销毁它
            destroySingleton(beanName);
            throw ex;
        }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

7.1 getSingleton

public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    synchronized (this.singletonObjects) {
        // 从缓存中检查一遍
        // 因为 singleton 模式其实就是复用已经创建的 bean 所以这步骤必须检查
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            // 如果当前单例对象正在销毁
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName,
                        "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                        "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
            }
            // 加载前置处理，校验beanName没有正在创建
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
                // 获取单例对象
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {
                // Has the singleton object implicitly appeared in the meantime ->
                // if yes, proceed with it since the exception indicates that state.
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            }
            catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            }
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                // 后置处理
                afterSingletonCreation(beanName);
            }
            // 加入缓存中
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}

核心的还是 singletonFactory.getObject

7.2 createBean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {

    if (logger.isTraceEnabled()) {
        logger.trace("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;

    // 确保此时的 bean 已经被解析了
    // 如果获取的class 属性不为null，则克隆该 BeanDefinition
    // 主要是因为该动态解析的 class 无法保存到到共享的 BeanDefinition
    Class resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    try {
        // 验证 lookup-method 和 replace-method 配置
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        // 实例化的前置处理
        // 给 BeanPostProcessors 一个机会用来返回一个代理类而不是真正的类实例
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                "BeanPostProcessor before instantiation of bean failed", ex);
    }

    try {
        // 创建 Bean 对象
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }
    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        // A previously detected exception with proper bean creation context already,
        // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
}

这里有两个核心逻辑

7.2.1 resolveBeforeInstantiation

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                // 前置
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    // 后置
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

这里的前置处理指的是执行类型为InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法，用于在对象实例化之前返回方法中设置的值，会跳过接下来的对象实例化、初始化流程。

protected Object applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        // 找到类型为 InstantiationAwareBeanPostProcessor 的 BeanPostProcessor
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}

后置处理指得是获取 BeanPostProcessor 数组，执行 postProcessAfterInitialization 方法

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    // 获取 BeanPostProcessor 数组
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 循环调用 postProcessAfterInitialization 方法，如果为空立即返回
        Object current = processor.postProcessAfterInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

7.2.2 doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    throws BeanCreationException {

  // Instantiate the bean.
  // BeanWrapper 是对 Bean 的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装 bean 的属性描述器
  BeanWrapper instanceWrapper = null;
  // 单例模型，则从未完成的 FactoryBean 缓存中删除
  if (mbd.isSingleton()) {
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  }
  // 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化
  if (instanceWrapper == null) {
    instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
  // 包装的实例对象
  final Object bean = instanceWrapper.getWrappedInstance();
  // 包装的实例对象的类型
  Class beanType = instanceWrapper.getWrappedClass();
  if (beanType != NullBean.class) {
    mbd.resolvedTargetType = beanType;
  }

  // Allow post-processors to modify the merged bean definition.
  // 判断是否有后置处理
  // 如果有后置处理，则允许后置处理修改 BeanDefinition
  synchronized (mbd.postProcessingLock) {
    if (!mbd.postProcessed) {
      try {
        applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
      }
      catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Post-processing of merged bean definition failed", ex);
      }
      mbd.postProcessed = true;
    }
  }

  // Eagerly cache singletons to be able to resolve circular references
  // even when triggered by lifecycle interfaces like BeanFactoryAware.
  // 解决单例循环依赖
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
  if (earlySingletonExposure) {
    if (logger.isTraceEnabled()) {
      logger.trace("Eagerly caching bean '" + beanName +
          "' to allow for resolving potential circular references");
    }
    // 提前将创建的 bean 实例加入到 singletonFactories 中
    // 这里是为了后期避免循环依赖
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  }

  // Initialize the bean instance.
  // 开始初始化 bean 实例对象
  Object exposedObject = bean;
  try {
    // 对 bean 进行填充，将各个属性值注入，其中，可能存在依赖于其他 bean 的属性
    // 则会递归初始依赖 bean
    populateBean(beanName, mbd, instanceWrapper);
    // 调用初始化方法
    exposedObject = initializeBean(beanName, exposedObject, mbd);
  }
  catch (Throwable ex) {
    if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
      throw (BeanCreationException) ex;
    }
    else {
      throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    }
  }

  // 循环依赖处理
  if (earlySingletonExposure) {
    Object earlySingletonReference = getSingleton(beanName, false);
    // 只有在存在循环依赖的情况下，earlySingletonReference 才不会为空
    if (earlySingletonReference != null) {
      // 如果 exposedObject 没有在初始化方法中被改变，也就是没有被增强
      if (exposedObject == bean) {
        exposedObject = earlySingletonReference;
      }
      // 处理依赖
      else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
        String[] dependentBeans = getDependentBeans(beanName);
        Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
        for (String dependentBean : dependentBeans) {
          if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
            actualDependentBeans.add(dependentBean);
          }
        }
        if (!actualDependentBeans.isEmpty()) {
          throw new BeanCurrentlyInCreationException(beanName,
              "Bean with name '" + beanName + "' has been injected into other beans [" +
              StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
              "] in its raw version as part of a circular reference, but has eventually been " +
              "wrapped. This means that said other beans do not use the final version of the " +
              "bean. This is often the result of over-eager type matching - consider using " +
              "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
        }
      }
    }
  }

  // Register bean as disposable.
  // 注册 bean
  try {
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
  }
  catch (BeanDefinitionValidationException ex) {
    throw new BeanCreationException(
        mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  }

  return exposedObject;
}

这个方法主要包括几个部分：
1.通过 createBeanInstance 获取 bean 实例对象
2.执行 MergedBeanDefinitionPostProcessors 类型的BeanPostProcessors，MergedBeanDefinitionPostProcessors 又一个很重要的实现类 AutowiredAnnotationBeanPostProcessor 实现了@Autowired和@Value注解
3.初始化对象，填充依赖
4.处理依赖
5.注册bean
接下来一部分一部分的看一下

7.2.2.1 createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // Make sure bean class is actually resolved at this point.
    // 解析 bean ，将 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());
    }

    // 如果存在 Supplier 回调，则使用给定的回调方法初始化策略
    Supplier instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }

    // 使用 FactoryBean 的 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) {
            // 如果已缓存的解析的构造函数或者工厂方法不为空，则可以利用构造函数解析
            // 因为需要根据参数确认到底使用哪个构造函数，该过程比较消耗性能，所有采用缓存机制
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    // 已经解析好了，直接注入即可
    if (resolved) {
        // autowire 自动注入，调用构造函数自动注入
        if (autowireNecessary) {
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            // 使用默认构造函数构造
            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?
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }

    // No special handling: simply use no-arg constructor.
    return instantiateBean(beanName, mbd);
}

实例化bean是一个很复杂的过程，总的来说有4种方式获取bean实例：

  • 如果存在 Supplier 回调，则调用 obtainFromSupplier() 进行初始化
  • 如果存在工厂方法，则使用工厂方法进行初始化
  • 指定的构造函数
  • 默认的构造函数
    下面简单分析下这4种情况：

1.Supplier 回调

对应的代码是

Supplier instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }
}

接下来继续看 obtainFromSupplier 方法

protected BeanWrapper obtainFromSupplier(Supplier instanceSupplier, String beanName) {
    Object instance;
    // 判断 beanName 对应的实例对象是否正在创建中
    String outerBean = this.currentlyCreatedBean.get();
    this.currentlyCreatedBean.set(beanName);
    try {
        // 调用 Supplier 的 get()，返回一个对象
        instance = instanceSupplier.get();
    }
    finally {
        if (outerBean != null) {
            this.currentlyCreatedBean.set(outerBean);
        }
        else {
            this.currentlyCreatedBean.remove();
        }
    }

    if (instance == null) {
        instance = new NullBean();
    }
    // 根据对象构造 BeanWrapper 对象
    BeanWrapper bw = new BeanWrapperImpl(instance);
    // 初始化 BeanWrapper
    initBeanWrapper(bw);
    return bw;
}

2. instantiateUsingFactoryMethod

ps：instantiateUsingFactoryMethod 方法体实在是太大了，这里害怕自己分析的不够清晰。推荐一篇文章。我会把 instantiateUsingFactoryMethod 拆分开，分析一些重要的逻辑，接下来就开始。

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

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

这里首先构造了一个 ConstructorResolver 对象，ConstructorResolver 可以理解为beanFactory的委托类，委托它来完成实例对象的创建和初始化。

2.1 BeanWrapperImpl

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

2.2 找到实例化方法

什么是实例工厂和静态工厂

// 有工厂名
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 (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
    throw new ImplicitlyAppearedSingletonException();
  }
  factoryClass = factoryBean.getClass();
  isStatic = false;
}
else {
  // 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;
}

2.3 找到实例化方法对应参数

// 1.调用getBean时传递的参数不为空
if (explicitArgs != null) {
  argsToUse = explicitArgs;
}
// 2.在本方法最后保存的缓存
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;
      }
    }
  }
  // 转换缓存中的参数类型，比如将 "1" -> 1
  if (argsToResolve != null) {
    argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
  }
}

2.4 寻找合适的实例化方法

// 获取工厂方法的类全名称
factoryClass = ClassUtils.getUserClass(factoryClass);
// 获取所有待定方法
List candidateList = null;
if (mbd.isFactoryMethodUnique) {
  if (factoryMethodToUse == null) {
    factoryMethodToUse = mbd.getResolvedFactoryMethod();
  }
  if (factoryMethodToUse != null) {
    candidateList = Collections.singletonList(factoryMethodToUse);
  }
}
if (candidateList == null) {
  candidateList = new ArrayList<>();
  // 检索所有方法，这里是对方法进行过滤
  Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
  for (Method candidate : rawCandidates) {
    // 如果有static 且为工厂方法，则添加到 candidateSet 中
    if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
      candidateList.add(candidate);
    }
  }
}

// 如果方法唯一且输入参数为空且配置文件中没有配置参数，直接创建对象并且返回
if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
  Method uniqueCandidate = candidateList.get(0);
  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;
  }
}

2.5 解析构造函数的参数

Method[] candidates = candidateList.toArray(new Method[0]);
// 排序，public方法在其他类型方法之前，public根据参数多少倒排
AutowireUtils.sortFactoryMethods(candidates);

// 用于承载解析后的构造函数参数的值
ConstructorArgumentValues resolvedValues = null;
boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set ambiguousFactoryMethods = null;

int minNrOfArgs;
if (explicitArgs != null) {
    minNrOfArgs = explicitArgs.length;
}
else {
    // getBean() 没有传递参数，则需要解析保存在 BeanDefinition 构造函数中指定的参数
    if (mbd.hasConstructorArgumentValues()) {
        ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
        resolvedValues = new ConstructorArgumentValues();
        // 解析构造函数的参数
        // 将该 bean 的构造函数参数解析为 resolvedValues 对象，其中会涉及到其他 bean
        minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
    }
    else {
        minNrOfArgs = 0;
    }
}

2.6 选择合适的构造函数

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

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

        // getBean()传递了参数
        if (explicitArgs != null) {
            // Explicit arguments given -> arguments length must match exactly.
            if (paramTypes.length != explicitArgs.length) {
                continue;
            }
            argsHolder = new ArgumentsHolder(explicitArgs);
        }
        else {
            // 为提供参数，解析构造参数
            try {
                String[] paramNames = null;
                // 获取 ParameterNameDiscoverer 对象
                // ParameterNameDiscoverer 是用于解析方法和构造函数的参数名称的接口，为参数名称探测器
                ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                if (pnd != null) {
                    // 获取指定构造函数的参数名称
                    paramNames = pnd.getParameterNames(candidate);
                }
                // 在已经解析的构造函数参数值的情况下，创建一个参数持有者对象
                argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
                        paramTypes, paramNames, candidate, autowiring, candidates.length == 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;
            }
        }

        // isLenientConstructorResolution 判断解析构造函数的时候是否以宽松模式还是严格模式
        // 严格模式：解析构造函数时，必须所有的都需要匹配，否则抛出异常
        // 宽松模式：使用具有"最接近的模式"进行匹配
        // typeDiffWeight：类型差异权重
        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.getParameterCount() &&
                !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
            if (ambiguousFactoryMethods == null) {
                ambiguousFactoryMethods = new LinkedHashSet<>();
                ambiguousFactoryMethods.add(factoryMethodToUse);
            }
            ambiguousFactoryMethods.add(candidate);
        }
    }
}

2.7 校验与缓存

// 没有可执行的工厂方法，抛出异常
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);
    // getBean()传入的参数不为空
    if (explicitArgs != null) {
        for (Object arg : explicitArgs) {
            argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
        }
    }
    // BeanDefinition 中的参数类型
    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);
}

到此通过FactoryBean获取对象实例就分析完了

3. autowireConstructor（指定的构造函数）

与第二种大同小异，方法体也十分的长。总的来说就是：寻找合适的构造函数和构造函数的参数，然后使用不同的策略初始化bean对象。

4.instantiateBean（默认的构造函数）

这个就比较简单了

回到AbstractAutowireCapableBeanFactory.doCreateBean中

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
    if (logger.isTraceEnabled()) {
        logger.trace("Eagerly caching bean '" + beanName +
                "' to allow for resolving potential circular references");
    }
    // 提前将创建的 bean 实例加入到 singletonFactories 中
    // 这里是为了后期避免循环依赖
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

addSingletonFactory用于添加FactoryBean到三级缓存中，getEarlyBeanReference用于解决在循环依赖的情况下AOP代理类的提前暴露问题。
接下来继续看populateBean给对象做属性填充

7.2.2.2 populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // 没有实例化对象
    if (bw == null) {
        // 有属性，则抛出 BeanCreationException 异常
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
        }
        else {
            // Skip property population phase for null instance.
            return;
        }
    }

    // 在设置属性之前给 InstantiationAwareBeanPostProcessors 最后一次改变 bean 的机会
    boolean continueWithPropertyPopulation = true;

    if (!mbd.isSynthetic() // bean 不是"合成"的，即未由应用程序本身定义
            && hasInstantiationAwareBeanPostProcessors()) { // // 是否持有 InstantiationAwareBeanPostProcessor
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }

    // 如果后续处理器发出停止填充命令，则终止后续操作
    if (!continueWithPropertyPopulation) {
        return;
    }

    // bean 的属性值
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    // 自动注入
    int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        // 将 PropertyValues 封装成 MutablePropertyValues 对象
        // MutablePropertyValues 允许对属性进行简单的操作，并提供构造函数以支持Map的深度复制和构造。
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // Add property values based on autowire by name if applicable.
        // 根据名称自动注入
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // Add property values based on autowire by type if applicable.
        // 根据类型自动注入
        if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }

    // 是否已经注册了 InstantiationAwareBeanPostProcessors
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    // 是否需要进行【依赖检查】
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        // 遍历 BeanPostProcessor 数组
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 对所有需要依赖检查的属性进行后处理
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    // 从 bw 对象中提取 PropertyDescriptor 结果集
                    // PropertyDescriptor：可以通过一对存取方法提取一个属性
                    if (filteredPds == null) {
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }
                }
                pvs = pvsToUse;
            }
        }
    }
    // 依赖检查
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        // 依赖检查，对应 depends-on 属性
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }

    // 将属性应用到 bean 中
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

主要的逻辑：
1.根据 hasInstantiationAwareBeanPostProcessors 属性来判断是否需要在注入属性之前给 InstantiationAwareBeanPostProcessors 最后一次改变 bean 的机会，此过程可以控制 Spring 是否继续进行属性填充。
2.根据注入类型的不同来判断是根据名称来自动注入（autowireByName()）还是根据类型来自动注入（autowireByType()），统一存入到 PropertyValues 中，PropertyValues 用于描述 bean 的属性。
3.判断是否需要进行 BeanPostProcessor 和 依赖检测。
4.将所有 PropertyValues 中的属性填充到 BeanWrapper 中。
第一步比较简单，这里就不详细介绍了

7.2.2.2.1 autowireByName

protected void autowireByName(
        String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

    // 对 Bean 对象中非简单属性
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        // 如果容器中包含指定名称的 bean，则将该 bean 注入到 bean中
        if (containsBean(propertyName)) {
            // 递归获取相关 bean
            Object bean = getBean(propertyName);
            // 为指定名称的属性赋予属性值
            pvs.add(propertyName, bean);
            // 属性依赖注入
            registerDependentBean(propertyName, beanName);
            if (logger.isTraceEnabled()) {
                logger.trace("Added autowiring by name from bean name '" + beanName +
                        "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
            }
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                        "' by name: no matching bean found");
            }
        }
    }
}

7.2.2.2.2 autowireByType

protected void autowireByType(
        String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

    // 获取 TypeConverter 实例
    // 使用自定义的 TypeConverter，用于取代默认的 PropertyEditor 机制
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
        converter = bw;
    }

    Set autowiredBeanNames = new LinkedHashSet<>(4);
    // 获取非简单属性
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        try {
            // 获取 PropertyDescriptor 实例
            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
            // 不要尝试按类型
            if (Object.class != pd.getPropertyType()) {
                // 探测指定属性的 set 方法
                MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
                DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                // 解析指定 beanName 的属性所匹配的值，并把解析到的属性名称存储在 autowiredBeanNames 中
                // 当属性存在过个封装 bean 时将会找到所有匹配的 bean 并将其注入
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                if (autowiredArgument != null) {
                    pvs.add(propertyName, autowiredArgument);
                }
                // 迭代方式注入 bean
                for (String autowiredBeanName : autowiredBeanNames) {
                    registerDependentBean(autowiredBeanName, beanName);
                    if (logger.isTraceEnabled()) {
                        logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
                                propertyName + "' to bean named '" + autowiredBeanName + "'");
                    }
                }
                autowiredBeanNames.clear();
            }
        }
        catch (BeansException ex) {
            throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
        }
    }
}

继续回到doCreateBean方法中

7.2.2.3 initializeBean

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) { // 安全模式
        AccessController.doPrivileged((PrivilegedAction) () -> {
            // 激活 Aware 方法，对特殊的 bean 处理：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        invokeAwareMethods(beanName, bean);
    }

    // 后处理器，before
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    // 激活用户自定义的 init 方法
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }
    // 后处理器，after
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}


这里的前置处理和后置处理，就是执行BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法，就是在这个地方，通过实现BeanPostProcessor接口从而实现了AOP功能，invokeInitMethods方法在下一篇文章中分析。


2.7.2.2.4 处理循环依赖


if (earlySingletonExposure) {
    Object earlySingletonReference = getSingleton(beanName, false);
    // 只有在存在循环依赖的情况下，earlySingletonReference 才不会为空
    if (earlySingletonReference != null) {
        // 如果 exposedObject 没有在初始化方法中被改变，也就是没有被增强
        if (exposedObject == bean) {
            exposedObject = earlySingletonReference;
        }
        // 处理依赖
        else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
            String[] dependentBeans = getDependentBeans(beanName);
            Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
            for (String dependentBean : dependentBeans) {
                if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                    actualDependentBeans.add(dependentBean);
                }
            }
            if (!actualDependentBeans.isEmpty()) {
                throw new BeanCurrentlyInCreationException(beanName,
                        "Bean with name '" + beanName + "' has been injected into other beans [" +
                        StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                        "] in its raw version as part of a circular reference, but has eventually been " +
                        "wrapped. This means that said other beans do not use the final version of the " +
                        "bean. This is often the result of over-eager type matching - consider using " +
                        "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
            }
        }
    }
}



到此bean的创建过程就分析完成了
























你可能感兴趣的:(bean加载三：bean创建)






    

  • 美易官方：盘前道指期货涨0.5%，游戏驿站跌逾15%
美股投资
财经人工智能大数据新浪微博微信微信公众平台百度金融

    在股市开盘前的交易时段，道指期货上涨了0.5%，而游戏驿站（GameStop）的股价却出现了大幅下跌，跌幅超过15%。这一市场动态引发了投资者的广泛关注，也反映了当前股市的复杂性和不确定性。美股股指期货周三盘前走强，交易员为季度末的再平衡做准备。本周因假期而缩短，美国将公布关键通胀数据。道指期货涨0.5%，标普500指数期货涨0.6%，纳指期货涨0.5%。德国DAX指数涨0.4%，英国富时100指
    

    • 

  • 【Python】一文详细介绍 py格式 文件
高斯小哥
Python基础【高质量合集】python新手入门学习

    【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
    

    • 

  • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情
迷影咖啡

    作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
    

    • 

  • 迎接2019
唯有杜康1994

    告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
    

    • 

  • 植物小记
番茄秧子

    小时候，我养过一院子的花。今年，我重新开始从头开始养一点儿植物。别人说那也只是别人说临到快过年，我逛了一趟花市，买了两棵水仙花。路过另外一个卖水仙的摊位，霸气的卖花小妹瞧了一眼我捧着的那两棵弱小，说了一句：“你那个水仙不行，都不会开花的。”以我的脾气，这当然不能相信啊。结果，带回家好几天没动静。某一天早晨起来，两棵水仙悄不吭声全开了，然后香了屋子好多天。水仙三月，我在花市扛了一盆栀子花，花店老板见
    

    • 

  • 被隔离的日子（五）@三七会写作营
三七会萍海临风

    从隔离的初期，我们三人都不适应，彼此说话都还火药味十足。后随着时间的推移，到现在，我们仨人能够心平气和，幽默地对待彼此。看来，时间可真是个好东西，不仅能见证一个人的心性，还能看清自己的需求、他人的本质。今天晚上，孩子跑到厨房，告诉我她给人捐款了。我纳闷，不是给河南捐过款了么。当时，我还落后于她捐的呢。这次又捐给谁？看到我一脸狐疑，孩子说，还记得初四给她补课的那个男老师么？当让记得，当时，就因为是男
    

    • 

  • 教育微创新的意蕴
知北老师

    我是1992年参加工作的，一毕业就被分配到一所全县最偏僻落后的农村学校——付窝中学，12年后被调往一所已经连续十年全县倒数第一，也是很偏僻落后的农村学校——北宋镇第三中学。三年后到了北宋镇第一中学工作，这所学校教学质量也是连续几年落后了。2014年我到了北京市育英学校，这所学校是京城名校。2016年7月，我被育英学校派往原密云区第七中学工作，这是一所城乡接合部薄弱学校。学校现名为北京市育英学校密云
    

    • 

  • 2022年河南省高等职业教育技能大赛云计算赛项竞赛赛卷（样卷）
忘川_ydy
云计算云计算openstackkubernetesdockerpythonk8sansible

    #需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！第一部分：私有云任务1私有云服务搭建(10分)使用提供的用户名密码，登录竞赛用的云计算平台，按要求自行使用镜像创建两台云主机，创建完云主机后确保网络正常通信，然后按要求配置服务器。根据提供安装脚本框架，补充脚本完成OpenStack平台的安装搭
    

    • 

  • 通俗易懂：MySQL中如何设置只读实例并确保数据一致性？
大龄下岗程序员
mysqljavamysqlspring

    在MySQL中设置只读实例主要应用于构建高可用性和扩展性的数据库环境，通常是为了分担读取负载或者用于备份和灾难恢复。以下是创建MySQL只读实例并确保数据一致性的基本步骤：1.创建并配置只读实例-主从复制设置-首先，你需要有一个主数据库实例（Master）负责接收所有的写操作。-创建一个或多个从数据库实例（Slave），并将它们配置为主数据库的复制品。这通常通过设置主从复制（Replication
    

    • 

  • word字号和mathtype磅值关系及批量修改
小铁匠-Ma
office小技巧经验分享

    word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • 为什么说仪式和习惯非常重要？
章鱼老师zy

    这是章鱼姐第【40】篇原创文章，日更计划第【37/100】天。阅读张萌萌姐【精力管理手册】第【6/7】章。一阅读摘要这一章萌姐讲到了习惯的重要性，为什么说养成一个习惯很重要？如何养成一个好习惯？如何建立自己的仪式感？二金句精力管理最重要的是产生什么效果。当你想做却没有动力去做一件事情时，你就应该把它养成习惯。习惯可以帮我们创造稳定框架。对于那些特别考验意志的事情，我们应该先行后思。三思考题，萌姐讲
    

    • 

  • 第一章 山洞传来牛铃声
满眼荷花

    春夏时节，田野一片青碧，山林薄雾蔼蔼，水草萋萋的小河边静静立着一只白鹭，像一位白头钓翁，在耐心地等鱼。王三乐牵着一头老黄牛，正在河边田埂上放牛。看见白鹭，他百无聊赖地捡起一块小石头扔了过去。白鹭动作舒缓、姿势优美地飞起避过，在空中飞行一段后，宛若晴空一片云，翩然而下，又静静立于河边青草间，继续呈现完美的画面。王三乐也觉得自己很无聊，这也难怪，从他记事起就开始放牛，一直到现在都大学毕业了，还没丢下放
    

    • 

  • 12-25
yummy0632

    72.4kg早饭：一碗面条，俩鸡蛋，三个砂糖桔。五天过去了，这本书我听完了。哈哈简直了。真兴奋，我准备好了，迎接新的自己。午饭：一个花卷，一碗汤，一份油菜，一份冬瓜粉条，一份红烧肉。晚饭：一个花卷，一份芹菜，一份土豆，一份鸭子。很咸。
    

    • 

  • 以前开发MFC界面如何快速转成QT界面
广州视觉芯软件有限公司
mfcqtc++

    将MFC界面快速转换为Qt界面可能需要进行一些手动工作，因为MFC和Qt是两个不同的界面框架，它们具有不同的设计和实现原理。但是，以下步骤可以帮助你快速进行转换：创建一个新的Qt项目：使用QtCreator创建一个新的Qt项目。分析MFC界面：仔细分析你的MFC界面，包括窗口、对话框、控件等的布局、样式和行为。重新设计界面：使用Qt的可视化设计器重新设计界面。在QtCreator的设计器中，你可以
    

    • 

  • 2022-10-02
朗月斋主

    肿瘤溶解病毒（OVs）作为一种新型的免疫治疗和治疗辅助剂，在制药行业中越来越受到关注，因为它们能够通过多种机制诱导和提高抗肿瘤免疫力。首先，OVs能够利用宿主免疫系统的内在机制（例如，逃避免疫检测）可以使肿瘤的免疫逃逸机制失效。第二，许多类型的OVs已被证明可以直接裂解肿瘤细胞，从而诱导出由肿瘤相关抗原和危险信号分子释放介导的肿瘤特异性T细胞反应。第三，表达免疫刺激治疗基因的武装OV可以在肿瘤组织
    

    • 

  • 1.计算机处理器架构+嵌入式处理器架构及知识
vv 啊
arm-linux学习linux系统架构

    目录一：x86-64处理器架构二：Intel80386处理器（i386）1.i3862.i686三：嵌入式Linux知识：1.MinGW2.GNU计划2.1GNU工具链概述此次只分享英特尔和ADM处理器有关于x86的架构，至于嵌入式处理器架构请查看https://en.wikipedia.org/wiki/List_of_ARM_processors一：x86-64处理器架构x86-64，也称为x
    

    • 

  • 夫子庙前的金子招牌
光中的cici

    古城都不乏老招牌，比如苏杭，比如南京。随便一个都有久远的年代。夫子庙前，乌衣巷口，店肆成市招牌林立繁华重归来。难为我一个外地人，究竟该喝谁家的那碗鸭血粉丝汤呢？在网上研究了半天，选了秦淮人家。只因为三点：一，临河就着秦淮河喝鸭血汤就着秦淮河喝鸭血汤二，装修较其他一溜大白墙的店算讲究的了，我特别吃环境，没办法～三，有鸭血汤鸭血汤倒是有，夹杂在一套所谓的套餐里，不允许单独点菜。我是为了这秦淮河买的单，
    

    • 

  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】
还算善良_
私有代码库工具类javalist数据结构

    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
    

    • 

  • 浙江女大学生“卖淫日记”曝光，震惊全网：背后还藏着一个真相
地球上的星星_272e

    作者/在风来源/微信公众号：自黑思维最近，一个新闻震碎无数人的三观：在浙江农林大学，有一位女大学生，在网上公开自己的“卖淫日记”，无论是文字还是图片，都非常露骨。而目前关于这事的瓜，都已经被删得七七八八，但我有保留截图的习惯，所以才有了这篇文章。首先，必须要强调的一点，就是这事不是谣传，是真的，学校已经出来证实过。只是学校表示该名女学生有精神病。但到底是不是真的精神有问题？我们可以从她的日记里，略
    

    • 

  • 常用API---初始化，话题和服务对象创建，回旋/头函数，时间（如：获取当前时刻，持续时间执行频率，休眠，定时器等），运行频率，定时器，节点生命周期，日志相关API
李卓璐
机器人人工智能c++

    初始化ROS节点ros::init(argc,argv,“name”,options);作用：ros初始化函数参数： 1.argc—封装实参的个数（n+1个->有一个是自身）； 2.argv—封装参数的数组； 3.name—为节点命名（唯一性）； 4.options—节点启动项，解决节点重名问题。返回值：void使用： 1.argc和argv的使用：  如果按照ROS中的特定格式传入实参，那么RO
    

    • 

  • 2021.12.13 自律日记
夏舒帅然a

    深感时光转瞬即逝，如指缝流金！自律、习惯养成、执行力提高迫在眉睫！今天是什么日子：平日艳阳天起床：7：50任务清单（明日）1.起床：7:302.就寝：10：103.读书30分钟4.打两套太极5.两次静坐（每次15分钟）昨日完成的任务情况，最重要的三件事一.读书30分。未完成二.就寝10：00完成三.起床7：30未完成四.打两套太极未完成五.两次静坐（每次15分钟）未完成习惯养成：早睡早起、每日读书
    

    • 

  • ChatGPT一路狂飙？
何鲸洛

    2月2日。根据投行瑞银集团在周三发布的一份研究报告。爆红聊天机器人ChatGPT的月活跃用户在今年1月份预计达到了1亿，这距离它推出只有2个月时间，成为史上增长最快的消费者应用。①ChatGPT一路火花带闪电？▽2014年。OpenAI创始人SamAltman早年曾执掌著名的硅谷孵化器YCombinator。2015年。Altman联合马斯克、彼得·泰尔、AWS、印度Infosys和YC等作为出资
    

    • 

  • 【美丽特色乡村】，景德镇马鞍岭村，
粒子飞翔

    【美丽特色乡村】，景德镇马鞍岭村，就像是陶渊明笔下的山水田园，阡陌交通，精美的白房参差错落，碧绿透亮的河水从不远处的深涧里连绵不绝流入此地，滋养着土里。成群的白鸭悠闲地在河水里戏水，人与环境达成和谐的境界。借助三宝国际瓷谷建设的契机，马鞍岭村迎来了天翻地覆的沧桑巨变,此地以陶瓷文化为特色，融合原来生态资源，修复了水碓遗址、矿坑遗址等历史文化遗产，提升生态环境现状。同时，依托三宝溪围绕整个村落，对河
    

    • 

  • yarn的安装和使用全网最详细教程
zxj19880502
yarnnpm

    一、yarn的简介：Yarn是facebook发布的一款取代npm的包管理工具。二、yarn的特点：速度超快。Yarn缓存了每个下载过的包，所以再次使用时无需重复下载。同时利用并行下载以最大化资源利用率，因此安装速度更快。超级安全。在执行代码之前，Yarn会通过算法校验每个安装包的完整性。超级可靠。使用详细、简洁的锁文件格式和明确的安装算法，Yarn能够保证在不同系统上无差异的工作。三、yarn的
    

    • 

  • 喝酒给500红包，大家讨论一下微信报单好还是传真报单好？
践侠客

    2018年6月2日，L1组编号8号，日精进第65天，（文/胡鼎峰）昨天又和客户一起吃饭喝酒了，尽管最后的结果是蛮好的，但是因为喝酒我昨天又断更了，这对于习惯了每天写作日更的我来说，体验非常地差。早上三点就早早醒过来，想要爬起来写文章，但是头脑因为酒精的作用依然是昏昏沉沉，于是在半梦半醒之间熬到了天亮。对于我来说，日更是现在最重要的事情，虽然我也不知道我日更到底是为了什么，但是就是隐隐地觉得自己必须
    

    • 

  • 哪种生活容易？不过是事在人为和听天由命
华板扣

    提起不打卡、无考核的工作应该是非常让人羡慕吧！我已经上了三个月这样的班了，我想说自由的工作真的不那么自由，因为不打卡也就没有上下班区分，无考勤那是因为有收入，能在市场上存活下去才是这份工作的价值。不能只考虑自己的专业，因为只提专业目前并不能变成钱，可能这就是商业的残酷性。三个月前我其实并没有考虑清楚究竟是我选择了这份工作，还是这份工作选择了我，但现在我发现其实是我需要这份工作。我就像皮筋一样给了自
    

    • 

  • 买莆田鞋的app软件，三大app莆田鞋平台推荐给大家
腕表鞋屋

    买莆田鞋的app软件，三大app莆田鞋平台推荐给大家，如毒app、亚马逊、潮鞋之家、鞋子货源app、淘宝等app都非常的好用，还有更多的可以购买莆田鞋子，莆田鞋在哪个app买好用，下面一起看看。微信:pt188x(下单赠送精美礼品)买莆田鞋的三大app软件：一、淘宝app。买莆田鞋当然少不了淘宝，建议大家不要直接去搜索莆田鞋，那样给出的结果是很少的。大家看上哪款鞋子的型号直接去搜索就可以了，然后按
    

    • 

  • 2022-2-13晨间日记
越亮也打烊

    今天是什么日子起床：7:00就寝：12:08天气：晴心情：糟糕纪念日：无任务清单昨日完成的任务，最重要的三件事：寒假作业，网课，画画改进：作业时间剪短习惯养成：网课不逃～周目标·完成进度数学卷子100％学习·信息·阅读《傅雷家书》《钢铁是怎样炼成的》健康·饮食·锻炼我终于不喝饮料啦，喝茶～人际·家人·朋友邝姐姐带我吃火锅工作·思考啥时候开学，我还有几天赶完作业最美好的三件事1.卷子写完了2.我有冰
    

    • 

  • 直返APP所属的公司是何时成立的?它的发展历程和业务范围
好项目高省

    直返APP为我们带来了返利购物的便利，那么这款APP所属的公司是如何成立的呢？它的背后又有怎样的发展历程和业务范围呢？让我们一起探寻。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，是2021年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。高省是公认的返利最高的软件。古楼导师高省邀请码5558
    

    • 

  • 解线性方程组
qiuwanchi

    package gaodai.matrix;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Sc
    

    • 

  • 在mysql内部存储代码
annan211
性能mysql存储过程触发器

    
在mysql内部存储代码
在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。
先看优点：
1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。
2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。
3 可以简化代码的维护和版本更新。
4 可以帮助提升安全，比如提供更细
    

    • 

  • Android使用Asynchronous Http Client完成登录保存cookie的问题
hotsunshine
android

    Asynchronous Http Client是android中非常好的异步请求工具
除了异步之外还有很多封装比如json的处理，cookie的处理
引用
Persistent Cookie Storage with PersistentCookieStore
This library also includes a PersistentCookieStore whi
    

    • 

  • java面试题
Array_06
java面试

    java面试题
第一，谈谈final, finally, finalize的区别。
final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
    

    • 

  • 网站加速
oloz
网站加速

    前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教.
1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。
2、采用Gzip对网页进行压缩；
   GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
    

    • 

  • 正确书写单例模式
随意而生
java 设计模式 单例

    　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。
　　懒汉式，线程不安全
　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
    

    • 

  • 单例模式
香水浓
java

    懒汉  调用getInstance方法时实例化
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if(null == ins
    

    • 

  • 安装Apache问题：系统找不到指定的文件 No installed service named "Apache2"
AdyZhang
apachehttp server

    安装Apache问题：系统找不到指定的文件 No installed service named "Apache2"
每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。
解决方法确保几处：
1、停止IIS启动
2、把端口80改成其它 （譬如90，800，，，什么数字都好）
3、防火墙(关掉试试)
在运行处输入 cmd 回车，转到apa
    

    • 

  • 如何在android 文件选择器中选择多个图片或者视频？
aijuans
android

    我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传
但是android原生态的sdk中，只能一个一个的进行选择和上传。
我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个 处理方法
官方的图片选择器(但是不支持所有版本的androi，只支持API Level 
    

    • 

  • mysql中查询生日提醒的日期相关的sql
baalwolf
mysql

    SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(),  dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
    

    • 

  • MongoDB索引文件破坏后导致查询错误的问题
BigBird2012
mongodb

    问题描述：
MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。
解决方案：
 
使用脚本，重建MongoDB所有表的索引。
var names = db.getCollectionNames();
for( var i in names ){
var name = names[i];
print(name); 
    

    • 

  • Javascript Promise
bijian1013
JavaScriptPromise

            Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。
一.认识Promises
        “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
    

    • 

  • [Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程
bit1129
zookeeper

       Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是  
 
public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
    

    • 

  • 【Java命令三】jstack
bit1129
jstack

    jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump
 
[hadoop@hadoop sbin]$ jstack
Usage:
jstack [-l] <pid>
(to connect to running process)
jstack -F 
    

    • 

  • jboss 5.1启停脚本　动静分离部署
ronin47

    以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename  -b ip -g  clustername   -u broatcast jboss.messaging.ServerPeerID=int  -Djboss.service.binding.set=p
    

    • 

  • UI之如何打磨设计能力?
brotherlamp
UIui教程ui自学ui资料ui视频

     
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。
1.找到自己的方式
如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
    

    • 

  • 三色旗算法
bylijinnan
java算法

    
import java.util.Arrays;
/**
问题：
假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，
您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳
子上进行这个动作，而且一次只能调换两个旗子。
网上的解法大多类似：
在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
    

    • 

  • 警告:No configuration found for the specified action: \'s
chiangfai
configuration

    1.index.jsp页面form标签未指定namespace属性。
<!--index.jsp代码-->
<%@taglib prefix="s" uri="/struts-tags"%>
...
<s:form action="submit" method="post"&g
    

    • 

  • redis -- hash_max_zipmap_entries设置过大有问题
chenchao051
redishash

    使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑
 
#define ZIPMAP_BIGLEN 254
#define ZIPMAP_END 255
 
 
/* Return th
    

    • 

  • select into outfile access deny问题
daizj
mysqltxt导出数据到文件

    本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/
为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。
授权的语句如下：
grant select on armory.* to rn
    

    • 

  • phpexcel导出excel表简单入门示例
dcj3sjt126com
PHPExcelphpexcel

    
<?php
error_reporting(E_ALL);
ini_set('display_errors', TRUE);
ini_set('display_startup_errors', TRUE);
 
if (PHP_SAPI == 'cli')
die('This example should only be run from a Web Brows
    

    • 

  • 美国电影超短200句
dcj3sjt126com
电影

    1. I see． 我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too． 我也是。5. My god! 天哪!6. No way! 不行!7. Come on． 来吧(赶快)8. Hold on． 等一等。9. I agree。 我同意。10. Not bad． 还不错。11. Not yet． 还没。12. See you． 再见。13. Shut up! 
    

    • 

  • Java访问远程服务
dyy_gusi
httpclientwebservicegetpost

        随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
    

    • 

  • Maven的settings.xml配置
geeksun
settings.xml

    settings.xml是Maven的配置文件，下面解释一下其中的配置含义：
settings.xml存在于两个地方：
1.安装的地方：$M2_HOME/conf/settings.xml
2.用户的目录：${user.home}/.m2/settings.xml
前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。

    

    • 

  • ubuntu的init与系统服务设置
hongtoushizi
ubuntu

    转载自： 
http://iysm.net/?p=178 init
Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。
ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。
运行
    

    • 

  • 跟我学Nginx+Lua开发目录贴
jinnianshilongnian
nginxlua

    使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。 
  目录
第一章 安装Nginx+Lua开发环境
第二章 Nginx+Lua开发入门
第三章 Redis/SSDB+Twemproxy安装与使用
第四章 L
    

    • 

  • php位运算符注意事项
home198979
位运算PHP&

    $a = $b = $c = 0;
$a & $b = 1;
$b | $c = 1
 问a,b,c最终为多少?
 
当看到这题时，我犯了一个低级错误，误 以为位运算符会改变变量的值。所以得出结果是1 1 0
但是位运算符是不会改变变量的值的，例如：
$a=1;$b=2;
$a&$b;
 这样a,b的值不会有任何改变

    

    • 

  • Linux shell数组建立和使用技巧
pda158
linux

    1.数组定义 　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。 　　
2.数组读取与赋值 　　得到长度： 　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
    

    • 

  • hotspot源码(JDK7)
ol_beta
javaHotSpotjvm

    源码结构图，方便理解：
 
├─agent                            Serviceab
    

    • 

  • Oracle基本事务和ForAll执行批量DML练习
vipbooks
oraclesql

    基本事务的使用：
从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚
select * from account;
-- 创建一张账户表
create table account(
-- 账户ID
id number(3) not null,
-- 账户名称
nam
    

    •