大龄码农生活
大龄码农生活

spring bean生命周期三---Spring Bean populateBean 属性填充阶段

目录

 

前言

一、populateBean - 概述

二、populateBean - 详解

2.1. 属性填充判断 

2.2、自动装配 ：autowiring自动装配的

2.2.1、自动装配 - autowireByName

2.2.2、 自动装配 - autowireByType

2.3、排除规则 - unsatisfiedNonSimpleProperties

3、@Autowired 和 @Resource 的注入工作

3.1、第六次调用后置处理器  InstantiationAwareBeanPostProcessor#postProcessProperties

3.2、CommonAnnotationBeanPostProcessor#postProcessPropertyValues

3.3、AutowiredAnnotationBeanPostProcessor #postProcessPropertyValues

3.4、需要依赖注入的对象 DefaultListableBeanFactory#resolveDependency 

4. applyPropertyValues

三、总结

前言

本文是笔者阅读Spring源码的记录文章，由于本人技术水平有限，在文章中难免出现错误，如有发现，感谢各位指正。

我们在上一篇文章：spring bean生命周期二---Spring Bean实例化（ Instantiation）阶段 中完成了bean的实例化过程 ，但是属性内容还没有注入，本文就是将bean的属性进行注入的过程。

一、populateBean - 概述

我们这里先整体过一遍代码，后面进行每一步的详细解读。

// AbstractAutowireCapableBeanFactory#populateBean
	// beanName : bean 的name
	// mbd  :  bean的定义信息
	// bw  : bean实例的包装类型，里面有bean的实例
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			 没有属性抛出异常
			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;
			}
		}
		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		//
		boolean continueWithPropertyPopulation = true;
         //mbd.isSynthetic() 合成类
		//todo 第五次---判断属性是否填充：InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
		// 给InstantiationAwareBeanPostProcessor最后一次机会在属性设置前来改变bean
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			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定义资源时为BeanDefiniton中设置的属性值
		//这个是程序员在 bd中 写入的属性rootBeanDefinition.getPropertyValues().add("type","男的");
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		 2. 自动装配 ：autowiring自动装配的。根据名称或类型自动注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {


			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

			// Add property values based on autowire by name if applicable.
			//根据Bean名称进行autowiring自动装配处理
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}

			// Add property values based on autowire by type if applicable.
			//根据Bean类型进行autowiring自动装配处理
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}

			pvs = newPvs;
		}
		//对非autowiring的属性进行依赖注入处理
		// 后处理器已经初始化
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

		if (hasInstAwareBpps || needsDepCheck) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				//TODO 获取的bean所有后置处理器找到 所有需要注入的属性
				// 这里会进行 @Autowired 和 @Resource 的注入工作
				// 属性填充InstantiationAwareBeanPostProcessor
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						//下面是完成属性注入的
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						// 如果postProcessProperties 返回null，再调用 postProcessPropertyValues这个过时的方法
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				// 依赖检查，对应 depends-on 属性，3.0 已弃用
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}
		if (pvs != null) {
			 4. 将属性应用到bean中
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

从上看下来，整个流程如下：

  1. InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation 方法，可以决定程序是否继续进行属性填充。只要有一个 InstantiationAwareBeanPostProcessor 返回false，都会终止属性填充的过程。这个过程属于实例化 后置阶段上上文已经描述过了
  2. 自动装配 ：autowiring自动装配的。根据注入类型（name或type），提取依赖的bean，并统一存入到 propertyValues 中。
  3. @Autowired 和 @Resource 的属性注入工作，调用后置处理器应用 InstantiationAwareBeanPostProcessor#postProcessProperties 方法，对属性获取完毕填充前对属性的再次处理。

         有两个实现类型 ：1、AutowiredAnnotationBeanPostProcessor 中的实现类 处理 @Autowired 注解的

                                        2、AutowiredAnnotationBeanPostProcessor 中的实现类 处理 @Autowired 注解的

  1. 将所有 propertyValues 中的属性填充至 BeanWrapper 中。

在这里方法里按照如下顺序调用了后处理器

  • InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation ： 是否使用 InstantiationAwareBeanPostProcessor进行属性装配
  • InstantiationAwareBeanPostProcessor.postProcessProperties ： 进行属性装配

二、populateBean - 详解

2.1. 属性填充判断 

这个的上文中已经描述过了这里就简单贴出代码

 //mbd.isSynthetic() 合成类
		//todo 第五次---判断属性是否填充：InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation
		// 给InstantiationAwareBeanPostProcessor最后一次机会在属性设置前来改变bean
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

如下，这里调用了InstantiationAwareBeanPostProcessor #postProcessAfterInstantiation 方法来决定是否继续注入属性。该方法正常返回true。如果返回false 则将取消对此bean调用任何后续的InstantiationAwareBeanPostProcessor 方法。

2.2、自动装配 ：autowiring自动装配的

在下面这段代码中，对 autowiring自动装配中根据名称或类型自动注入的种类进行自动装配。


    		 2. 自动装配 ：autowiring自动装配的。根据名称或类型自动注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {


			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

			// Add property values based on autowire by name if applicable.
			//根据Bean名称进行autowiring自动装配处理
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}

			// Add property values based on autowire by type if applicable.
			//根据Bean类型进行autowiring自动装配处理
			if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}

			pvs = newPvs;
		}

这一段代码的目的是，如果bean在声明的时候指定了自动注入类型是 byName或者byType，则会根据这个规则，对 bean内部的排除某些特定的属性(排除规则后面详解)， 进行byName 或者 byType的自动装配。

2.2.1、自动装配 - autowireByName

//根据名称对属性进行自动依赖注入
	protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

		//对Bean对象中非简单属性(不是简单继承的对象，如8中原始类型，字符串，URL等都是简单属性)进行处理
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			//如果Spring IOC容器中包含指定名称的Bean
			if (containsBean(propertyName)) {
				//调用getBean方法向IOC容器索取指定名称的Bean实例，迭代触发属性的初始化和依赖注入
				Object bean = getBean(propertyName);
				//为指定名称的属性赋予属性值
				pvs.add(propertyName, bean);
				//指定名称属性注册依赖Bean名称，进行属性依赖注入
				registerDependentBean(propertyName, beanName);
				if (logger.isDebugEnabled()) {
					logger.debug("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");
				}
			}
		}
	}

可以看到，byName 的处理逻辑很简单，一句话概括，获取需要注入的bean然后递归调用getBean获取bean进行注入。 关于 unsatisfiedNonSimpleProperties 方法在后面有讲解。

2.2.2、 自动装配 - autowireByType

byType 的装配和 byName 对我们感觉来说似乎没什么差异，但是在实际实现上却截然不同，代码也复杂的多。具体代码如下：

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

		//获取用户定义的类型转换器
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}

		//存放解析的要注入的属性
		Set autowiredBeanNames = new LinkedHashSet<>(4);
		//对Bean对象中非简单属性(不是简单继承的对象，如8中原始类型，字符
		//URL等都是简单属性)进行处理
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			try {
				//获取指定属性名称的属性描述器
				PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
				// Don't try autowiring by type for type Object: never makes sense,
				// even if it technically is a unsatisfied, non-simple property.
				//不对Object类型的属性进行autowiring自动依赖注入
				if (Object.class != pd.getPropertyType()) {
					//获取属性的setter方法
					MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
					// Do not allow eager init for type matching in case of a prioritized post-processor.
					//检查指定类型是否可以被转换为目标对象的类型
					boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
					//创建一个要被注入的依赖描述
					DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
					//根据容器的Bean定义解析依赖关系，返回所有要被注入的Bean对象
					Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
					if (autowiredArgument != null) {
						//为属性赋值所引用的对象
						pvs.add(propertyName, autowiredArgument);
					}
					for (String autowiredBeanName : autowiredBeanNames) {
						//指定名称属性注册依赖Bean名称，进行属性依赖注入
						registerDependentBean(autowiredBeanName, beanName);
						if (logger.isDebugEnabled()) {
							logger.debug("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);
			}
		}
	}

下面提两点 ：

  1. 关于 registerDependentBean 方法，我们在之前的文章中有过解释，详阅 Spring 源码分析三 ：bean的加载① - doGetBean概述

  2. 这里面的主要的逻辑被封装到了DefaultListableBeanFactory#resolveDependency 方法的具体实现我们在后继查看。目前我所知另外调用地方：

    1. AutowiredAnnotationBeanPostProcessor#postProcessProperties  中注入处理 @Autowired 注入的时候也调用了该方法
    2. ConstructorResolver#autowireConstructor 在 resolveAutowiredArgument( methodParam, beanName, autowiredBeanNames, converter, fallback); 时也调用了该方法。

2.3、排除规则 - unsatisfiedNonSimpleProperties

在autowireByName 和 autowireByType方法中，都有如下一行代码

String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);

在 unsatisfiedNonSimpleProperties 方法中，对Bean 的属性进行了过滤，得到了需要自动装配的属性。我们来详细看看里面的内容。

protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
		Set result = new TreeSet<>();
		// 获取bean 的property 属性
		PropertyValues pvs = mbd.getPropertyValues();
		// 获取 bw 中的属性描述
		PropertyDescriptor[] pds = bw.getPropertyDescriptors();
		for (PropertyDescriptor pd : pds) {
			// if  pd属性具有set方法 && 依赖检查中没有被忽略 && 没有被配置成 property 属性 && 不是简单类型
			if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
					!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
				// 添加到需要装配的集合中
				result.add(pd.getName());
			}
		}
		// 返回需要自动装配的bean集合
		return StringUtils.toStringArray(result);
	}

可以看到过滤条件

  1. 装配 属性具有set 方法： 因为后面的装配是通过set方法装配
  2. 依赖检查中没有被忽略isExcludedFromDependencyCheck(pd) 
  3. 没有被property 属性，因为这里property 会被单独处理，不需要在这里保存
  4. 不是简单类型，即不属于Void、void、 Enum、CharSequence、Number、Date、Temporal、URI、URL、Locale、Class 和 八大基本数据类型及其包装类型。

3、@Autowired 和 @Resource 的注入工作

这里只要时候  InstantiationAwareBeanPostProcessor#postProcessProperties 后置处理器处理

PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				//TODO 获取的bean所有后置处理器找到 所有需要注入的属性
				// 这里会进行 @Autowired 和 @Resource 的注入工作
				// 属性填充InstantiationAwareBeanPostProcessor
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						//下面是完成属性注入的
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						// 如果postProcessProperties 返回null，再调用 postProcessPropertyValues这个过时的方法
						if (pvs == null) {
							return;
						}
					}
				}
			}

3.1、第六次调用后置处理器  InstantiationAwareBeanPostProcessor#postProcessProperties

这里通过 InstantiationAwareBeanPostProcessor #postProcessPropertyValues 方法完成了属性的注入。

1、AutowiredAnnotationBeanPostProcessor #postProcessPropertyValues中的实现类 处理 @Autowired 注解和@Value 注解的自动注入功能。

 2、CommonAnnotationBeanPostProcessor#postProcessPropertyValues中的实现类 处理  @Resource注解、@PostConstruct等通用注解。

3.2、CommonAnnotationBeanPostProcessor#postProcessPropertyValues

//处理属性值
	@Override
	public PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

		//获取@Resource注解中配置的属性值元数据
		InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
		try {
			metadata.inject(bean, beanName, pvs);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
		}
		return pvs;
	}

获取@Resource注解中配置的属性值元数据

这里主要是对 @Resource 进行注入findResourceMetadata在MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition的时候执行过.

所以这里, 大概率是从缓存中拿取结果, 然后进行注入操作. 事实上, 也确实如此.

/获取@Resource注解中配置的属性值元数据
	private InjectionMetadata findResourceMetadata(String beanName, final Class clazz, @Nullable PropertyValues pvs) {
		// Fall back to class name as cache key, for backwards compatibility with custom callers.
		String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
		// Quick check on the concurrent map first, with minimal locking.
		//首先从容器缓存中查找
		InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
		if (InjectionMetadata.needsRefresh(metadata, clazz)) {
			synchronized (this.injectionMetadataCache) {
				metadata = this.injectionMetadataCache.get(cacheKey);
				if (InjectionMetadata.needsRefresh(metadata, clazz)) {
					if (metadata != null) {
						metadata.clear(pvs);
					}
					metadata = buildResourceMetadata(clazz);
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
			}
		}
		return metadata;
	}

metadata.inject(bean, beanName, pvs);

	public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
		//
		Collection checkedElements = this.checkedElements;
		Collection elementsToIterate =
				(checkedElements != null ? checkedElements : this.injectedElements);
		if (!elementsToIterate.isEmpty()) {
			boolean debug = logger.isDebugEnabled();
			for (InjectedElement element : elementsToIterate) {
				if (debug) {
					logger.debug("Processing injected element of bean '" + beanName + "': " + element);
				}
				element.inject(target, beanName, pvs);
			}
		}
	}

 

 

element.inject(target, beanName, pvs);的实现类有三个

这里最终会调用本类中的方法:

org.springframework.beans.factory.annotation.InjectionMetadata.InjectedElement#inject 方法

protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
				throws Throwable {

			//这里处理通过字段注入
			if (this.isField) {
				Field field = (Field) this.member;
				ReflectionUtils.makeAccessible(field);
				field.set(target, getResourceToInject(target, requestingBeanName));
			}
			else {
				if (checkPropertySkipping(pvs)) {
					return;
				}
				try {
					//这里处理通过方法注入
					Method method = (Method) this.member;
					ReflectionUtils.makeAccessible(method);
					method.invoke(target, getResourceToInject(target, requestingBeanName));
				}
				catch (InvocationTargetException ex) {
					throw ex.getTargetException();
				}
			}
		}

3.3、AutowiredAnnotationBeanPostProcessor #postProcessPropertyValues

大概逻辑是，获取被 @Autowired 修饰的 属性或者方法，如果是属性，则通过getBean 获取bean并注入，如果是方法，则获取方法参数后，invoke 方法(调用该方法，因为我们一般写的都是set方法，给属性注入赋值)。

//处理类中的属性
	@Override
	public PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {

		//获取指定类中autowire相关注解的元信息
		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
		try {
			//对Bean的属性进行自动注入
			metadata.inject(bean, beanName, pvs);
		}
		catch (BeanCreationException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
		}
		return pvs;
	}

这里主要是对 @Autowired 和 @Value 进行注入的. InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);

findAutowiringMetadata在MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition的时候执行过.

所以此处, 是从缓存中拿取结果, 然后进行注入操作.

最终会调用本类中的方法:

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject

//对字段进行注入
		@Override
		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
			//获取注入元素对象
			Field field = (Field) this.member;
			Object value;
			//如果当前对象在容器中被缓存 默认为false.
			if (this.cached) {
				//根据Bean名称解析缓存中的字段值
				value = resolvedCachedArgument(beanName, this.cachedFieldValue);
			}
			//如果当前对象没有被容器缓存
			else {
				//创建一个字段依赖描述符
				DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
				desc.setContainingClass(bean.getClass());
				Set autowiredBeanNames = new LinkedHashSet<>(1);
				Assert.state(beanFactory != null, "No BeanFactory available");
				//获取容器中的类型转换器
				TypeConverter typeConverter = beanFactory.getTypeConverter();
				try {
					//根据容器中Bean定义，解析指定的依赖关系，获取需要依赖注入的对象
					value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
				}
				catch (BeansException ex) {
					throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
				}
				//线程同步，确保容器中数据一致性
				synchronized (this) {
					//如果当前对象没有被容器缓存
					if (!this.cached) {
						//获取到了当前对象的依赖对象，并且required属性为true
						if (value != null || this.required) {
							this.cachedFieldValue = desc;
							//为指定Bean注册依赖Bean
							registerDependentBeans(beanName, autowiredBeanNames);
							if (autowiredBeanNames.size() == 1) {
								String autowiredBeanName = autowiredBeanNames.iterator().next();
								//如果容器中有指定名称的Bean对象
								if (beanFactory.containsBean(autowiredBeanName)) {
									// 依赖对象类型和字段类型匹配，默认按类型注入
									if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
										//创建一个依赖对象的引用，同时缓存
										this.cachedFieldValue = new ShortcutDependencyDescriptor(
												desc, autowiredBeanName, field.getType());
									}
								}
							}
						}
						//如果获取的依赖关系为null，且获取required属性为false
						else {
							//将字段值的缓存设置为null
							this.cachedFieldValue = null;
						}
						//容器已经对当前字段的值缓存
						this.cached = true;
					}
				}
			}
			//如果字段依赖值不为null
			if (value != null) {
				//显式使用JDK的反射机制，设置自动的访问控制权限为允许访问
				ReflectionUtils.makeAccessible(field);
				//TODO 为Bean对象的字段设置值 完成了属性填充
				field.set(bean, value);
			}
		}
	}

3.4、需要依赖注入的对象 DefaultListableBeanFactory#resolveDependency 

根据容器中Bean定义，解析指定的依赖关系，获取需要依赖注入的对象。这里是很重要的方法在很多地方都使用到

 value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);

org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency

	@Override
	@Nullable
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
         // 针对不同类型的不同处理
		if (Optional.class == descriptor.getDependencyType()) {
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		//延迟加载
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		//
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			return new Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName);
		}
		else {
			//ToDO 这个一般为空 这个是特殊情况 处理bean是否懒加载，如果懒加载，创建一个代理对象注入bean
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
				// 下面是正常情况
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}

上面的逻辑比较清晰，对一些特殊的类型进行特殊处理，一般的通用处理都会调用 doResolveDependency 方法。这里我们不去关注特殊类型的处理，下面再来看看
DefaultListableBeanFactory#doResolveDependency 方法，代码如下。

DefaultListableBeanFactory#doResolveDependency

	@Nullable
	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			//非正常情况
			// 尝试获取缓存
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				// 存在缓存直接返回
				return shortcut;
			}

			//获得需要注入属性的类型
			Class type = descriptor.getDependencyType();
			// 取值@Value注解中的value属性中的值，这里取出的值是未经修改的值，即带有 ${} 标签的值。如果descriptor未被@Value标注，则返回null
			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
			if (value != null) {
				// 到这里说明属性被 @Value 注解修饰了，这里是解析 @Value 注解的逻辑
				// 如果value不为nul
				if (value instanceof String) {
					// 处理占位符如${}，做占位符的替换(不解析SP EL表达式)
					String strVal = resolveEmbeddedValue((String) value);
					BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
					//解析SP EL(如#{})
					value = evaluateBeanDefinitionString(strVal, bd);
				}
				// 类型转换，把解析出来的结果转成type类型
				TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
				return (descriptor.getField() != null ?
						converter.convertIfNecessary(value, type, descriptor.getField()) :
						converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
			}

			//TODO 对集合类型进行处理，包括，Array、Collection、Map。后面详解
			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
			if (multipleBeans != null) {
				// 如果解析出来集合类型，则直接返回
				return multipleBeans;
			}

			//调用查找所有类型为type的实例，存放在matchingBeans 
			//  (在 resolveMultipleBeans 方法中也是核心也是调用该方法)。下面详解
			Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (matchingBeans.isEmpty()) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			String autowiredBeanName;
			Object instanceCandidate;

			//TODO 这个是处理 这个是根据 类型找到多个bean(也就是实现类有多个)
			// 如果有多个bean 则在按照名字来匹配多个bean 找出来一个bean 用来注入
			if (matchingBeans.size() > 1) {
				// 按以下顺序，找到符合条件的就直接返回
				// 1. 挑选出被标识为primary的bean
				// 2. 挑选标识了@Priority，且先级级最高的bean。可以不标识，一旦标识，不允许同一优先级的存在
				autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
				if (autowiredBeanName == null) {
					if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
						// 非集合类，找到了多个符合条件的Bean，抛出异常
						return descriptor.resolveNotUnique(type, matchingBeans);
					}
					else {
						// In case of an optional Collection/Map, silently ignore a non-unique case:
						// possibly it was meant to be an empty collection of multiple regular beans
						// (before 4.3 in particular when we didn't even look for collection beans).
						return null;
					}
				}
				//根据名字从 根据类型的获得的matchingBeans 找到bean
				instanceCandidate = matchingBeans.get(autowiredBeanName);
			}
			else {
				// We have exactly one match.
				// 如果只找到了唯一匹配的元素，则直接使用
				Map.Entry entry = matchingBeans.entrySet().iterator().next();
				autowiredBeanName = entry.getKey();
				instanceCandidate = entry.getValue();
			}

			if (autowiredBeanNames != null) {
				// 将待装配的Bean名称放入autowiredBeanNames集合里
				autowiredBeanNames.add(autowiredBeanName);
			}
			if (instanceCandidate instanceof Class) {
				// 这里又去调用 getBean 方法去获取bean
				instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
			}
			Object result = instanceCandidate;
			if (result instanceof NullBean) {
				if (isRequired(descriptor)) {
					// 如果 result 是 NullBean类型，且 required = true，则抛出异常
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				result = null;
			}
			// 类型校验，确保类型与解析出来的Bean实例能够匹配
			if (!ClassUtils.isAssignableValue(type, result)) {
				throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
			}
			return result;
		}
		finally {
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}

DefaultListableBeanFactory#resolveMultipleBeans

这个方法是用来处理 数组、Collection、Map 类型的注入。具体实现如下：

	private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) {

		final Class type = descriptor.getDependencyType();
		// 如果是 StreamDependencyDescriptor 类型，则返回流的形式
		if (descriptor instanceof StreamDependencyDescriptor) {
			Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (autowiredBeanNames != null) {
				autowiredBeanNames.addAll(matchingBeans.keySet());
			}
			Stream stream = matchingBeans.keySet().stream()
					.map(name -> descriptor.resolveCandidate(name, type, this))
					.filter(bean -> !(bean instanceof NullBean));
			if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
				stream = stream.sorted(adaptOrderComparator(matchingBeans));
			}
			return stream;
		}	
		// 如果是 数组类型
		else if (type.isArray()) {
			// 确定最终类型
			Class componentType = type.getComponentType();
			ResolvableType resolvableType = descriptor.getResolvableType();
			Class resolvedArrayType = resolvableType.resolve(type);
			if (resolvedArrayType != type) {
				componentType = resolvableType.getComponentType().resolve();
			}
			if (componentType == null) {
				return null;
			}
			// 根据属性类型找到 beanFactory 中所有类型的匹配bean
			// 返回值构成 ： key= 匹配的beanName, value= beanName对应的实例化bean，通过 getBean(beanName)获取。
			Map matchingBeans = findAutowireCandidates(beanName, componentType,
					new MultiElementDescriptor(descriptor));
			// 如果是未找到匹配的bean，则返回null，
			if (matchingBeans.isEmpty()) {
				return null;
			}
			// 保存所有适配的 beanName
			if (autowiredBeanNames != null) {
				autowiredBeanNames.addAll(matchingBeans.keySet());
			}
			// 进行类型转换，将bean 转换为对应的type 类型。
			TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
			Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);
			if (result instanceof Object[]) {
				Comparator comparator = adaptDependencyComparator(matchingBeans);
				if (comparator != null) {
					// 排序
					Arrays.sort((Object[]) result, comparator);
				}
			}
			return result;
		}
		// 对 Collection 类型的处理，逻辑基本同上，这里不再赘述
		else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
			Class elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
			if (elementType == null) {
				return null;
			}
			Map matchingBeans = findAutowireCandidates(beanName, elementType,
					new MultiElementDescriptor(descriptor));
			if (matchingBeans.isEmpty()) {
				return null;
			}
			if (autowiredBeanNames != null) {
				autowiredBeanNames.addAll(matchingBeans.keySet());
			}
			TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
			Object result = converter.convertIfNecessary(matchingBeans.values(), type);
			if (result instanceof List) {
				if (((List) result).size() > 1) {
					Comparator comparator = adaptDependencyComparator(matchingBeans);
					if (comparator != null) {
						((List) result).sort(comparator);
					}
				}
			}
			return result;
		}
		// 对map类型的处理，逻辑类似上面
		else if (Map.class == type) {
			ResolvableType mapType = descriptor.getResolvableType().asMap();
			Class keyType = mapType.resolveGeneric(0);
			if (String.class != keyType) {
				return null;
			}
			Class valueType = mapType.resolveGeneric(1);
			if (valueType == null) {
				return null;
			}
			Map matchingBeans = findAutowireCandidates(beanName, valueType,
					new MultiElementDescriptor(descriptor));
			if (matchingBeans.isEmpty()) {
				return null;
			}
			if (autowiredBeanNames != null) {
				autowiredBeanNames.addAll(matchingBeans.keySet());
			}
			return matchingBeans;
		}
		else {
			return null;
		}
	}


可以看到的是，如果是集合类型，内部的核心方法也是 findAutowireCandidates 方法。所以下面还是来看 DefaultListableBeanFactory#findAutowireCandidates 方法。


DefaultListableBeanFactory#findAutowireCandidates


	protected Map findAutowireCandidates(
			@Nullable String beanName, Class requiredType, DependencyDescriptor descriptor) {
		// 根据 Class 类型，找到对应的候选beanName,
		String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
				this, requiredType, true, descriptor.isEager());
		Map result = new LinkedHashMap<>(candidateNames.length);
		// 这里我们一般不会涉及。如果注入的是 resolvableDependencies key类型，则会装配成value类型
		for (Map.Entry, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
			Class autowiringType = classObjectEntry.getKey();
			if (autowiringType.isAssignableFrom(requiredType)) {
				Object autowiringValue = classObjectEntry.getValue();
				autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
				if (requiredType.isInstance(autowiringValue)) {
					result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
					break;
				}
			}
		}
		// 遍历候选的beanName
		for (String candidate : candidateNames) {
			// 不是自引用 && 允许被注入(autowire-candidate 标签指定) 
			if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
				// 将结果添加到result中
				addCandidateEntry(result, candidate, descriptor, requiredType);
			}
		}
		// 如果目前找到的匹配的bean集合为空
		if (result.isEmpty()) {
			// Array || Collection || Map 。即是否表示多个bean的集合类型
			boolean multiple = indicatesMultipleBeans(requiredType);
			// Consider fallback matches if the first pass failed to find anything...
			DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
			for (String candidate : candidateNames) {
				// 非自引用 && 允许被注入 && (非集合类 || 解析 @Qualifier 注解或者 javax.inject.Qualifier类成功)
				// 这里开始分析解析的属性是否被 @Qualifier 注解或者 javax.inject.Qualifier类 限定符限定了
				if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
						(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
					addCandidateEntry(result, candidate, descriptor, requiredType);
				}
			}
			// 如果还没找到 && 非集合类
			if (result.isEmpty() && !multiple) {
				// Consider self references as a final pass...
				// but in the case of a dependency collection, not the very same bean itself.
				for (String candidate : candidateNames) {
					// 将自我引用视为最后一步。判断是不是自己引用自己
					if (isSelfReference(beanName, candidate) &&
							(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
							isAutowireCandidate(candidate, fallbackDescriptor)) {
						addCandidateEntry(result, candidate, descriptor, requiredType);
					}
				}
			}
		}
		return result;
	}
	
	...
	
	private void addCandidateEntry(Map candidates, String candidateName,
			DependencyDescriptor descriptor, Class requiredType) {
		// 根据类型判断，如果是MultiElementDescriptor，获取后保存到候选列表中
		if (descriptor instanceof MultiElementDescriptor) {
			Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
			if (!(beanInstance instanceof NullBean)) {
				candidates.put(candidateName, beanInstance);
			}
		}
		// 如果 单例缓存中存在 ||  是 StreamDependencyDescriptor  的类型 &&  order = true
		else if (containsSingleton(candidateName) || (descriptor instanceof StreamDependencyDescriptor &&
				((StreamDependencyDescriptor) descriptor).isOrdered())) {
			// 调用了beanFacotory.getBean 方法获取bean
			Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
			// 保存起来
			candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance));
		}
		else {
			// getType 调用了beanFacotory.getBean 方法
			candidates.put(candidateName, getType(candidateName));
		}
	}



这里提两点：


    

  1.  
    这里需要注意 resolvableDependencies。其在 DefaultListableBeanFactory#resolvableDependencies 定义如下，其作用是，当一些其他的类需要装配key类型的bean时，实际装配的类型是key对应的value 类型。
     
    	/** Map from dependency type to corresponding autowired value. */
	// key 是映射值，value是实际注入值
	private final Map, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

     
    在 Spring默认的代码中，仅仅有八个元素保存到其中，如下：
     
    2. 



spring bean生命周期三---Spring Bean populateBean 属性填充阶段_第1张图片


    

  1.  
    从上面的代码可以看到，Spring寻找合适的bean的要求是一再放宽的 ： 非自引用 -> 被 Qualifier 限定符修饰的bean -> 自引用。
     
    2. 

  2.  
    autowire-candidate ：xml中在注入bean 的时候有该属性。@Bean也有对应的属性。其作用是用来标记当前bean是否会被作为注入的候选bean。默认值 true：表示其他bean可以把当前bean作为属性注入。如果false:表示其他bean选在注入属性 bean时将忽略当前bean。这一点在上面的代码中也有体现。
     
    3. 



4. applyPropertyValues


上面只是将属性保存了起来，并未真正设置到bean中，这里设置到bean中


protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		if (pvs.isEmpty()) {
			return;
		}

		if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
			((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
		}

		MutablePropertyValues mpvs = null;
		List original;
		// 如果pvs 是 MutablePropertyValues 类型的封装
		if (pvs instanceof MutablePropertyValues) {
			mpvs = (MutablePropertyValues) pvs;
			// 如果 mpv 中的值类型已经转换完毕，则可以直接设置到BeanWrapper 中
			if (mpvs.isConverted()) {
				// Shortcut: use the pre-converted values as-is.
				try {
					bw.setPropertyValues(mpvs);
					return;
				}
				catch (BeansException ex) {
					throw new BeanCreationException(
							mbd.getResourceDescription(), beanName, "Error setting property values", ex);
				}
			}
			// 保存原始值，等待类型转换
			original = mpvs.getPropertyValueList();
		}
		else {
			// 保存原始值，等待类型转换
			original = Arrays.asList(pvs.getPropertyValues());
		}
		// 获取类型转换器
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

		// Create a deep copy, resolving any references for values.
		// 准备进行深拷贝
		List deepCopy = new ArrayList<>(original.size());
		boolean resolveNecessary = false;
		// 遍历属性，将属性转换为对应类的对应属性类型
		for (PropertyValue pv : original) {
			// 如果已经转换之后直接保存
			if (pv.isConverted()) {
				deepCopy.add(pv);
			}
			else {
				// 进行类型转换
				String propertyName = pv.getName();
				Object originalValue = pv.getValue();
				if (originalValue == AutowiredPropertyMarker.INSTANCE) {
					Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
					if (writeMethod == null) {
						throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
					}
					originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
				}
				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
				Object convertedValue = resolvedValue;
				
				boolean convertible = bw.isWritableProperty(propertyName) &&
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
				if (convertible) {
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
				}
				// Possibly store converted value in merged bean definition,
				// in order to avoid re-conversion for every created bean instance.
				if (resolvedValue == originalValue) {
					if (convertible) {
						pv.setConvertedValue(convertedValue);
					}
					deepCopy.add(pv);
				}
				else if (convertible && originalValue instanceof TypedStringValue &&
						!((TypedStringValue) originalValue).isDynamic() &&
						!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
					pv.setConvertedValue(convertedValue);
					deepCopy.add(pv);
				}
				else {
					resolveNecessary = true;
					deepCopy.add(new PropertyValue(pv, convertedValue));
				}
			}
		}
		if (mpvs != null && !resolveNecessary) {
			mpvs.setConverted();
		}

		// Set our (possibly massaged) deep copy.
		try {
			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
		}
	}



三、总结


populateBean 在bean创建结束之后，完成了对 bean属性的注入。根据byName、byType 的不同类型注入有不同的解析方式。

























你可能感兴趣的:(spring源码学习)






    

  • Spring源码学习-Spring流程概述（一）
coder_sheep
Springspringjavaaopioc源码

    Spring启动的流程publicclassTest{publicstaticvoidmain(String[]args){ClassPathXmlApplicationContextcontext=newClassPathXmlApplicationContext("applicationContext.xml");Studentbean=context.getBean(Student.clas
    

    • 

  • Spring源码学习---------(最简单易懂的源码学习笔记)
HiSiri666666
Springjavaspring5spring开发语言学习

    哈喽！大家好，我是「奇点」，江湖人称singularity。刚工作几年，想和大家一同进步一位上进心十足的【JavaToB端大厂领域博主】！喜欢java和python，平时比较懒，能用程序解决的坚决不手动解决✨如果有对【java】感兴趣的【小可爱】，欢迎关注我❤️❤️❤️感谢各位大可爱小可爱！❤️❤️❤️————————————————如果觉得本文对你有帮助，欢迎点赞，欢迎关注我，如果有补充欢迎评论
    

    • 

  • Spring源码学习-实例化过程
coder_sheep
Springspring学习javaioc源码面试

    spring源码学习中核心的部分，也是高频面试题，希望经过本章学习，帮助大家理解bean的实例化流程@Overridepublicvoidrefresh()throwsBeansException,IllegalStateException{//省略部分代码。。。//Instantiateallremaining(non-lazy-init)singletons.//初始化剩下的单实例（非懒加载的
    

    • 

  • Spring源码学习
原来~如此
springjava学习spring

    源码学习前提版本：5.3.10形式：注册形式-AnnotationConfigApplicationContext（AppConfig.class）学习内容spring启动注册过程this()阶段创建AnnotationConfigApplicationContext实例创建AnnotatedBeanDefinitionReader实例默认注册几个注解相关的bean后置处理器-注册到beanDef
    

    • 

  • spring源码学习——前置知识
无唯～
spring源码分析spring学习java

    文章目录前言1、BeanFactory与ApplicationContext2、常用注解及回调方法1、Bean注册常用注解2、组件扫描注解3、依赖注入方式3、回调注入4、普通Bean和工厂Bean5、Bean生命周期初始化销毁方法。6、spring的事件机制&监听器7、模块装配8、条件装配9、BeanDefinition1、什么是BeanDefinition？2、为什么需要BeanDefiniti
    

    • 

  • Spring源码学习三
CopyLower
学习spring学习java

    手写Starter我们通过手写Starter来加深对于自动装配的理解1.创建一个Maven项目，quick-starter定义相关的依赖org.springframework.bootspring-boot-starter2.1.6.RELEASEcom.alibabafastjson1.2.56true2.定义Formate接口定义的格式转换的接口，并且定义两个实现类publicinterfac
    

    • 

  • Spring源码学习一
CopyLower
学习spring学习java

    IOC容器概述ApplicationContext接口相当于负责bean的初始化、配置和组装的IoC容器.Spring为ApplicationContext提供了一些开箱即用的实现,独立的应用可以使用ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext，web应用在web.xml配置监听，提供xml位置和org.spring
    

    • 

  • Spring源码学习二
CopyLower
学习spring学习java

    @EnableAutoConfiguration注解的实现原理了解了ImportSelector和ImportBeanDefinitionRegistrar后，对于EnableAutoConfiguration的理解就容易一些了它会通过import导入第三方提供的bean的配置类：AutoConfigurationImportSelector@Import(AutoConfigurationImp
    

    • 

  • Spring源码学习四、Bean的加载
唐小码
springspringjava

    PS：本文参照《Spring源码深度解析2》与spring官方，仅作个人学习这章分析的是,从容器中获取beanStudentstudent=(Student)xmlBeanFactory.getBean("student");bean加载的大体思路@OverridepublicObjectgetBean(Stringname)throwsBeansException{returndoGetBean
    

    • 

  • spring初始化解析xml 配置文件一
nandao158
spring源码学习spring

    从本篇开始我们正式进入spring源码学习，首先从我们最熟悉的解析xml配置文件开始。依次跟踪代码，紧接着上一篇的开始，如下，创建一个测试方法：importcom.xiangxue.jack.bean.Student;importorg.junit.Test;importorg.springframework.context.support.ClassPathXmlApplicationConte
    

    • 

  • Spring源码编译步骤
Marlon520
springjava后端

    Spring源码学习一、Gradle为什么下载gradle呢？我们平时不都是用maven吗？原因只有一个，spring源码是用gradle构建的，所以，你想看spring源码必须安装和学会使用gradle，那么，让我们开始gradle之旅吧，我也是一个gradle小白，边学边记吧，加油吧少年，机会是给有准备的人，相信你就是那一个！！！1.Gradle下载官网下载：https://gradle.or
    

    • 

  • spring源码学习(三)——初始化bean
km56558
springspring

    spring源码学习(一)——ioc初始化spring源码学习(二)——ConfigurationClassPostProcessor(BeanFactory后置处理器的执行)spring源码学习(四)——aop1.2.3初始化bean执行完beanFactoryPostProcessors之后，会找到所有BeanPostProcessor（Bean的后置处理器），注册到beanFactory中。
    

    • 

  • Spring源码学习（二）--手写模拟spring底层原理
从头再来_f
Spring源码springjava

    通过手写模拟，了解Spring的底层源码启动过程,了解BeanDefinition、BeanPostProcessor的概念,了解Spring解析配置类等底层源码工作流程,通过手写模拟，了解依赖注入，Aware回调等底层源码工作流程,通过手写模拟，了解SpringAOP的底层源码工作流程当然,代码实现很粗糙,目的是为了更好的廖家spring底层bean加载的过程项目地址:write-spring:
    

    • 

  • 极客大学 java 进阶训练营怎么样，图文详解
一头狒狒
java开发语言

    Spring思维导图Spring源码学习笔记有关微服务的面试题：Dubbo中zookeeper做注册中心，如果注册中心集群都挂掉，发布者和订阅者之间还能通信么？Dubbo的整体架构设计有哪些分层?什么是SpringBoot？以及SpringBoot的优劣势？你如何理解SpringBoot中的Starters？服务注册和发现是什么意思？SpringCloud如何实现？SpringCloud断路器的作
    

    • 

  • Spring源码学习笔记
zhengtuqi
Spring

    springbean实例化简图更改allowcircularReference为false可以关闭循环依赖，方式有三种。1、更改spring源码2、不要使用带参构造函数改为3、拓展spring（具体不知道怎么做，应该是通过BeanPostProcessor接口）1、SpringIOC笔记：1、重要的区别，别搞混了Instantiation实例化Initialization初始化1、在填充bean属
    

    • 

  • Spring源码学习(四)：容器ApplicationContext的refresh（2）- 执行BeanFactoryPostProcessor
liangsheng_g
spring源码分析springjava

    文章目录前言一、BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor是什么二、Spring执行这些PostProcessor的步骤1.BeanDefinitionRegistryPostProcessor优先级高2.开始执行Spring容器里的BeanDefinitionRegistryPostProcessor2.1执行了Pri
    

    • 

  • Spring源码学习（一）--Spring底层核心原理解析
从头再来_f
Spring源码Springspringjava

    目录Spring中是如何创建一个对象？Bean的创建过程推断构造方法AOP大致流程Spring事务最近在跟视频学习spring源码，将每节课记录下来，以后好来复习。首先把Spring中核心知识点都给大家进行串讲，对Spring的底层有了一个整体的大致了解，比如：Bean的生命周期底层原理依赖注入底层原理初始化底层原理推断构造方法底层原理AOP底层原理Spring事务底层原理但都只是大致流程，后续会
    

    • 

  • Spring源码学习（十）--推断构造方法
从头再来_f
Spring源码springjava源码

    前言之前有篇文章是关于Bean的生命周期，Spring在扫描完成生成BeanDefinition后会去创建bean，Spring在加载beanClass后会进行实例化，就是需要利用该类的构造方法来实例化得到一个对象，因为之前学习和调试过程中自己没有在代码中去写构造方法，都是使用默认的无参构造方法，但是如果一个类存在多个构造方法，就需要进行构造方法的推导。首先，我们先看一下在javaConfig和x
    

    • 

  • spring源码学习_01 本地环境搭建
Louis.No1
springspring

    参考网上各种资源，终于把spring源码运行起来了；步骤总结如下：spring版本：5.2.x本地系统macidea2019.3.2下载地址：https://www.jetbrains.com/idea/download/other.htmljdk11下载地址：https://repo.huaweicloud.com/java/jdk/1.前期准备安装git、gradle；git的安装过程相对简单
    

    • 

  • 好的文章推荐
LeeGaKi
java

    JVMOOP-Klass模式浅谈JVMOOP-Klass二分模型_在云端123的博客-CSDN博客DDD领域驱动设计开发万字长文，结合电商支付业务一文搞懂DDD(qq.com)Spring源码构建spring源码学习_01本地环境搭建_spring源码运行_Louis.No1的博客-CSDN博客
    

    • 

  • Spring源码学习笔记：经典设计模式之委派模式
Jarvis.y
java设计模式Spring源码学习笔记架构师学习笔记java设计模式spring

    1、博客内容均出自于咕泡学院架构师第三期2、架构师系列内容：架构师学习笔记（持续更新）0、委派模式（DelegatePattern）负责任务的调度和分配任务，跟代理模式很像，可以看做是一种特殊情况下的静态代理的全权代理，但是代理模式注重过程，而委派模式注重结果。不属于GOF232种设计模式之一。属于行为型模式。委派模式跟代理模式很像，可以看做是一种特殊情况下的静态代理的全权代理，但是代理模式注重过
    

    • 

  • Spring源码学习笔记：经典设计模式之工厂模式
Jarvis.y
java设计模式Spring源码学习笔记架构师学习笔记设计模式javaspring

    1、博客内容均出自于咕泡学院架构师第三期2、架构师系列内容：架构师学习笔记（持续更新）0、工厂模式（FactoryPattern）工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。工厂模式跟单例模式紧密相关1、简单工厂模式（SimpleFactoryPatt
    

    • 

  • Spring源码学习之IDEA搭建Spring源码Debug环境
掉发的小王
springspring学习intellij-idea

    一、前言大家肯定都debug过spring的源码，看看bean的创建过程，有个缺点不能自己随意的添加注释。学习开源框架的源码时，搭建一个可以方便地进行调试的环境是非常重要的，不明白的地方也可以修改一下源码的东西！看了好多文章，都是比较老的，现在跟着搭建是有问题的，踩了很多坑，最终完成搭建，整理一下思路还是比较清晰的，让我们一起来试试吧！二、下载导入Idea本次小编使用的Idea版本为2021.3，
    

    • 

  • Spring源码学习（三）-- 底层架构核心概念解析
从头再来_f
Spring源码springjava

    前面，我们大概了解了Spring中的一些概念和底层工作流程，这篇是后续看Spring源码所必备的，防止后续看源码的过程中，遇到不会的概念得单独跳出来学习。BeanDefinitionBeanDefinition表示Bean定义，BeanDefinition中存在很多属性用来描述一个Bean的特点。比如：class，表示Bean类型scope，表示Bean作用域，单例或原型等lazyInit：表示B
    

    • 

  • Spring源码学习(未完待续)
兴厚

    IOC一.注册bean过程（xml解析）使用BeanDefinitionReader读取xml配置文件获取到Document对象//XmlBeanDefinitionReader的intdoLoadBeanDefinitions(InputSourceinputSource,Resourceresource)方法Documentdoc=doLoadDocument(inputSource,reso
    

    • 

  • Spring源码学习（十四）-- AOP底层源码解析下
从头再来_f
Spring源码springjava代理模式

    上篇文章学习了动态代理的使用以及spring中动态代理的基础使用和aop的基本概念，本篇文章首先学习spring中ProxyFactory原理以及aop源码ProxyFactory选择cglib或jdk动态代理原理OrderServicetarget=newOrderService();ProxyFactoryproxyFactory=newProxyFactory();proxyFactory.
    

    • 

  • Spring源码学习（八）-- 依赖注入源码解析（下）
从头再来_f
Spring源码springjava源码

    resolveDependency()实现上篇文章分析了Spring中的自动注入(byName,byType)和@Autowired注解的工作原理以及源码，@Autowired注解依赖注入其中注入点注入，无论是属性注入还是方法注入都有一个相同的方法org.springframework.beans.factory.support.DefaultListableBeanFactory#resolve
    

    • 

  • spring源码学习---@Autowired 注入源码分析和自定义依赖注入
大龄码农生活
spring源码学习

    一、简介众所周知，Spring的依赖注入（DI）对SpringIOC有着举足轻重的作用，是Spring灵魂所在。本篇文章就从日常开发中最常用的注解@Autowired开始，着手分析Spring是如何通过它们将Bean所需的外部资源注入其中.1.1、@Autowired注入规则@Autowired可以应用在非静态字段、非静态方法、构造器上面注入bean。1.2、@Autowired注入过程元信息解析
    

    • 

  • Spring源码学习环境搭建
MuziBlogs

    Spring概览一、作者介绍SpringFramework创始人，著名作者。Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。有着相当丰富的C/C++技术背景的Rod早在1996年就开始了对Java服务器端技术的研究。他是一个在保险、电子商务和金融行业有着丰富经验的技术顾问，同时也是JSR-154（Servlet2.4）和
    

    • 

  • Spring源码学习-SpringBoot原理解析
风之轻殇
Spring源码解读springBootspring学习springboot

    目录SpringBoot启动注解@EnableAutoConfiguration@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)Tomcat和SpringMVC组件的准备过程DispatcherServlet自动装配示例@ServletWebServerFactoryAutoConfigurationSe
    

    • 

  • log4j对象改变日志级别
3213213333332132
javalog4jlevellog4j对象名称日志级别

    log4j对象改变日志级别可批量的改变所有级别，或是根据条件改变日志级别。
log4j配置文件：
log4j.rootLogger=ERROR,FILE,CONSOLE,EXECPTION
#log4j.appender.FILE=org.apache.log4j.RollingFileAppender
log4j.appender.FILE=org.apache.l
    

    • 

  • elk+redis 搭建nginx日志分析平台
ronin47
elasticsearchkibanalogstash

                 elk+redis 搭建nginx日志分析平台
logstash,elasticsearch,kibana 怎么进行nginx的日志分析呢？首先，架构方面，nginx是有日志文件的，它的每个请求的状态等都有日志文件进行记录。其次，需要有个队 列，redis的l
    

    • 

  • Yii2设置时区
dcj3sjt126com
PHPtimezoneyii2

    时区这东西，在开发的时候，你说重要吧，也还好，毕竟没它也能正常运行，你说不重要吧，那就纠结了。特别是linux系统，都TMD差上几小时，你能不痛苦吗？win还好一点。有一些常规方法，是大家目前都在采用的1、php.ini中的设置，这个就不谈了，2、程序中公用文件里设置，date_default_timezone_set一下时区3、或者。。。自己写时间处理函数，在遇到时间的时候，用这个函数处理（比较
    

    • 

  • js实现前台动态添加文本框，后台获取文本框内容
171815164
文本框

    
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://w
    

    • 

  • 持续集成工具
g21121
持续集成

            持续集成是什么？我们为什么需要持续集成？持续集成带来的好处是什么？什么样的项目需要持续集成？...        持续集成(Continuous integration ,简称CI)，所谓集成可以理解为将互相依赖的工程或模块合并成一个能单独运行
    

    • 

  • 数据结构哈希表(hash)总结
永夜-极光
数据结构

    1.什么是hash
来源于百度百科:
Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
 

    

    • 

  • 乱七八糟
程序员是怎么炼成的

    eclipse中的jvm字节码查看插件地址：
http://andrei.gmxhome.de/eclipse/
安装该地址的outline 插件  后重启，打开window下的view下的bytecode视图
http://andrei.gmxhome.de/eclipse/
 
jvm博客：
http://yunshen0909.iteye.com/blog/2
    

    • 

  • 职场人伤害了“上司” 怎样弥补
aijuans
职场

     由于工作中的失误，或者平时不注意自己的言行“伤害”、“得罪”了自己的上司，怎么办呢？
　　在职业生涯中这种问题尽量不要发生。下面提供了一些解决问题的建议：
　　一、利用一些轻松的场合表示对他的尊重
　　即使是开明的上司也很注重自己的权威，都希望得到下属的尊重，所以当你与上司冲突后，最好让不愉快成为过去，你不妨在一些轻松的场合，比如会餐、联谊活动等，向上司问个好，敬下酒，表示你对对方的尊重，
    

    • 

  • 深入浅出url编码
antonyup_2006
应用服务器浏览器servletweblogicIE

    出处：http://blog.csdn.net/yzhz  杨争  
http://blog.csdn.net/yzhz/archive/2007/07/03/1676796.aspx
一、问题：
        编码问题是JAVA初学者在web开发过程中经常会遇到问题，网上也有大量相关的
    

    • 

  • 建表后创建表的约束关系和增加表的字段
百合不是茶
标的约束关系增加表的字段

     
下面所有的操作都是在表建立后操作的,主要目的就是熟悉sql的约束,约束语句的万能公式
 
1,增加字段(student表中增加 姓名字段)
 
alter table 增加字段的表名 add 增加的字段名 增加字段的数据类型
alter table student add name varchar2(10);
 
&nb
    

    • 

  • Uploadify 3.2 参数属性、事件、方法函数详解
bijian1013
JavaScriptuploadify

    一.属性
属性名称
默认值
说明
auto
true
设置为true当选择文件后就直接上传了，为false需要点击上传按钮才上传。
buttonClass
”
按钮样式
buttonCursor
‘hand’
鼠标指针悬停在按钮上的样子
buttonImage
null
浏览按钮的图片的路
    

    • 

  • 精通Oracle10编程SQL(16)使用LOB对象
bijian1013
oracle数据库plsql

    /*
*使用LOB对象
*/
--LOB(Large Object)是专门用于处理大对象的一种数据类型，其所存放的数据长度可以达到4G字节
--CLOB/NCLOB用于存储大批量字符数据，BLOB用于存储大批量二进制数据，而BFILE则存储着指向OS文件的指针
/*
*综合实例
*/
--建立表空间
--#指定区尺寸为128k,如不指定，区尺寸默认为64k
CR
    

    • 

  • 【Resin一】Resin服务器部署web应用
bit1129
resin

    工作中，在Resin服务器上部署web应用，通常有如下三种方式：
 
配置多个web-app
配置多个http id
为每个应用配置一个propeties、xml以及sh脚本文件
配置多个web-app
 
在resin.xml中,可以为一个host配置多个web-app
 
<cluster id="app&q
    

    • 

  • red5简介及基础知识
白糖_
基础

     
简介
 
Red5的主要功能和Macromedia公司的FMS类似，提供基于Flash的流媒体服务的一款基于Java的开源流媒体服务器。它由Java语言编写，使用RTMP作为流媒体传输协议，这与FMS完全兼容。它具有流化FLV、MP3文件，实时录制客户端流为FLV文件，共享对象，实时视频播放、Remoting等功能。用Red5替换FMS后,客户端不用更改可正
    

    • 

  • angular.fromJson
boyitech
AngularJSAngularJS 官方APIAngularJS API

    angular.fromJson 描述: 把Json字符串转为对象 使用方法: angular.fromJson(json); 参数详解: Param Type Details json
string
JSON 字符串 返回值: 对象, 数组, 字符串 或者是一个数字 示例:
<!DOCTYPE HTML>
<h
    

    • 

  • java-颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I
bylijinnan
java

    
public class ReverseWords {
/**
* 题目：颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I.词以空格分隔。
* 要求：
* 1.实现速度最快,移动最少
* 2.不能使用String的方法如split,indexOf等等。
* 解答：两次翻转。
*/
publ
    

    • 

  • web实时通讯
Chen.H
Web浏览器socket脚本

    关于web实时通讯，做一些监控软件。
由web服务器组件从消息服务器订阅实时数据，并建立消息服务器到所述web服务器之间的连接，web浏览器利用从所述web服务器下载到web页面的客户端代理与web服务器组件之间的socket连接，建立web浏览器与web服务器之间的持久连接；利用所述客户端代理与web浏览器页面之间的信息交互实现页面本地更新，建立一条从消息服务器到web浏览器页面之间的消息通路
    

    • 

  • [基因与生物]远古生物的基因可以嫁接到现代生物基因组中吗?
comsci
生物

    
      大家仅仅把我说的事情当作一个IT行业的笑话来听吧..没有其它更多的意思
    如果我们把大自然看成是一位伟大的程序员,专门为地球上的生态系统编制基因代码,并创造出各种不同的生物来,那么6500万年前的程序员开发的代码,是否兼容现代派的程序员的代码和架构呢?
  
    

    • 

  • oracle 外部表
daizj
oracle外部表external tables

        oracle外部表是只允许只读访问，不能进行DML操作，不能创建索引，可以对外部表进行的查询，连接，排序，创建视图和创建同义词操作。
you can select, join, or sort external table data. You can also create views and synonyms for external tables. Ho
    

    • 

  • aop相关的概念及配置
daysinsun
AOP

    切面(Aspect):
通常在目标方法执行前后需要执行的方法（如事务、日志、权限），这些方法我们封装到一个类里面，这个类就叫切面。
连接点（joinpoint）
spring里面的连接点指需要切入的方法，通常这个joinpoint可以作为一个参数传入到切面的方法里面（非常有用的一个东西）。
通知（Advice）
通知就是切面里面方法的具体实现，分为前置、后置、最终、异常环
    

    • 

  • 初一上学期难记忆单词背诵第二课
dcj3sjt126com
englishword

    middle 中间的，中级的
well 喔，那么；好吧
phone 电话，电话机
policeman 警察
ask 问
take 拿到；带到
address 地址
glad 高兴的，乐意的
why 为什么 
China 中国
family 家庭
grandmother (外)祖母
grandfather (外)祖父
wife 妻子
husband 丈夫
da
    

    • 

  • Linux日志分析常用命令
dcj3sjt126com
linuxlog

    1.查看文件内容
cat
-n 显示行号 2.分页显示
more
Enter 显示下一行
空格 显示下一页
F 显示下一屏
B 显示上一屏
less
/get 查询"get"字符串并高亮显示 3.显示文件尾
tail
-f 不退出持续显示
-n 显示文件最后n行 4.显示头文件
head
-n 显示文件开始n行 5.内容排序
sort
-n 按照
    

    • 

  • JSONP 原理分析
fantasy2005
JavaScriptjsonpjsonp 跨域

    转自 http://www.nowamagic.net/librarys/veda/detail/224
JavaScript是一种在Web开发中经常使用的前端动态脚本技术。在JavaScript中，有一个很重要的安全性限制，被称为“Same-Origin Policy”（同源策略）。这一策略对于JavaScript代码能够访问的页面内容做了很重要的限制，即JavaScript只能访问与包含它的
    

    • 

  • 使用connect by进行级联查询
234390216
oracle查询父子Connect by级联

    使用connect by进行级联查询
 
       connect by可以用于级联查询，常用于对具有树状结构的记录查询某一节点的所有子孙节点或所有祖辈节点。
 
       来看一个示例，现假设我们拥有一个菜单表t_menu，其中只有三个字段：
    

    • 

  • 一个不错的能将HTML表格导出为excel,pdf等的jquery插件
jackyrong
jquery插件

    发现一个老外写的不错的jquery插件，可以实现将HTML
表格导出为excel,pdf等格式，
地址在：
https://github.com/kayalshri/
下面看个例子，实现导出表格到excel,pdf
<html>
<head>
<title>Export html table to excel an
    

    • 

  • UI设计中我们为什么需要设计动效
lampcy
UIUI设计

    关于Unity3D中的Shader的知识
首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，
    

    • 

  • 如何禁止页面缓存
nannan408
htmljspcache

    禁止页面使用缓存~
------------------------------------------------
jsp:页面no cache：
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cach
    

    • 

  • 以代码的方式管理quartz定时任务的暂停、重启、删除、添加等
Everyday都不同
定时任务管理spring-quartz

          【前言】在项目的管理功能中，对定时任务的管理有时会很常见。因为我们不能指望只在配置文件中配置好定时任务就行了，因为如果要控制定时任务的 “暂停” 呢？暂停之后又要在某个时间点 “重启” 该定时任务呢？或者说直接 “删除” 该定时任务呢？要改变某定时任务的触发时间呢？ “添加” 一个定时任务对于系统的使用者而言，是不太现实的，因为一个定时任务的处理逻辑他是不
    

    • 

  • EXT实例
tntxia
ext

     
（1） 增加一个按钮
 
JSP:
 
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
Stri
    

    • 

  • 数学学习在计算机研究领域的作用和重要性
xjnine
Math

    最近一直有师弟师妹和朋友问我数学和研究的关系，研一要去学什么数学课。毕竟在清华，衡量一个研究生最重要的指标之一就是paper,而没有数学，是肯定上不了世界顶级的期刊和会议的，这在计算机学界尤其重要！你会发现，不论哪个领域有价值的东西，都一定离不开数学！在这样一个信息时代，当google已经让世界没有秘密的时候，一种卓越的数学思维，绝对可以成为你的核心竞争力.  无奈本人实在见地
    

    •