liushangzaibeijing
liushangzaibeijing

spring源码分析之bean的创建

目录

一、不同scope实例创建的简单分析

 1、单例对象创建

  getSingleton(String beanName,ObjectFactory of)方法详解

 2、原型对象创建 

 3、其他Scope范围bean实例创建 

二、创建bean实例的核心流程分析

1、creatBean()方法

2、doCreateBean()方法

3、 createBeanInstance() 

3.1、使用Supplier函数接口进行bean的实例化

3.2、 使用工厂方法进行bean的实例化

3.3、使用构造函数进行bean的实例化

前言：我们在上一篇博文 spring源码分析之bean的加载 中已经介绍了有关spring的bean加载过程中的主要流程，只是在创建不同scope范围的bean实例的过程中留下了伏笔，那么这边博文作者针对其上面博文有关手动创建bean实例进行详细的介绍。

一、不同scope实例创建的简单分析

    先简单补充一下实例创建的代码

   1、单例对象创建

              逻辑代码:单例对象使用beanFactory的重载重载方法 getSingleton(String beanName,ObjectFactory of)。

    ObejctFactory是一个接口式接口，这里使用了匿名内部类 调用createBean()方法 具体的创建bean实例的正式该方法。

//创建单例对象代码片段
sharedInstance = getSingleton(beanName, () -> {
try {
	//具体的调用逻辑是调用ObjectFactory其匿名内部类的getObject()方法
	//方法中createBean()方法
	return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
	destroySingleton(beanName);
	throw ex;
	}
});

      getSingleton(String beanName,ObjectFactory of)方法详解

/**
* 创建单例对象
* @param beanName 创建对象的beanName
* @param singletonFactory  具体调用该对象的getObject()方法创建对应的bean实例
* @return 返回创建的对象
*/
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
	Assert.notNull(beanName, "Bean name must not be null");
	synchronized (this.singletonObjects) {
	//从单例缓存中获取单例对象
	Object singletonObject = this.singletonObjects.get(beanName);
	//如果对象为null
	if (singletonObject == null) {
		//则进行单例对象的创建操作
		//判断如果该beanFactory被销毁则抛出异常
		if (this.singletonsCurrentlyInDestruction) {
			throw new BeanCreationNotAllowedException();
		}
		if (logger.isDebugEnabled()) {
			logger.debug("Creating shared instance of singleton bean beanName);
		}
		//单例对象创建之前的回调 默认实现是将其添加到正在创建的列表中
		//表明该对象正在被创建 单例对象 防止多次创建
		beforeSingletonCreation(beanName);
		boolean newSingleton = false;
		//创建保存异常的信息 用于存储创建实例对象的异常信息
		boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
		if (recordSuppressedExceptions) {
			this.suppressedExceptions = new LinkedHashSet<>();
		}
		try {
			//调用ObjectFactory 创建实例对象
			singletonObject = singletonFactory.getObject();
			newSingleton = true;
		}
		catch (IllegalStateException ex) {
			//在创建对象的时候出现异常 可能从别的途径隐式的创建对象 所有从缓存中获取
			// 看看是否有了，破罐子破摔
			singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				throw ex;
			}
			}
			catch (BeanCreationException ex) {
			//添加创建bean实例异常的信息
				if (recordSuppressedExceptions) {
					for (Exception suppressedException : this.suppressedExceptions) {
						ex.addRelatedCause(suppressedException);
				    }
				}
				throw ex;
			}
			finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				//单例对象创建之前的回调 默认实现将正在创建的该bean标识 
                //从正在创建bean的列表中移除
				afterSingletonCreation(beanName);
			}
			if (newSingleton) {
				//添加新创建的单例对象到缓存中
				addSingleton(beanName, singletonObject);
			}
		}
		//返回创建的单例对象
		return singletonObject;
	}

 2、原型对象创建 

          创建原型对象的核心逻辑和单例创建实例一致调用createBean()方法

//原型对象创建的代码逻辑
Object prototypeInstance = null;
try {
	//原型对象创建之前的回调
	//主要功能是将创建的beanName 放入prototypesCurrentlyInCreation中
	beforePrototypeCreation(beanName);
	//创建原型对象的方式和创建单例对象的一样 这里不再详述
	prototypeInstance = createBean(beanName, mbd, args);
}
finally {
	//原型对象创建之前的回调
	//主要功能是将创建的beanName从prototypesCurrentlyInCreation移除
	afterPrototypeCreation(beanName);
}

  3、其他Scope范围bean实例创建 

     调用scope的get(String beanName,ObjectFactory of), get()方法中调用ObjectFactory的getObject() 创建对象实例，最终调用和上面的创建bean实例流程一致调用creatBean()方法

//调用scope的get方法，具体的创建的操作是在其第二个匿名参数ObjectFactory
//里面也是调用createBean()
Object scopedInstance = scope.get(beanName, () -> {
	//与原型对象创建之前的回调一致 
	//标记该beanName对应的bean实例对象正在被创建
	beforePrototypeCreation(beanName);
	try {
		//具体创建bean实例的核心代码
		return createBean(beanName, mbd, args);
	}
	finally {
		//与原型对象创建之后的回调一致 
		//移除beanName对应的bean实例从标记中
		afterPrototypeCreation(beanName);
	}
});


//scope 获取对象的
public Object get(String name, ObjectFactory objectFactory) {
    //先从缓存中获取对应的bean实例 如果没有则调用ObjectFactory的getObject()方法
    //getObject()方法中的实现是上面匿名内部类的createBean()方法
    Map scope = (Map)this.threadScope.get();
    Object scopedObject = scope.get(name);
    if (scopedObject == null) {
       scopedObject = objectFactory.getObject();
        scope.put(name, scopedObject);
    }
    return scopedObject;
}

 对于上面三种类型bean实例创建，各有不同点，但是最终都是调用相同的createBean()来进行实例的创建。下面我们来分析三种创建bean实例的核心代码createBean()方法。

二、创建bean实例的核心流程分析

    1、creatBean()方法

//根据RootBeanDefinition 创建对应的bean实例
protected Object createBean(String beanName, RootBeanDefinition mbd,
        @Nullable Object[] args)   throws BeanCreationException {

	if (logger.isDebugEnabled()) {
		logger.debug("Creating instance of bean '" + beanName + "'");
	}
	RootBeanDefinition mbdToUse = mbd;
	//1、解析beanDefinition中获取其中的class属性
    //如果beanDefinition中没有填充class属性
	//填充对应的RootBeanDefinition 的BeanClass
	Class resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass()
        && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	// Prepare method overrides.
	try {
	  //2、在beans.xml 中replace-method、lookup 配置 
      //会被解析到BeanDefinition的MethodOverride中
	  //标记BeanDefintion中的某些MethodOverride 只有一个方法 标明该方法没有重载方法
	  //在进行methodOverrides实例化的时候避免参数检查的开销
	  mbdToUse.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
	  throw new BeanDefinitionStoreException(ex);
	}
	try {
		//3、通过应用bean的后置处理器 返回一个代理对象而非目标对象，
        //此处是我们常用的AOP功能的实现
		//这里有一个短路操作 如果代理对象存在则直接返回代理对象 不在做后续的操作
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(ex);
	}

	try {
		//4、对于普通的bean 实例执行真正的创建bean实例的逻辑
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
        //返回bean实例对象
		return beanInstance;
	}
	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) 			 
          throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(ex);
	}
}

     上面代码的主要逻辑如下：

  1.  解析beanDefinition中获取其中的class属性,如果beanDefinition中没有填充class属性,填充对应的RootBeanDefinition的class属性。
  2. 在beans.xml 中replace-method、lookup 配置 会被解析到BeanDefinition的MethodOverride中，bean实例化的时候如果检测道存在MethodOverride属性，会动态的为当前bean生成代理并使用对应的拦截器为bean做增强处理。同时标记如果BeanDefintion中的某些MethodOverride只有一个方法标明该方法没有重载方法，避免参数检查的开销。 
  3. public void prepareMethodOverrides() throws BeanDefinitionValidationException {
   //判断beanDefintion是否有MethodOverrides
   if (hasMethodOverrides()) {
	  getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
   }
}
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
	//获取class中 方法名对应的重载方法的个数
	int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
	if (count == 0) {
		throw new BeanDefinitionValidationException();
	}
	//如果重载方法个数为1 则说明该方法没有重载方法 设置MethodOverride 的重载标识为false
	else if (count == 1) {
		// Mark override as not overloaded, to avoid the overhead of arg type checking.
		mo.setOverloaded(false);
	}
}
  4. 通过应用bean的后置处理器 返回一个代理对象而非目标对象，此处是我们常用的AOP功能的实现。这里有一个短路操作 如果代理对象存在则直接返回代理对象不在做后续的操作。
  5. //应用后置处理器，对bean实例进行代理增强 我们的AOP代理增强也是在该处来进行实现
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			//获取bean的class实例
			Class targetType = determineTargetType(beanName, mbd);
			if (targetType != null) {
			  //应用bean实例化之前的后置处理器进行 bean的处理
			  bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
			  if (bean != null) {
				//应用bean实例化之后的后置处理器进行 bean的处理
				bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
		     }
		  }
		}
	   mbd.beforeInstantiationResolved = (bean != null);
  }
 return bean;
}
  6. 对于普通的bean实例化调用doCreateBean()执行真正的创建bean实例的逻辑
 

3、doCreateBean()方法

      在上面代码对createBean()分析发现，对于普通bean实例的创建是由doCreatBean()来实现的接下来我们来分析doCreateBean()方法。

//真正的创建bean操作
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)	throws BeanCreationException {

	//BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，
	// 获取被包装bean的属性描述器，由于BeanWrapper接口是PropertyAccessor的子接口，
	// 因此其也可以设置以及访问被包装对象的属性值。
	BeanWrapper instanceWrapper = null;
	//单例对象
	if (mbd.isSingleton()) {
		//先从缓存中获取BeanWrapper 并移除缓存
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		//根据对应的策略创建新实例 工厂方法 构造函数 等创建实例
		//实例化bean 将BeanDefinition转换为BeanWrapper
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	//获取对应的bean实例
	final Object bean = instanceWrapper.getWrappedInstance();
	//获取对应的bean 的class属性
	Class beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		//设置beanDefintion的class属性resolvedTargetType
		mbd.resolvedTargetType = beanType;
	}
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
			  //应用MergedBeanDefinitionPostProcessor后置处理器
			  //主要是对AutowiredAnnotation、通用注解进行后置处理器
			  //比如 AutowiredAnnotationBeanPostProcessor类把正在被spring实例化的bean 
              //进行@Autowired和@Value扫描，
			  //扫描到类里面属性和方法上面如果有注解,就会把对应的方法或者属性封装
              //最终封装成InjectionMetadata对象
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(ex);
			}
			mbd.postProcessed = true;
		}
	}
     //为了解决循环依赖 先将实例化的bean此时还未初始化包装成ObjectFactory 
     //添加到singletonFactories缓存中
     //正在初始化化的单例模式的bean（已经实例化)为了避免循环引用先想将其包装成 
     //ObjectFactory放入缓存中 提前暴露出去。
	boolean earlySingletonExposure = (mbd.isSingleton()
           && this.allowCircularReferences &&
		isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
	  //在该bean实例未完全初始化之前 先将其包装为ObjectFactory对象放入缓存暴露出去
	  addSingletonFactory(beanName, 
           () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	Object exposedObject = bean;
	try {
		    //前面已经实例化了bean 接下来初始化bean实例
		populateBean(beanName, mbd, instanceWrapper);
             //如果bean实例继承了XXXAware 调用其对对应的接口类设置属性
             //或者调用init-method方法
		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);
		}
	}
	//如果该实例bean已经提前暴露出来
	if (earlySingletonExposure) {
		//说明该bean实例至少已经加载到了缓存中
		//如果调用initializeBean()  exposedObject和bean一致
        //则说明exposedObject没有被改变
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping 
              && hasDependentBean(beanName)) {
			//获取beaName的依赖 beanName依赖一定是创建的 (先创建依赖bean 再创建BeanName)
			String[] dependentBeans = getDependentBeans(beanName);
			Set actualDependentBeans = new LinkedHashSet<>
            for (String dependentBean : dependentBeans) {
			   if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
				   actualDependentBeans.add(dependentBean);
			   }
		 	}
			//如果actualDependentBeans 说明还有beanName对应的依赖没有创建完成
			//有循环依赖
			if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException();
			}
		}
	 }
   }

   // Register bean as disposable.
   try {
	 //spring对于bean实例的销毁方法 除了使用destory-method
	 //还可以通过注册DestructionAwareBeanPostProcesser 来统一处理bean的销毁方法
	 registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }
   catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(ex);
   }
return exposedObject;
}
  1.  实例化一个BeanWrapper对象，如果是单例对象先尝试从缓存中获取BeanWrapper实例，如果缓存中没有则调用createBeanInstance()方法来实例化BeanWarpper实例。并从BeanWarpper中获取对应的bean实例和对应的class属性。 BeanWrapper是对Bean的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装bean的属性描述器，由于BeanWrapper接口是PropertyAccessor的子接口，因此其也可以设置以及访问被包装对象的属性值。
  2. 应用MergedBeanDefinitionPostProcessor后置处理器，在bean实例化完毕后调用 可以用来修改merged BeanDefinition的一些properties或者用来给后续回调中缓存一些meta信息使用这个算是将merged BeanDefinition暴露出来的一个回调。
  3. 为了解决循环依赖 先将实例化的bean此时还未初始化包装成ObjectFactory 添加到singletonFactories缓存中。
  4. 实例化bean完成后，需要调用populateBean()实例化后的bean填充相关的属性。
  5. initializeBean()进行初始化方法的调用，调用相关的该实例bean的XXXAware的接口设置相应的属性。调用init-method方法 或者接口实现了InitializingBean调用其afterPropertiesSet()方法。
  6. 应用后置处理器 postProcessAfterInitialization()方法
  7. 对创建的bean实例进行依赖校验，即该实例bean的依赖必须在bean实例化之前被实例化
  8. 为对应的bean实例注册销毁方法。 

 通过上述的一系列步骤最终创建出来我们想要的bean实例了。

    上面的主要逻辑大都清晰可见，我们需要关注

             createBeanInstance() 获取对应的bean实例对象并将其包装成BeanWarpper

             populateBean()   填充实例bean的相关属性

             initializeBean()  调用bean实例的相关初始化方法 比如init-method，XXXAware接口等

            registerDisposableBeanIfNecessary()为创建的实例bean注册销毁方法。bean实例被销毁的时候会调用注册的销毁方法

4、 createBeanInstance() 

   在上面bean实例化过程中我们概览了bean实例化的大致流程，但是对于bean实例化细节，并没有过多的介绍，对于bean实例化的细节其实是在createBeanInstance()方法中，该方法主要根据对应的策略创建新实例,比如工厂方法、构造函数等方式创建实例。下面我们来分析下代码片段

//具体的对beanDefintion进行处理 并通过不同的方式实例化bean 譬如工厂、特定构造器 默认构造器等
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// 获取对应的mbd的class属性
	Class beanClass = resolveBeanClass(mbd, beanName);

	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) 
         && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException();
	}
	//1、Spring5.0新增的实例化策略,如果设置了该策略,将会覆盖构造方法和工厂方法实例化策略
    //Supplier 一个通过get()方法创建对象的
	//如果对应的beanDefinition 由Supplier 则调用其get方法获取bean实例
	Supplier instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}
	// 后面根据bean创建的不同方式 默认构造器实例化、特定构造器实例化、工厂方式创建
	// 由AbstractAutowireCapableBeanFactory 委托给ConstructorResolver调用其相应的方法
	// 1、如果使用工厂方法 则调用ConstructorResolver的instantiateUsingFactoryMethod()
    //来调用工厂类的静态/非静态方法初始化
	// 2、如果有特定构造器 则调用ConstructorResolver的autowireConstructor() 方法
    //默认构造器实例化bean
	// 3、否则使用默认空构造器函数实例化bean
    //调用工厂方法进行实例化
    if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}
	// bean对应的类可能会有多个构造函数，而每个构造函数的参数不同
	// spring在根据参数以及类型去判断最终使用哪个构造函数进行实例化
	//但是构造参数判断的过程比较耗时 这里会使用缓存机制 
    //先尝试从缓存中获取已经解析的构造函数方法
	//如果没有则进行判断并将判断出来的构造函数方法放入缓存中便于下来使用。
//单例模式: spring针对单例模式只创建一次将其实例化用到的构造函数方法存入缓存有什么意义
    //  我们知道对于IoC容器除了可以获取bean之外,还能销毁bean,
	//  当我们调用BeanFactory.destroyBean(myBeanName,myBeanInstance),
	//	销毁bean时,容器是不会销毁已经解析的构造函resolvedConstructorOrFactoryMethod的,
    //	如果再次调用BeanFactory.getBean(myBeanName)时,就会使用缓存的实例化构造器方法了。
//原型模式: 对于该模式的理解就简单了,IoC容器不会缓存原型模式bean的实例,
    / /当我们第二次向容器索取同一个bean时,就会使用该缓存的实例化构造函数方法了。
	boolean resolved = false;
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				//说明以前解析过该bean对应的构造函数
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	//解析过 则直接进行构造 要么是有特定的构造函数 要么使用默认构造函数
	//不去进行构造函数判断了
	if (resolved) {
		if (autowireNecessary) {
	    	//如果缓存中有构造器函数 直接根据缓存中的构造函数进行实例化
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			//使用默认的构造函数实例化
			return instantiateBean(beanName, mbd);
		}
	}

	// 根据类型或者参数解析获取对应的构造函数 并进行实例化
	Constructor[] ctors = determineConstructorsFromBeanPostProcessors
             (beanClass, beanName);
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		//判断出来了需要使用的构造器 使用构造器进行初始化
		return autowireConstructor(beanName, mbd, ctors, args);
	}
	// 没有查找到对应的构造函数 则使用默认的构造函数构造
	return instantiateBean(beanName, mbd);
}

  上面的代码虽然比较多，但是相对简单，主要分三种情况描述bean实例化

  •   使用Supplier函数接口进行bean的实例化
  •   使用工厂方法进行bean的实例化
  •   使用构造函数进行bean的实例化

 

  4.1、使用Supplier函数接口进行bean的实例化

        Spring5.0新增的实例化策略,如果设置了该策略,将会覆盖构造方法和工厂方法实例化策略 。在bean注册成BeanDefintion会调用registerBean(beanName, beanClass, Supplier supplier,  customizers) 将Supplier函数接口注册到beanDefintion，  Supplier是一个函数式接口，可以通过get()方法获取创建的bean实例对象。

//通过给定的Supplier 调用其get()方法获取一个bean实例 并将其包装为BeanWrapper
protected BeanWrapper obtainFromSupplier(Supplier instanceSupplier, String beanName) {
	String outerBean = this.currentlyCreatedBean.get();
	this.currentlyCreatedBean.set(beanName);
	Object instance;
	try {
		//调用Supplier的get()获取bean实例
		instance = instanceSupplier.get();
	}
	finally {
		if (outerBean != null) {
			this.currentlyCreatedBean.set(outerBean);
		}
		else {
			this.currentlyCreatedBean.remove();
		}
	}
	//将实例bean包装成BeanWrapper对象
	BeanWrapper bw = new BeanWrapperImpl(instance);
	initBeanWrapper(bw);
	return bw;
}

  4.2、 使用工厂方法进行bean的实例化

          工厂方法创建主要分成两种：一种是使用工厂的静态方法创建bean实例，另一种是工厂的非静态方法创建bean实例。

//调用该bean对应的factory-method 来实现化bean实例
public BeanWrapper instantiateUsingFactoryMethod(
		String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {		 
    //构建一个BeanWrapperImpl 实例并注册到beanFactory中
	BeanWrapperImpl bw = new BeanWrapperImpl();
	this.beanFactory.initBeanWrapper(bw);

	Object factoryBean;
	Class factoryClass;
	boolean isStatic;
    //获取beanDefintion的FactoryBeanName
	// 注意：静态工厂方法是没有factoryBeanName的，
	// 所以如果factoryBeanName不为null，则一定是实例工厂方法，
	// 否则就是静态工厂方法
	String factoryBeanName = mbd.getFactoryBeanName();

	if (factoryBeanName != null) {
		//工厂名字不能和beanName相同 工厂对象不能生产自己本身
		if (factoryBeanName.equals(beanName)) {
			throw new BeanDefinitionStoreException();
		}
		//先获取工厂对象实例
		factoryBean = this.beanFactory.getBean(factoryBeanName);
		if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
			throw new ImplicitlyAppearedSingletonException();
		}
		//获取工厂对象class
		factoryClass = factoryBean.getClass();
		//表明使用非静态的方式创建对象
		isStatic = false;
	}
	else {
		//使用工厂类的静态方法获取实例对象
		if (!mbd.hasBeanClass()) {
			throw new BeanDefinitionStoreException();
		}
		factoryBean = null;
		//class属性为beanDefintion的beanClass属性
		factoryClass = mbd.getBeanClass();
		//表明使用静态的方式创建对象
		isStatic = true;
	}

	//调用工厂的具体方法对象
	Method factoryMethodToUse = null;

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

	//2、判断有无显式指定构造方法参数,如果有则优先使用
	//   如xmlBeanFactory.getBean("student", "张同学","13岁");
	if (explicitArgs != null) {
		argsToUse = explicitArgs;
	}
	else {
		Object[] argsToResolve = null;
		synchronized (mbd.constructorArgumentLock) {
			//获取以及解析过的工厂方法以及该方法对应的参数
			//因为解析对应的FactoryMethod 是一个比较耗时的操作 这里如果曾经解析过
			//则会放到beanDefintion的对应的属性中便于下次初始化的时候直接使用
			factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
			if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
				//从beanDefinition的属性中获取对应的解析参数
				argsToUse = mbd.resolvedConstructorArguments;
				if (argsToUse == null) {
					argsToResolve = mbd.preparedConstructorArguments;
				}
			}
		}
		//解析参数类型，如果获取到的构造函数为A(int a,int b)
		// 会将对应的参数类型A（"1","2"） 转换为A(1,2)类型
		if (argsToResolve != null) {
			argsToUse = resolvePreparedArguments(beanName, mbd, bw,
            factoryMethodToUse, argsToResolve);
		}
	}
    //如果工厂方法 或者参数为null(不是size 为0) 则FactoryMethod相关属性没有被解析
	if (factoryMethodToUse == null || argsToUse == null) {
		//这里需要去判断合适的工厂方法
		factoryClass = ClassUtils.getUserClass(factoryClass);
		//判断的依据是mbd.isNonPublicAccessAllowed()是否允许私有方法被访问
		// 允许则获取factoryClass的所有方法、不允许则只获取其公有方法
		Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);

		List candidateList = new ArrayList<>();
		//遍历所有的方法 如果满足条件isStatic、mbd的factoryMethod一致的方法
        //放入candidateList中 侯选者列表中
		for (Method candidate : rawCandidates) {
			if (Modifier.isStatic(candidate.getModifiers()) == isStatic 
                  && mbd.isFactoryMethod(candidate)) {
				candidateList.add(candidate);
			}
		}

		Method[] candidates = candidateList.toArray(new Method[0]);
		//排序侯选者方法列表 优先选择公有工厂方法和参数最多的方法
        //（贪婪算法 参数越多 包容性越强越容易匹配上）
		AutowireUtils.sortFactoryMethods(candidates);

		ConstructorArgumentValues resolvedValues = null;
		//判断mbd注入方式是否构造器注册
		boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
		int minTypeDiffWeight = Integer.MAX_VALUE;
		Set ambiguousFactoryMethods = null;

		//定义最小工厂方法参数个数，以备循环解析候选方法使用
		int minNrOfArgs;
		//如果显示的指定了参数 则使用指定的参数的构造方法
		if (explicitArgs != null) {
			//如指定参数不为空，则使用指定参数个数作为最小方法参数个数
			minNrOfArgs = explicitArgs.length;
		}
		else {
			//如果没有显示的指定参数信息，尝试从beanDefintion中解析构造函数信息 
            //以便确定参数个数最少的构造函数
			if (mbd.hasConstructorArgumentValues()) {
				//获取beanDefintio中保存的构造函数参数信息
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				resolvedValues = new ConstructorArgumentValues();
				//要为beanDefintio中保存的构造函数参数列表解析特定的参数信息
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}
			else {
				//以上均未能获取，则将最小方法参数个数置为0
				minNrOfArgs = 0;
			}
		}

		LinkedList causes = null;

		for (Method candidate : candidates) {
			Class[] paramTypes = candidate.getParameterTypes();
			//这里只获取候选方法的参数格式大于等于最少参数格式的候选方法
			//不满足最少参数个数的方法会被排除掉
			if (paramTypes.length >= minNrOfArgs) {
				ArgumentsHolder argsHolder;

				//如果有显示声明的构造参数  候选方法的参数个数必须完全匹配显示参数个数
				//换句话说 要找到完全匹配显示参数个数的构造方法
				if (explicitArgs != null) {
					if (paramTypes.length != explicitArgs.length) {
						continue;
					}
					argsHolder = new ArgumentsHolder(explicitArgs);
				}
				else {
					//解析构造参数 通过类型转换或者自动装配 创建参数持有者ArgeHolder
					try {
						String[] paramNames = null;
						ParameterNameDiscoverer pnd = 
             this.beanFactory.getParameterNameDiscoverer();
						if (pnd != null) {
							paramNames = pnd.getParameterNames(candidate);
						}
						argsHolder = createArgumentArray(
							beanName, mbd, resolvedValues, bw, paramTypes, paramNames, 
                    candidate, autowiring);
					}
					catch (UnsatisfiedDependencyException ex) {
						if (logger.isTraceEnabled()) {
							//
					}
				}

			//通过构造函数参数权重对比,得出最适合使用的构造函数
			//先判断是返回是在宽松模式下解析构造函数还是在严格模式下解析构造函数。(默认是宽松模式)
			//对于宽松模式:例如构造函数为(String name,int age),配置文件中定义(value="张同学",value="18")
			//那么对于age来讲,配置文件中的"3",可以被解析为int也可以被解析为String,
			//这个时候就需要来判断参数的权重,使用ConstructorResolver的静态内部类
			//ArgumentsHolder分别对字符型和数字型的参数做权重判断,权重越小,则说明构造函数越匹配
			//对于严格模式:严格返回权重值,不会根据分别比较而返回比对值
			// 注意：minTypeDiffWeight = Integer.MAX_VALUE;而权重比较返回结果都是
			// 在Integer.MAX_VALUE做减法,起返回最大值为Integer.MAX_VALUE
			int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
				argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
			if (typeDiffWeight < minTypeDiffWeight) {
				factoryMethodToUse = candidate;
				argsHolderToUse = argsHolder;
				argsToUse = argsHolder.arguments;
				minTypeDiffWeight = typeDiffWeight;
				ambiguousFactoryMethods = null;
			}
			// 如果未能明确解析出需要使用的工厂方法
			//对于具有相同参数个数的方法，如果具有相同类型的权值，则收集这些候选对象，并最终引发歧义异常。
			// 但是，只在非宽松的构造函数解析模式中执行该检查，并显式地忽略覆盖的方法(具有相同的方法)。
			//该行代码是在 大的条件语句factoryMethodToUse 是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);
				}
			}
		}

		//经过如上的操作 如果不能获取到合适的工厂方法
		if (factoryMethodToUse == null) {
			//如果有异常信息  则为beanFacotry添加创建该bean异常信息 并抛出异常
			if (causes != null) {
				UnsatisfiedDependencyException ex = causes.removeLast();
				for (Exception cause : causes) {
					this.beanFactory.onSuppressedException(cause);
				}
			throw ex;
		}

		//如果没有异常信息 则讲所有的参数简单的名字收集起来
		//并使用该参数信息去抛出BeanCreationException详细异常信息
		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();
	}
	//如果工厂方法的return 为void 抛出异常
	else if (void.class == factoryMethodToUse.getReturnType()) {
		throw new BeanCreationException();
	}
	//如果有有歧义的方法 抛出异常
	else if (ambiguousFactoryMethods != null) {
				throw new BeanCreationException();
	}
    //判断后最终确定的构造函数存储在beanDefintion中方便下次使用的时候
	// 不用进行耗时的判断操作 直接使用即可
	if (explicitArgs == null && argsHolderToUse != null) {
		argsHolderToUse.storeCache(mbd, factoryMethodToUse);
	}
	}

    try {
 		Object beanInstance;
        //这里才是我们调用工厂方法的具体逻辑
		//获取beanFactory的具体的实例化策略 进行bean的实例化
		if (System.getSecurityManager() != null) {
			final Object fb = factoryBean;
			final Method factoryMethod = factoryMethodToUse;
			final Object[] args = argsToUse;
			beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
				beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, fb, factoryMethod, args),
			beanFactory.getAccessControlContext());
		}
		else {
			beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
					mbd, beanName, this.beanFactory, factoryBean, 
             factoryMethodToUse, argsToUse);
		}

		bw.setBeanInstance(beanInstance);
		return bw;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
			"Bean instantiation via factory method failed", ex);
	}
} 
  
 上面的代码很多也很复杂，主要的逻辑为先判断创建工厂对象的使用静态方法还是非静态方法，获取工厂对应的所有方法，根据方法名和参数个数匹配到最适合的方法最终合适的工厂方法创建实例对象。最終通过InstantiationStrategy类的instantiate()方法来进行实例化 Object result = factoryMethod.invoke(factoryBean, args)反射实例化。
 
  
  4.3、使用构造函数进行bean的实例化
 
  
    使用构造函数和使用工厂方法进行bean实例化逻辑相同，唯一的区别构造器形式进行bean的实例化需要根据参数个数和类型匹配对应的构造函数，通过反射进行实例化。
 
  
//和使用工厂方法实例化bean的逻辑相同 只不过此处是判断匹配的构造器方法 而非工厂方法
	public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
			@Nullable Constructor[] chosenCtors, @Nullable Object[] explicitArgs) {

		//1、创建一个默认的bean实例的包装类BeanWrapperImpl实例
		// 用来承接我们实例化的bean
		BeanWrapperImpl bw = new BeanWrapperImpl();
		//对BeanWrapperImpl实例初始化并将其作为PropertyEditorRegistry注册到beanFactory
		this.beanFactory.initBeanWrapper(bw);

		//用来存储判断出来的需要使用的构造函数
		Constructor constructorToUse = null;
		//用来存储判断出来的需要使用的构造函数参数对象（持有者）
		ArgumentsHolder argsHolderToUse = null;
		Object[] argsToUse = null;

		//2、判断有无显式指定构造方法参数,如果有则优先使用
		//   如xmlBeanFactory.getBean("student", "张同学","13岁");
		if (explicitArgs != null) {
			argsToUse = explicitArgs;
		}
		//3、从缓存中尝试获取解析的构造函数方法
		else {
			Object[] argsToResolve = null;
			//获取以及解析过的工厂方法以及该方法对应的参数
			//因为解析对应的构造函数Constructor对象 是一个比较耗时的操作 这里如果曾经解析过
			//则会放到beanDefintion的对应的属性中便于下次初始化的时候直接使用
			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;
					}
				}
			}
			//解析参数类型，如果获取到的构造函数为A(int a,int b)
			//会将对应的参数类型A（"1","2"）转换为A(1,2)类型
			if (argsToResolve != null) {
				//缓存中的值可能是原始值 也可能是最终值 原始值需要进行解析
				argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
			}
		}

		//4、如果缓存中没有说明构造器函数没有被解析存储到beanDefintion的缓存中
		//这里需要来进行解析构造器参数并判断使用哪个构造器参数
		if (constructorToUse == null) {
			// 判断注入方式为构造器函数注入
			boolean autowiring = (chosenCtors != null ||
					mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
			//用来引用解析后的构造函数参数列表
			ConstructorArgumentValues resolvedValues = null;

			//定义最小构造函数参数个数，以备循环解析候选方法使用
			int minNrOfArgs;
			if (explicitArgs != null) {
				//如指定参数不为空，则使用指定参数个数作为最少构造方法参数个数
				minNrOfArgs = explicitArgs.length;
			}
			else {
				//否则从beanDefintion中的获取构造参数对象 以及最少构造方法参数个数
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				//用来承接 resolveConstructorArguments()方法解析后的构造参数对象
				//该方法会解析参数信息 比如获取参数的基本类型 或者一个引用类型 并返回解析到的参数个数
				//该参数个数也是我们去匹配候选构造函数的最低参数个数
				resolvedValues = new ConstructorArgumentValues();
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}


			//5、根据构造参数 来确定对应的构造函数
			// 将外部传入显示的构造方法对象列表 先作为候选构造函数列表中
			Constructor[] candidates = chosenCtors;
			//如果外部传入的候选构造函数为null 需要我们来解析出候选构造函数
			if (candidates == null) {
				//获取创建bean实例的class属性
				Class beanClass = mbd.getBeanClass();
				try {
					//根据beanClass属性 获取其全部的构造函数
					//判断的依据是mbd.isNonPublicAccessAllowed
					// 是否允许私有构造方法被访问
					//  1、允许则获取beanClass的所有构造方法方法、
					//  2、不允许则只获取其公有构造方法方法
					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);
				}
			}
			//6、排序侯选者构造方法列表 优先选择公有构造方法和参数最多的构造方法
			// （贪婪算法 参数越多 包容性越强越容易匹配上）
			AutowireUtils.sortConstructors(candidates);
			//这里如果有多个侯选者构造方法 需要使用权重大小来匹配合适的构造器函数
			//权重越小则越匹配 还涉及到宽松模式和非狂送模式
			int minTypeDiffWeight = Integer.MAX_VALUE;
			//有歧义的构造函数方法 出现匹配的构造函数有多个的歧义
			// 如果有会收集到这里 在后面如果有则抛出歧义异常信息
			Set> ambiguousConstructors = null;
			//实例化过程中的异常信息存储类
			LinkedList causes = null;

			//遍历所有侯选者构造函数列表
			for (Constructor candidate : candidates) {
				// 1、获取构造函数的参数类型
				Class[] paramTypes = candidate.getParameterTypes();
                //我没看错的话 这段代码是在if(constructorToUse==null)的条件下判断的
				//这行代码怎么会执行呢？
				if (constructorToUse != null && argsToUse.length > paramTypes.length) {
					// Already found greedy constructor that can be satisfied ->
					// do not look any further, there are only less greedy constructors left.
					break;
				}
				//最小参数类型个数大于候选的构造函数则跳过 不匹配
				if (paramTypes.length < minNrOfArgs) {
					continue;
				}
				//2、获取构造函数的参数名称
                //用于存储构造参数信息的对象（构造函数参数持有者）
				ArgumentsHolder argsHolder;
				if (resolvedValues != null) {
					try {
						//如果候选的构造函数有注解@ConstructorProperties修饰
						// 获取其中的names 作为参数名列表
						//因为参数生成 有两种方式 一种是根据索引indexedArgumentValues map集合
						//                      一种是根据名字genericArgumentValues map集合
						//所以针对参数 需要使用ParameterNameDiscoverer 获取参数名称
						String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
						if (paramNames == null) {
							//如果没有注解修饰的参数 则获取工厂对象的构造参数查找器（作用是获取构造函数的参数名称）
							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
							if (pnd != null) {
								//通过ParameterNameDiscoverer的getParameterNames()方法
								//获取构造函数的参数名称
								paramNames = pnd.getParameterNames(candidate);
							}
						}
						//将获取到的构造参数转换ArgumentsHolder对象
						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
								getUserDeclaredConstructor(candidate), autowiring);
					}
					//异常 添加到异常中causes
					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 {
					//对于外部显示的参数 构造函数对应的参数个数必须完全匹配
					//已经显示的指定了构造参数 所以需要获取与其参数完全匹配的构造函数
					if (paramTypes.length != explicitArgs.length) {
						continue;
					}
					//将显示的外部构造参数 包装成ArgumentsHolder对象
					argsHolder = new ArgumentsHolder(explicitArgs);
				}
				//通过构造函数参数权重对比,得出最适合使用的构造函数
				// 先判断是返回是在宽松模式下解析构造函数还是在严格模式下解析构造函数。(默认是宽松模式)
				// 对于宽松模式:例如构造函数为(String name,int age),配置文件中定义(value="张同学",value="18")
				// 那么对于age来讲,配置文件中的"3",可以被解析为int也可以被解析为String,
				// 这个时候就需要来判断参数的权重,使用ConstructorResolver的静态内部类
				// ArgumentsHolder分别对字符型和数字型的参数做权重判断,权重越小,则说明构造函数越匹配
				// 对于严格模式:严格返回权重值,不会根据分别比较而返回比对值
				// 注意：minTypeDiffWeight = Integer.MAX_VALUE;而权重比较返回结果都是
				// 在Integer.MAX_VALUE做减法,起返回最大值为Integer.MAX_VALUE
				int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
				// 根据权重获取到了最匹配的构造函数 将其赋值
				if (typeDiffWeight < minTypeDiffWeight) {
					constructorToUse = candidate;
					argsHolderToUse = argsHolder;
					argsToUse = argsHolder.arguments;
					minTypeDiffWeight = typeDiffWeight;
					ambiguousConstructors = null;
				}
				// 如果未能明确解析出需要使用的工厂方法
				// 对于具有相同参数个数的方法，如果具有相同类型的权值，则收集这些候选对象，并最终引发歧义异常。
				// 但是，只在非宽松的构造函数解析模式中执行该检查，并显式地忽略覆盖的方法(具有相同的方法)。
				//该行代码是在 大的条件语句factoryMethodToUse 是null的条件下 中间没有想过赋值操作
				//代码不会执行吧？
				else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
					if (ambiguousConstructors == null) {
						ambiguousConstructors = new LinkedHashSet<>();
						ambiguousConstructors.add(constructorToUse);
					}
					ambiguousConstructors.add(candidate);
				}
			}

			//没有合适的构造方法 则抛出相关的异常 这里
			if (constructorToUse == null) {
				if (causes != null) {
					UnsatisfiedDependencyException ex = causes.removeLast();
					for (Exception cause : causes) {
						this.beanFactory.onSuppressedException(cause);
					}
					throw ex;
				}
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Could not resolve matching constructor " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
			}
			//歧义异常
			else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Ambiguous constructor matches found in bean '" + beanName + "' " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
						ambiguousConstructors);
			}
			//如果有显示的构造器参数 每次需要根据具体的参数信息来精确匹配构造函数
			// 所以不需要将其存储在缓存中，只有没有外部显示的构造参数时候 会将最匹配的构造函数放入缓存
			//方便下次直接从缓存中获取。
			if (explicitArgs == null) {
				argsHolderToUse.storeCache(mbd, constructorToUse);
			}
		}

		//7、到了这里我们已经获取到了唯一一个合适进行bean实例化的构造函数
		//这里会从beanFactory 获取具体的实例化策略 调用构造函数进行bean实例化
		try {
			final InstantiationStrategy strategy = beanFactory.getInstantiationStrategy();
			Object beanInstance;

			if (System.getSecurityManager() != null) {
				final Constructor ctorToUse = constructorToUse;
				final Object[] argumentsToUse = argsToUse;
				beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
						strategy.instantiate(mbd, beanName, beanFactory, ctorToUse, argumentsToUse),
						beanFactory.getAccessControlContext());
			}
			else {
				beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
			}

			bw.setBeanInstance(beanInstance);
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean instantiation via constructor failed", ex);
		}
	} 
  
     
   
  •  
    创建一个默认的bean实例的包装类BeanWrapperImpl实例
     
    •  
   
  •  
    判断有无显式指定构造方法参数,如果有则优先使用
     
    •  
   
  •  
    从缓存中尝试获取解析的构造函数方法
     
    •  
   
  •  
    如果缓存中没有说明构造器函数没有被解析存储到beanDefintion的缓存中，需要解析构造器参数并判断使用哪个构造器参数
     
    •  
   
  •  
    根据构造参数 来确定对应的构造函数
     
    •  
   
  •  
    排序侯选者构造方法列表 优先选择公有构造方法和参数最多的构造方法

     
    •  
   
  •  
    到了这里我们已经获取到了唯一一个合适进行bean实例化的构造函数
     
    •  
   
  • 通过构造函数进行反射或者Kotlin方式进行bean的实例化操作 
    //构造函数的实例化方式
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
		final Constructor ctor, @Nullable Object... args) {
     //如果beanDefiontion中有相关的replace-method、lookup-method
	//需要覆盖、动态替换的方法需要使用cglib进行动态代理
	//这时不适用构造函数进行bean的实例化 而是使用instantiateWithMethodInjection()进行操作
	if (!bd.hasMethodOverrides()) {
		if (System.getSecurityManager() != null) {
			// 设置对于私有的构造方法 设置允许访问
			AccessController.doPrivileged((PrivilegedAction) () -> {
				ReflectionUtils.makeAccessible(ctor);
				return null;
			});
		}
		//具体的实例化 会使用KFunction的callBy() 不清楚是干啥呢
		//或者Constructor的newInstance()方法
		return (args != null ? BeanUtils.instantiateClass(ctor, args) : BeanUtils.instantiateClass(ctor));
	}
	else {
		//这边对于replace-method、lookup-method 需要使用CglibSubclassingInstantiationStrategy
		// 创建CglibSubclassCreator对象调用其instantiate方法
		// 说白了就是使用cglib进行代理增强进行覆盖或者动态替换
		return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
}


public static  T instantiateClass(Constructor ctor, Object... args) throws BeanInstantiationException {
        //标记构造函数可以访问
		ReflectionUtils.makeAccessible(ctor);
        //使用Kotline 或者反射构造函数创建bean实例
		return (KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
				KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
		}
} 
    至此有关bean实例获取逻辑分析完毕。有不妥之处敬请指教。
      
   
  
       
     
  
     
     
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(spring源码)
    
        
    
            
    
                
      
                    
    • Java基础：单例模式，Spring源码中有哪些单例模式
                        生活诙谐号
Java基础Spring源码设计模式单例模式javaspring
                        
      单例模式是一种常用的软件设计模式，其目的是确保一个类仅有一个实例，并提供一个全局访问点来获取这个唯一实例。在Java中，实现单例模式通常需要遵循以下几个关键原则：私有化构造器：将类的构造器声明为private，以防止外部代码通过new操作符直接创建该类的实例。静态工厂方法：提供一个静态方法（通常称为getInstance()），用于获取单例对象。这个方法负责检查是否已经创建过实例，如果尚未创建，则
      
                    
      • 
                    
    • 单例模式详解（DLC和spring源码中的应用）
                        CCCCVVVVCCCC
单例模式springjava
                        
      单例模式详解（DLC和spring源码中的应用）单例模式通过确保一个类只有一个实例并提供一个全局访问点来访问该实例来实现。通常，实现单例模式有两种方法：饿汉式和懒汉式。饿汉式单例在类加载时就创建了实例，所以不存在线程安全问题。懒汉式单例在第一次调用时才创建实例，并且必须通过同步机制来保证线程安全。下面是一个简单的饿汉式单例类的示例：publicclassSingleton{//创建Singleto
      
                    
      • 
                    
    • Spring源码浅析の循环依赖
                        西岭千秋雪_
源码分析springjava后端springboot
                        
      AbstractBeanFactory#doGetBean:尝试获取bean如果bean是单例的：if(mbd.isSingleton()){//尝试获取beansharedInstance=getSingleton(beanName,()->{try{//获取不到就创建returncreateBean(beanName,mbd,args);}catch(BeansExceptionex){//E
      
                    
      • 
                    
    • Spring系列之设计模式
                        johnny233
设计模式Springspring设计模式
                        
      Spring作为Java世界当之无愧的No.1开源框架，其架构设计非常优秀，使用很多设计模式。注：本文参考Spring-6.1.5版本源码；本文目录设置参考设计模式三大类来划分，Spring家族包括Spring、SpringMVC、SpringBoot、SpringCloud、SpringData等，总之Spring源码博大精深；某一种设计模式会在若干个Spring接口、类、或模块里有所体现，不可
      
                    
      • 
                    
    • Spring Boot 一个极简且完整的后台框架
                        搬砖养女人
数据库架构javaspringsqltomcat
                        
      一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
      
                    
      • 
                    
    • Spring 源码解读专栏：从零到一深度掌握 Spring 框架
                        捕风捉你
spring源码解读springjava后端
                        
      前言Spring是Java世界中无可争议的王者框架，它以其灵活、轻量、强大而著称，成为企业级开发的首选工具。然而，很多开发者在使用Spring时，往往只停留在会用的层面，对于其内部实现和设计原理知之甚少。本专栏旨在通过系统化的Spring源码解读，从实践到源码分析，再到设计模式的探讨，带你逐步揭开Spring的神秘面纱，真正掌握这款框架的精髓。专栏目标在这个专栏中，我们将通过以下几个步骤，帮助你深
      
                    
      • 
                    
    • 手写spring源码
                        augisTrench
springpythonwindows
                        
      gitlub地址：仓库地址spring源码springboot基于spring的底层去实现，在springboot进行启动时候手写启动类和tomcat，加载启动类的注解进行扫描加载全部的bean。讲数据发送给tomcat后，tomcat才能将接口的信息进行展示出来。这边就不手写了。packagecom.trench.springUtil;importcom.trench.interfa.*;imp
      
                    
      • 
                    
    • 我的2023，如履薄冰，你说我能保住这份工吗
                        
2023-年度总结
                        
      最近刷B站发现李连杰的投名状电影片段配合上void这首曲子，还挺魔性的，看了挺上头。也有不少据此二创的视频，都还挺好玩的。感觉用这个来总结2023似乎也挺恰当。我想从技术成长和生活两方面来聊一聊我的2023。技术成长今年写的系列教程很少，总结起来就三个：年初完结了gRPC系列。4、5月份的时候完善了之前的MySQL系列。7月份开始连载Spring源码系列。相比于往年，今年的技术更新确实慢了很多，有
      
                    
      • 
                    
    • Spring源码笔记之SpringIOC--（3）什么是BeanFactory？
                        冷雨夜中漫步
spring全家桶spring笔记java
                        
      什么是BeanFactory？BeanFactory是SpringIOC的最顶层接口，涵盖了IOC容器最基本的操作。ListableBeanFactory、ConfigurableBeanFactory提供了IOC容器获取所有Bean、配置Bean的额外能力。所有BeanFactory的实现类持有所有Bean的定义BeanDefinition，用一个唯一的字符串（即Bean的名字）区分。BeanF
      
                    
      • 
                    
    • redo log —— MySQL宕机时数据不丢失的原理
                        天堂2013
MySQLMySQLredologjava
                        
      扫描下方二维码或者微信搜索公众号菜鸟飞呀飞，即可关注微信公众号，阅读更多Spring源码分析、Java并发编程和Netty源码系列文章。问题在开始阅读本文之前，可以先思考一下下面两个问题。众所周知，MySQL有四大特性：ACID，其中D指的是持久性（Durability），它的含义是MySQL的事务一旦提交，它对数据库的改变是永久性的，即数据不会丢失，那么MySQL究竟是如何实现的呢？MySQL数
      
                    
      • 
                    
    • 【Spring源码分析】解析配置类-ConfigurationClassPostProcessor源码分析
                        假正经的小柴
Java源码分析spring数据库前端
                        
      阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑【Spring源码分析】从源码角度去熟悉依赖注入（一）【Spring源码分析】从源码角度去熟悉依赖注入（二）【Spring源码分析】@Resource注入的源码解析【Spring源码分析
      
                    
      • 
                    
    • 【手撕Spring源码】容器与Bean
                        十八岁讨厌编程
手撕框架源码springspringbootjava源码
                        
      文章目录什么是容器？容器接口容器实现BeanFactory容器实现ApplicationContext容器实现Bean的生命周期模板方法设计模式Bean后处理器BeanFactory后处理器有关后处理器(PostProcessor)的调用时期Aware接口和InitializingBean接口初始化和销毁Scope什么是容器？Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种用于
      
                    
      • 
                    
    • spring源码解析流程，一步一步在源码加注释带你了解bean的加载过程
                        笨蛋CXJ
springspringjava
                        
      spring前述：spring源码环境搭建以及源码下载在文章后方有链接，可自行参考搭建，这里只是对加载过程做一个解析，spring全家桶远不止这些东东，感兴趣的小伙伴可以去官网看一下，本文将以源码加注释的方式进行过程解析，带你了解spring中bean到底是如何一步步加载完成了解重点：bean的生命周期、加载过程最终目的：学习spring源码短期内不对对你的技术有太大提升，可能只是了解到漂亮的代码
      
                    
      • 
                    
    • 【Spring源码分析】循环依赖的底层源码剖析
                        假正经的小柴
Java源码分析spring数据库java
                        
      循环依赖的底层源码剖析一、预知知识二、循环依赖的底层源码剖析1.Spring是如何存储半成品Bean的？getEarlyBeanReference方法的源码分析2.Spring是如何解决的循环依赖呢？测试3.哪些循环依赖Spring是无法解决的呢？@Async引起的循环依赖解决方案单构造注入引起的循环依赖解决方案三、总结阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spr
      
                    
      • 
                    
    • 【Spring源码分析】推断构造方法
                        假正经的小柴
Java源码分析springjava数据库
                        
      推断构造方法源码解析一、确认候选构造——AutowireAnnotationBeanPostProcessor#determineCandidateConstructors二、autowireConstructor方法源码解析三、总结阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码
      
                    
      • 
                    
    • 【Spring源码分析】@Resource注入的源码解析
                        假正经的小柴
Java源码分析springjava数据库
                        
      @Resource注入的源码解析一、绪论二、CommonAnnotationBeanPostProcessor源码分析postProcessMergedBeanDefinition源码解析postProcessProperties源码解析ResourceElement构造函数分析inject方法解析三、总结不愿看这段可跳过系列：话是针对可能是刷到这篇博客的人写的（而非订阅从头到尾跟着去阅读的）：还
      
                    
      • 
                    
    • 【Spring源码分析】Spring的启动流程源码解析
                        假正经的小柴
Java源码分析spring数据库java
                        
      阅读此需阅读下面这些博客先【Spring源码分析】Bean的元数据和一些Spring的工具【Spring源码分析】BeanFactory系列接口解读【Spring源码分析】执行流程之非懒加载单例Bean的实例化逻辑【Spring源码分析】从源码角度去熟悉依赖注入（一）【Spring源码分析】从源码角度去熟悉依赖注入（二）【Spring源码分析】@Resource注入的源码解析【Spring源码分析
      
                    
      • 
                    
    • 【Spring源码分析】37-Spring MVC的异常处理
                        一直不懂
SpringFramework源码分析
                        
      在SpringMVC中处理HTTP请求时如果抛出异常会使用DispatcherServlet#processHandlerException()处理，这个方法内部使用SpringMVC默认的注册的HandlerExceptionResolver进行处理。@NullableprotectedModelAndViewprocessHandlerException(HttpServletRequestr
      
                    
      • 
                    
    • 源码分析怎么做？
                        _tison
编程语言javaspring人工智能移动开发
                        
      近日在知乎上看到一个关于源码分析的提问《程序员阅读源码是一种什么心态？源码对编程意义何在？如何才能更好阅读代码？》，正好结合对比读完的两本讲解Spring源码的书《Spring源码深度解析（第2版）》（简称《Spring》）和《深入理解SpringMVC源代码》（简称《SpringMVC》），聊一聊阅读的体验，顺便讲一讲阅读分析怎么做、怎么写这回事。首先要明确的是，源码分析的入手点是软件而不是源代
      
                    
      • 
                    
    • 模拟mybatis实现接口依赖注入
                        瞿大官人

                        
      一、前言这一节基于前面两节mybatis中Mapper注入spring源码分析与mybatis接口依赖注入源码分析的理论，手动实现将接口放入Spring工厂中，并且能够依赖注入。二、实践这里先把已写好的类贴出来，下面会一一介绍。这篇文章的两个目的如下。image.png目的一：将TestInterface接口放入Spring的工厂中.@ComponentpublicinterfaceTestInt
      
                    
      • 
                    
    • 【Spring框架】Spring事务同步
                        小七mod
Java#Spring数据库SpringSpring事务事务同步Java事务
                        
      目录一、什么是Spring事务同步二、事务同步管理器2.1TransactionSynchronizationManager事务同步管理器2.1.1资源同步2.1.2事务同步2.1.3总结三、事务同步管理器保障事务的原理四、spring事务为何使用TransactionSynchronizationManagerspring源码实现五、TransactionSynchronization--(be
      
                    
      • 
                    
    • 浅谈SpringMVC执行过程
                        程序员日常填坑

                        
      通过深入分析Spring源码，我们知道Spring框架包括大致六大模块，如Web模块，数据库访问技术模块，面向切面模块，基础设施模块，核心容器模块和模块，其中，在Spring框架的Web模块中，又包含很多前端技术，如SpringMVC,SpringWebSocket,SpringWebPortlet等，在本篇文章中，我们主要分析SpringMVC模块，在分析SpringMVC技术时，本篇文章将通过
      
                    
      • 
                    
    • 手写Spring之BeanFactory(三级缓存)
                        pq217

                        
      概述看了好久spring源码，有些地方理解的不深刻，决定手写一下BeanFactory来加深理解规范spring中最主要的bean工厂实现就是DefaultListableBeanFactory，看一下它实现的接口publicclassDefaultListableBeanFactoryextendsAbstractAutowireCapableBeanFactoryimplementsConfi
      
                    
      • 
                    
    • 专治不会看源码的毛病--spring源码解析AOP篇
                        八年码农

                        
      公众号编程一生昨天有个大牛说我啰嗦，眼光比较细碎，看不到重点。太他爷爷的有道理了！要说看人品，还是女孩子强一些。原来记得看到一个男孩子的抱怨，说怎么两人刚刚开始在一起，女孩子在心里就已经和他过完了一辈子。哥哥们，不想这么远行吗？看看何洁，看看带着俩娃跳楼的妈妈。所以现在的女孩子是很明白的，有些男孩子个子不高，其貌不扬，但是一看那人品气质就知道能找个不错的女盆友。不过要说看人的技术能力，男孩子确实更
      
                    
      • 
                    
    • Spring源码剖析（二） - Bean对象的三级缓存
                        Jasper_Chen

                        
      前面讲到Spring在创建Bean的过程中使用了三级缓存来对Bean对象进行缓存。这个三级缓存是用来解决对象的循环依赖问题。什么是对象的循环依赖？举个例子：classA{privateBb;privateCc;}classB{privateAa;}classC{privateAa;}classA中引用了B和C，而B和C中又引用了A。那么在spring中创建Bean对象时，需要先创建对象，然后对其属
      
                    
      • 
                    
    • 联合使用Spring的@Transactional和@Async注解的思考
                        API调用Engineer
Programmingspringjava后端
                        
      背景在工作过程中因为一些特殊的原因，想通过@Transactional和@Async注解来实现特殊的业务场景。不过在使用的过程中遇到了一些出乎意料的情况，也是因为对Spring源码框架的不熟悉，在经过几天的断点调试和csdn结合的方式终于梳理清楚遇到的问题的脉络，以及产生意料之外情况的原因。故在此做一个总结，以及分享一下学习到的相关知识点。至于为什么要联合使用@Transactional和@Asy
      
                    
      • 
                    
    • idea搭建spring5.3.x源码环境
                        泗水长流
springspring5.3.x源码gradle安装配置spring5.3.x源码环境spring源码搭建
                        
      1.写在前面的话碰到了不少想阅读或者学习spring源码的同学，但是第一步搭建这个源码阅读环境就能难倒了一大批人。下面我就以spring5.3.x这个源码分支，来具体演示一下搭建过程。2.下载源码下载源码这一步，说实话，由于某些原因，会导致我们用git做clone的时候，老是中断，clone不下来。所以我们可以先把github的源码，复制到gitee上，然后从gitee上来下载。打开spring的
      
                    
      • 
                    
    • spring源码之IOC容器资源定位过程
                        rofeya

                        
      铺垫平时我们在使用spring进行项目实践的时候，对于底层的某些实现逻辑大部分都被忽略过，但是对底层实现的了解却往往是我们在实践中解决出现的问题最有利的帮助。以下是我阅读源码进行并整理的一些学习笔记。准备工作在开发环境中构建自己的spring源码环境，本人是使用IDEA开发工具，构建步骤网上一搜一大把，下面就附上一个在IDEA搭建spring源码环境的链接：https://blog.csdn.ne
      
                    
      • 
                    
    • 自己整理的一些关于Spring源码的总结，面试之前回来看看（不定期更新）
                        学到头冷

                        
      Spring中的设计模式？1.工厂2.单例（看看内部枚举实现的单例）3.委派（delegate）4.模板方法（refresh方法算一个）5.策略模式6.访问者模式7.责任链模式（beanPostProcess这些后置处理器执行）Spring事务是怎么运作的？待更新Spring中的obtainfreshbeanfactory？（XML方式BeanDefinition如何注册）1.newDefault
      
                    
      • 
                    
    • Spring源码深度解析：十三、JdbcTemplate 的源码分析
                        代码的知行者
Spring源码springjava后端
                        
      一、前言文章目录：Spring源码深度解析：文章目录二、JdbcTemplateJdbcTemplate是SpringTemplate设置模式中的一员。类似的还有TransactionTemplate、MongoTemplate等。通过JdbcTemplate我们可以使得Spring访问数据库的过程简单化。在JdbcTemplate中执行SQL语句的方法大致分为3类：execute：可以执行所有S
      
                    
      • 
                                
    • Java实现的基于模板的网页结构化信息精准抽取组件：HtmlExtractor
                                    yangshangchuan
信息抽取HtmlExtractor精准抽取信息采集
                                    
      HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件，本身并不包含爬虫功能，但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。 
   
HtmlExtractor是为大规模分布式环境设计的，采用主从架构，主节点负责维护抽取规则，从节点向主节点请求抽取规则，当抽取规则发生变化，主节点主动通知从节点，从而能实现抽取规则变化之后的实时动态生效。 
如
      
                                
      • 
                                
    • java编程思想 -- 多态
                                    百合不是茶
java多态详解
                                    
      一: 向上转型和向下转型 
面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。父类：人    子类：男人向上转型： Person p = new Man() ; //向上转型不需要强制类型转化向下转型： Man man =
      
                                
      • 
                                
    • [自动数据处理]稳扎稳打,逐步形成自有ADP系统体系
                                    comsci
dp
                                    
       
      对于国内的IT行业来讲,虽然我们已经有了"两弹一星",在局部领域形成了自己独有的技术特征,并初步摆脱了国外的控制...但是前面的路还很长.... 
 
      首先是我们的自动数据处理系统还无法处理很多高级工程...中等规模的拓扑分析系统也没有完成,更加复杂的
      
                                
      • 
                                
    • storm 自定义 日志文件
                                    商人shang
stormclusterlogback
                                    
      Storm中的日志级级别默认为INFO，并且，日志文件是根据worker号来进行区分的，这样，同一个log文件中的信息不一定是一个业务的，这样就会有以下两个需求出现： 
1. 想要进行一些调试信息的输出 
2. 调试信息或者业务日志信息想要输出到一些固定的文件中 
  
不要怕，不要烦恼，其实Storm已经提供了这样的支持，可以通过自定义logback 下的 cluster.xml 来输
      
                                
      • 
                                
    • Extjs3 SpringMVC使用 @RequestBody 标签问题记录
                                    21jhf

                                    
      springMVC使用 @RequestBody(required = false) UserVO userInfo 
传递json对象数据，往往会出现http 415，400,500等错误，总结一下需要使用ajax提交json数据才行，ajax提交使用proxy，参数为jsonData，不能为params；另外，需要设置Content-type属性为json，代码如下： 
（由于使用了父类aaa
      
                                
      • 
                                
    • 一些排错方法
                                    文强chu
方法
                                    
      1、java.lang.IllegalStateException: Class invariant violation 
at org.apache.log4j.LogManager.getLoggerRepository(LogManager.java:199)at org.apache.log4j.LogManager.getLogger(LogManager.java:228) 
at o
      
                                
      • 
                                
    • Swing中文件恢复我觉得很难
                                    小桔子
swing
                                    
             我那个草了！老大怎么回事，怎么做项目评估的？只会说相信你可以做的，试一下，有的是时间！ 
       用java开发一个图文处理工具，类似word，任意位置插入、拖动、删除图片以及文本等。文本框、流程图等，数据保存数据库，其余可保存pdf格式。ok,姐姐千辛万苦，
      
                                
      • 
                                
    • php 文件操作
                                    aichenglong
PHP读取文件写入文件
                                    
      1 写入文件 
@$fp=fopen("$DOCUMENT_ROOT/order.txt", "ab"); 
if(!$fp){ 
 echo "open file error" ; 
 
exit; 
} 
$outputstring="date:"." \t tire:".$tire."
      
                                
      • 
                                
    • MySQL的btree索引和hash索引的区别
                                    AILIKES
数据结构mysql算法
                                    
      Hash 索引结构的特殊性，其 检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。           
可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢
      
                                
      • 
                                
    • JAVA的抽象--- 接口 --实现
                                    百合不是茶

                                    
      抽象 接口 实现接口 
  
//抽象 类 ,方法 
  
//定义一个公共抽象的类 ,并在类中定义一个抽象的方法体 
抽象的定义使用abstract 
  
abstract class A 定义一个抽象类 例如： 
//定义一个基类
public abstract class A{ 
  
  
//抽象类不能用来实例化，只能用来继承 
//
      
                                
      • 
                                
    • JS变量作用域实例
                                    bijian1013
作用域
                                    
      <script> 
    var scope='hello'; 
    function a(){ 
       console.log(scope);   //undefined 
       var scope='world'; 
       console.log(scope);   //world 
       console.log(b);      
      
                                
      • 
                                
    • TDD实践（二）
                                    bijian1013
javaTDD
                                    
      实践题目：分解质因数 
Step1： 
单元测试： 
package com.bijian.study.factor.test;

import java.util.Arrays;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.Test;

import com.bijian.
      
                                
      • 
                                
    • [MongoDB学习笔记一]MongoDB主从复制
                                    bit1129
mongodb
                                    
      MongoDB称为分布式数据库，主要原因是1.基于副本集的数据备份， 2.基于切片的数据扩容。副本集解决数据的读写性能问题，切片解决了MongoDB的数据扩容问题。 
  事实上，MongoDB提供了主从复制和副本复制两种备份方式，在MongoDB的主从复制和副本复制集群环境中，只有一台作为主服务器，另外一台或者多台服务器作为从服务器。   本文介绍MongoDB的主从复制模式，需要指明
      
                                
      • 
                                
    • 【HBase五】Java API操作HBase
                                    bit1129
hbase
                                    
      import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.ha
      
                                
      • 
                                
    • python调用zabbix api接口实时展示数据
                                    ronin47

                                    
      zabbix api接口来进行展示。经过思考之后，计划获取如下内容：     1、  获得认证密钥     2、  获取zabbix所有的主机组     3、  获取单个组下的所有主机     4、  获取某个主机下的所有监控项  
      
                                
      • 
                                
    • jsp取得绝对路径
                                    byalias
绝对路径
                                    
      在JavaWeb开发中，常使用绝对路径的方式来引入JavaScript和CSS文件，这样可以避免因为目录变动导致引入文件找不到的情况，常用的做法如下： 
 
一、使用${pageContext.request.contextPath} 
 
　　代码” ${pageContext.request.contextPath}”的作用是取出部署的应用程序名，这样不管如何部署，所用路径都是正确的。 
 

      
                                
      • 
                                
    • Java定时任务调度：用ExecutorService取代Timer
                                    bylijinnan
java
                                    
      《Java并发编程实战》一书提到的用ExecutorService取代Java Timer有几个理由，我认为其中最重要的理由是： 
如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以 TimerTask抛出的未检查的异常会终止timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被
      
                                
      • 
                                
    • SQL 优化原则
                                    chicony
sql
                                    
        
一、问题的提出 
　在应用系统开发初期，由于开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各种写法的性能优劣，但是如果将应用系统提交实际应用后，随着数据库中数据的增加，系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍，可见对于一个系统
      
                                
      • 
                                
    • java 线程弹球小游戏
                                    CrazyMizzz
java游戏
                                    
      最近java学到线程，于是做了一个线程弹球的小游戏，不过还没完善 
 
 这里是提纲 
 1.线程弹球游戏实现 
 1.实现界面需要使用哪些API类 
 JFrame 
 JPanel 
 JButton 
 FlowLayout 
 Graphics2D 
 Thread 
 Color 
 ActionListener 
 ActionEvent 
 MouseListener 
 Mouse
      
                                
      • 
                                
    • hadoop jps出现process information unavailable提示解决办法
                                    daizj
hadoopjps
                                    
      hadoop jps出现process information unavailable提示解决办法       
jps时出现如下信息： 
3019 -- process information unavailable3053 -- process information unavailable2985 -- process information unavailable2917 -- 
      
                                
      • 
                                
    • PHP图片水印缩放类实现
                                    dcj3sjt126com
PHP
                                    
        
<?php
class Image{

	private $path;


	function __construct($path='./'){
		$this->path=rtrim($path,'/').'/';
	}

	//水印函数，参数：背景图，水印图，位置，前缀,TMD透明度

	public function water($b,$l,$pos
      
                                
      • 
                                
    • IOS控件学习：UILabel常用属性与用法
                                    dcj3sjt126com
iosUILabel
                                    
      参考网站： 
http://shijue.me/show_text/521c396a8ddf876566000007 
http://www.tuicool.com/articles/zquENb 
http://blog.csdn.net/a451493485/article/details/9454695 
http://wiki.eoe.cn/page/iOS_pptl_artile_281
      
                                
      • 
                                
    • 完全手动建立maven骨架
                                    eksliang
javaeclipseWeb
                                    
      建一个 JAVA 项目 ： 
mvn archetype:create 
-DgroupId=com.demo 
-DartifactId=App 
[-Dversion=0.0.1-SNAPSHOT] 
[-Dpackaging=jar] 
 
 
建一个 web 项目 ： 
mvn archetype:create 
-DgroupId=com.demo 
-DartifactId=web-a
      
                                
      • 
                                
    • 配置清单
                                    gengzg
配置
                                    
      1、修改grub启动的内核版本
vi /boot/grub/grub.conf
将default 0改为1

拷贝mt7601Usta.ko到/lib文件夹

拷贝RT2870STA.dat到 /etc/Wireless/RT2870STA/文件夹

拷贝wifiscan到bin文件夹，chmod 775 /bin/wifiscan
拷贝wifiget.sh到bin文件夹，chm
      
                                
      • 
                                
    • Windows端口被占用处理方法
                                    huqiji
windows
                                    
      以下文章主要以80端口号为例，如果想知道其他的端口号也可以使用该方法..........................1、在windows下如何查看80端口占用情况?是被哪个进程占用?如何终止等.        这里主要是用到windows下的DOS工具,点击"开始"--"运行",输入&
      
                                
      • 
                                
    • 开源ckplayer 网页播放器， 跨平台(html5, mobile)，flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 ！
                                    天梯梦
mobile
                                    
      CKplayer，其全称为超酷flv播放器，它是一款用于网页上播放视频的软件，支持的格式有：http协议上的flv,f4v,mp4格式，同时支持rtmp视频流格 式播放，此播放器的特点在于用户可以自己定义播放器的风格，诸如播放/暂停按钮，静音按钮，全屏按钮都是以外部图片接口形式调用，用户根据自己的需要制作 出播放器风格所需要使用的各个按钮图片然后替换掉原始风格里相应的图片就可以制作出自己的风格了，
      
                                
      • 
                                
    • 简单工厂设计模式
                                    hm4123660
java工厂设计模式简单工厂模式
                                    
             简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式。是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。 
      
                                
      • 
                                
    • maven笔记
                                    zhb8015
maven
                                    
      跳过测试阶段： 
mvn package -DskipTests 
临时性跳过测试代码的编译： 
mvn package -Dmaven.test.skip=true 
  
maven.test.skip同时控制maven-compiler-plugin和maven-surefire-plugin两个插件的行为，即跳过编译，又跳过测试。 
  
指定测试类 
mvn test
      
                                
      • 
                                
    • 非mapreduce生成Hfile，然后导入hbase当中
                                    Stark_Summer
maphbasereduceHfilepath实例
                                    
      最近一个群友的boss让研究hbase，让hbase的入库速度达到5w+/s，这可愁死了，4台个人电脑组成的集群，多线程入库调了好久，速度也才1w左右，都没有达到理想的那种速度，然后就想到了这种方式，但是网上多是用mapreduce来实现入库，而现在的需求是实时入库，不生成文件了，所以就只能自己用代码实现了，但是网上查了很多资料都没有查到，最后在一个网友的指引下，看了源码，最后找到了生成Hfile
      
                                
      • 
                                
    • jsp web tomcat 编码问题
                                    王新春
tomcatjsppageEncode
                                    
      今天配置jsp项目在tomcat上，windows上正常，而linux上显示乱码，最后定位原因为tomcat 的server.xml 文件的配置，添加 URIEncoding 属性： 
 
 

      <Connector port="8080" protocol="HTTP/1.1" 
               connectionTi
      
                                
      •