传统的spring注册bean都是基于spring提供的xml配置实现注册bean，只要通过base-package指定要扫描的bean，对应的bean加上@service或者@controller等注解，spring就可以扫描到bean，并进行实例化，再进行依赖注入，这样就完成了bean的注册及依赖注入，而当这种配置型的注册不能满足我们业务需求的时候，我们就要通过自己的代码，动态注册bean；至于有什么业务需求导致配置型注册满足不了的不是本次讨论的主题；接下来直接上代码：

 

public void registerSpringBean(String beanId,String className,Map propertyMap) {

// get the BeanDefinitionBuilder

ConfigurableApplicationContext configurableContext = (ConfigurableApplicationContext) applicationContext;

BeanDefinitionRegistry beanDefinitionRegistry = (DefaultListableBeanFactory) configurableContext.getBeanFactory();

 

BeanDefinitionBuilder beanDefinitionBuilder =

BeanDefinitionBuilder.genericBeanDefinition(className);

if(propertyMap!=null){

Iterator<?> entries = propertyMap.entrySet().iterator();

Map.Entry<?, ?> entry;

while (entries.hasNext()) {

entry = (Map.Entry<?, ?>) entries.next();

String key = (String) entry.getKey();

Object val = entry.getValue();

beanDefinitionBuilder.addPropertyValue(key, val);

}

}

BeanDefinition beanDefinition=beanDefinitionBuilder.getBeanDefinition();

beanDefinitionRegistry.registerBeanDefinition(beanId,beanDefinition);

}

了解过spring的源码的同学就可以知道，xml中配置的bean的扫描，spring最终也是通过beanDefinition来进行处理注册的；具体的可以去看看spring的bean注册源代码或者百度其他相关的资料；

参数解释：

   1 . beanId：要注册的bean的在spring中的名称，和xml配置的<bean id="">一样的道理，在依赖bean的时候使用

  2 . className：要注册的bean的class名字。可以通过xxx.Class.getName()获取；

  3 . propertyMap：要注入到bean的属性值，通过key-value的形式指定，key为属性名称，value为属性值

概念
DI(Dependency Injection)依赖注入：依赖注入是指在程序运行期间,由外部容器动态地将依赖对象注入到组件中如：一般，通过构造函数注入、Setter注入、注解注入。

Setter注入与注解注入类似，区别在于：Setter 注入是通过 Set 方法对属性进行赋值，而注解注入是通过反射为属性赋值。
时机
当 Spring IOC 容器完成了 Bean 定义资源的定位、载入、解析和注册以后，IOC 容器中已经管理类 BeanDefinition 的相关数据，但是此时 IOC 容器还没有对所管理的 Bean 进行依赖注入，依赖注入在以下两种情况发生：

对应 Bean 对象未配置成懒加载的方式即 @Lazy(value = false) 或未使用该注解，则会在初始化 IOC 容器完成之后对非懒加载 BeanDefinition 进行实例化和依赖注入。
懒加载 Bean 对象在用户第一次调用 getBean()方法时，IOC 容器触发 Bean 的实例化和依赖注入。

原理
入口
我们第一种情况进行分析，在 IOC 完成后触发的实例化和依赖注入。从上一篇文章 Spring 之 IOC 详解（基于注解方式）

说到的 AbstractApplicationContext.refresh() 继续进行分析：
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		// 调用容器准备刷新的方法，获取容器的当前时间，同时给容器设置同步标识
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		// 从资源路径获取bean信息并封装成beanDefinition注册到beanFactory的beanDefinitionMap中
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		// beanFactory的预准备工作，对beanFactory配置容器特性，例如类加载器、事件处理器等
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			//beanFactory准备工作完成之后要进行的后置处理工作，留给子类扩展使用
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			// 执行BeanFactory的后置处理器，在BeanFactory标准初始化之后执行的
			// 调用所有注册的BeanFactoryPostProcessor的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(beanFactory);

			// Register bean processors that intercept bean creation.
			// 为BeanFactory注册Post事件处理器，BeanPostProcessor是Bean的后置处理器，用于监听容器触发的事件
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			//初始化MessageSource信息源，即国际化处理、消息绑定、消息解析
			initMessageSource();

			// Initialize event multicaster for this context.
			//初始化容器事件广播器，并放入applicationEventMulticaster bean中
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			//留给子类来初始化其他的bean
			onRefresh();

			// Check for listener beans and register them.
			//在所有注册的bean中查找ApplicationListener，为事件广播器注册事件监听器
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			//初始化所有剩下的非懒加载单实例bean
			finishBeanFactoryInitialization(beanFactory);

			// Last step: publish corresponding event.
			//完成刷新过程，初始化容器的生命周期事件处理器，并发布容器的生命周期事件
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
			// 销毁已经创建的Bean
			destroyBeans();

			// Reset 'active' flag.
			// 取消刷新操作，重置容器的同步标识
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			// 重置公共缓存
			resetCommonCaches();
		}
	}
}

我们可以看到 finishBeanFactoryInitialization 方法明确是实例化所有非懒加载方式的 Bean 对象，源码如下：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
	// Initialize conversion service for this context.
	if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
			beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
		beanFactory.setConversionService(
				beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
	}

	if (!beanFactory.hasEmbeddedValueResolver()) {
		beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
	}

	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
	for (String weaverAwareName : weaverAwareNames) {
		getBean(weaverAwareName);
	}

	//为了使类型匹配，停止使用临时的类加载器
	beanFactory.setTempClassLoader(null);

	//缓存容器中所有注册的BeanDefinition元数据，以防被修改
	beanFactory.freezeConfiguration();

	//对配置了lazy-init属性为false的单例模式的Bean进行预实例化处理
	beanFactory.preInstantiateSingletons();
}

继续跟进跳转到 DefaultListableBeanFactory.preInstantiateSingletons() 方法，源码如下：
public void preInstantiateSingletons() throws BeansException {
	if (logger.isTraceEnabled()) {
		logger.trace("Pre-instantiating singletons in " + this);
	}
	//获取容器中的所有bean，依次进行初始化和创建对象
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

	// 对非懒加载的单例bean进行初始化
	for (String beanName : beanNames) {
		//获取bean的定义信息
		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
		//bean不是抽象的、是单实例的、是非懒加载的
		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			//判断是否是FactoryBean，是否是实现FactoryBean接口的bean
			if (isFactoryBean(beanName)) {
				Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
				if (bean instanceof FactoryBean) {
					final FactoryBean<?> factory = (FactoryBean<?>) bean;
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
										((SmartFactoryBean<?>) factory)::isEagerInit,
								getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
			}
			else {
				//不是工厂Bean,利用getBean创建对象
				getBean(beanName);
			}
		}
	}

	// 触发所有适用bean的初始化后回调...
	for (String beanName : beanNames) {
		Object singletonInstance = getSingleton(beanName);
		if (singletonInstance instanceof SmartInitializingSingleton) {
			final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
					smartSingleton.afterSingletonsInstantiated();
					return null;
				}, getAccessControlContext());
			}
			else {
				smartSingleton.afterSingletonsInstantiated();
			}
		}
	}
}

在这里我们需要先了解一下 FactoryBean 是什么？看起来和 BeanFactory 很像，但不是一个东西。

BeanFactory是个Factory，也就是IOC容器或对象工厂，在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的，提供了实例化对象和拿对象的功能。使用场景：

从Ioc容器中获取Bean(byName or byType)
检索Ioc容器中是否包含指定的Bean
判断Bean是否为单例

FactoryBean是个Bean，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似。使用场景：

实时生成自定义 Bean 对象

接来下看具体 getBean 方法是如何实现的，跳转到 AbstractBeanFactory.getBean() 方法。
//获取 IOC 容器中指定名称的 Bean
@Override
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}
//获取 IOC 容器中指定名称和类型的 Bean
@Override
public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
	return doGetBean(name, requiredType, null, false);
}
//获取 IOC 容器中指定名称和参数的 Bean
@Override
public Object getBean(String name, Object... args) throws BeansException {
	return doGetBean(name, null, args, false);
}
//获取 IOC 容器中指定名称、类型和参数的 Bean
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
	throws BeansException {
	return doGetBean(name, requiredType, args, false);
}

从这里可以看到 AbstractBeanFactory 提供了多种获取 Bean 的方式，懒加载的 Bean 对象在用户第一次时一样是通过这几个方法。 doGetBean 方法才是真正向 IOC 容器获取被管理 Bean 的过程，源码如下：
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

	//根据指定的名称获取被管理的Bean的名称，剥离指定名称中对容器的相关依赖
	//如果指定的是别名，将别名转换为规范的Bean名称
	final String beanName = transformedBeanName(name);
	Object bean;

	//先从缓存中取是否已经有被创建过的单态类型的Bean
	//对于单例模式的Bean整个IOC容器中只创建一次，不需要重复创建
	Object sharedInstance = getSingleton(beanName);
	//IOC容器创建单例模式Bean实例对象
	if (sharedInstance != null && args == null) {
		if (logger.isTraceEnabled()) {
			//如果单例模式的Bean被创建，则直接返回
			if (isSingletonCurrentlyInCreation(beanName)) {
				logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
						"' that is not fully initialized yet - a consequence of a circular reference");
			}
			else {
				logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
			}
		}
		//获取给定Bean的实例对象，主要完成FactoryBean获取实例化对象过程
		//注意：BeanFactory是管理容器中Bean的工厂，而FactoryBean是创建创建对象的工厂Bean，两者之间有区别
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}

	else {
		//缓存中没有单例模式的Bean,缓存中已经有原型模式的Bean,但是由于循环引用导致实例化对象失败
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		//对IOC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否能在当前的BeanFactory中获取所需要的Bean
		//如果不能再委托当前容器的父容器去查找，如果还是找不到则沿着继承关系继续查找
		BeanFactory parentBeanFactory = getParentBeanFactory();
		//当前容器的父容器存在，且当前容器中不存在指定名称的Bean
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// Not found -> check parent.
			//解析指定Bean名称的原始名称
			String nameToLookup = originalBeanName(name);
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			//递归到beanFactory中寻找
			else if (args != null) {
				//委派父容器根据指定名称和显式的参数查找
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else if (requiredType != null) {
				//委派父容器根据指定名称和类型查找
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
				//委派父容器根据指定名称查找
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}

		//创建的Bean是否需要进行类型验证
		if (!typeCheckOnly) {
			//向容器标记指定的Bean已经被创建
			markBeanAsCreated(beanName);
		}

		try {
			//根据指定Bean名称获取其父级Bean定义，主要解决Bean继承时子类和父类公共属性问题
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
			//判断父级BeanDefinition是否是抽象的
			checkMergedBeanDefinition(mbd, beanName, args);

			//获取当前bean所有属性对应的依赖Bean名称
			String[] dependsOn = mbd.getDependsOn();
			//如果当前Bean有依赖
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
					//注册当前bean和依赖bean关联关系
					registerDependentBean(dep, beanName);
					try {
						//递归调用，获取依赖Bean
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}

			//创建单例模式的Bean的实例对象
			if (mbd.isSingleton()) {
				//调用匿名内部类创建Bean实例对象，创建Bean实例对象，并且注册给所依赖的对象
				sharedInstance = getSingleton(beanName, () -> {
					try {
						//创建一个指定Bean实例对象，如果有父级继承，则合并子类和父类的定义
						return createBean(beanName, mbd, args);
					}
					catch (BeansException ex) {
						// Explicitly remove instance from singleton cache: It might have been put there
						// eagerly by the creation process, to allow for circular reference resolution.
						// Also remove any beans that received a temporary reference to the bean.
						//从单例模式的Bean缓存中清除实例对象
						destroySingleton(beanName);
						throw ex;
					}
				});
				//获取给定Bean的实例对象，主要完成FactoryBean获取实例化对象过程
				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			}
			//IOC容器创建原型模式的Bean实例对象
			else if (mbd.isPrototype()) {
				//原型模式每次都会创建一个新的对象
				Object prototypeInstance = null;
				try {
					//创建的原型对象之前进行回调
					beforePrototypeCreation(beanName);
					//创建指定Bean的对象实例
					prototypeInstance = createBean(beanName, mbd, args);
				}
				finally {
					//回调方法，告诉IOC容器不再创建指定Bean的原型对象
					afterPrototypeCreation(beanName);
				}
				//获取给定Bean的实例对象，主要完成FactoryBean获取实例化对象过程
				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
			}

			else {
				//创建的Bean既不是单例模式也不是原型模式，创建其他生命周期的Bean
				String scopeName = mbd.getScope();
				final Scope scope = this.scopes.get(scopeName);
				//如果Bean定义资源中没有配置生命周期范围，则Bean定义不合法
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
				}
				try {
					//调用匿名内部类，获取一个指定生命周期范围的实例
					Object scopedInstance = scope.get(beanName, () -> {
						beforePrototypeCreation(beanName);
						try {
							return createBean(beanName, mbd, args);
						}
						finally {
							afterPrototypeCreation(beanName);
						}
					});
					//获取给定Bean的实例对象，主要完成FactoryBean获取实例化对象过程
					bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
				}
				catch (IllegalStateException ex) {
					throw new BeanCreationException(beanName,
							"Scope '" + scopeName + "' is not active for the current thread; consider " +
							"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
							ex);
				}
			}
		}
		catch (BeansException ex) {
			cleanupAfterBeanCreationFailure(beanName);
			throw ex;
		}
	}

这里会设计到一个高频面试题-循环依赖，在后续文章中我将单独拉出来进行讲解，在这里就不做过多讨论。

上述方法主要完成了

从缓存中获取单例 Bean
从缓存中取到，则调用 getObjectForBeanInstance 获取实例对象并返回
如果没有则从父级 RootBeanDefinition 中查找
都没有找到的情况下，创建指定生命周期的 Bean 实例

如果从单例缓存中获取到了对应的单例 Bean， getObjectForBeanInstance 方法：获取给定 Bean 的实例对象，主要是完成FactoryBean的相关处理。
protected Object getObjectForBeanInstance(
		Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
	//容器已经得到了Bean实例对象，这个实例对象可能是一个普通的Bean，
	//也可能是一个工厂Bean，如果是一个工厂Bean，则使用它创建一个Bean实例对象，
	//如果调用本身就想获得一个容器的引用，则指定返回这个工厂Bean实例对象

	//如果指定的名称是容器的解引用(dereference，即是对象本身而非内存地址)，且Bean实例也不是创建Bean实例对象的FactoryBean
	if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
		throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
	}
	//如果Bean实例不是工厂Bean或者是指定名称的FactoryBean则直接返回，
	//调用者向获取对容器的引用，则直接返回当前的Bean实例
	if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
		return beanInstance;
	}

	//处理指定名称不是容器的解引用，或者根据名称获取的Bean实例对象是一个工厂Bean
	//使用工厂Bean创建一个Bean的实例对象
	Object object = null;
	if (mbd == null) {
		//从Bean工厂缓存中获取给定名称的Bean实例对象
		object = getCachedObjectForFactoryBean(beanName);
	}
	//让Bean工厂生产给定名称的Bean对象实例
	if (object == null) {
		FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
		//如果从BeanFactory生产的Bean是单态模式的，则缓存
		if (mbd == null && containsBeanDefinition(beanName)) {
			//从容器中获取指定名称的Bean定义，如果继承基类，则合并基类相关属性
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		//如果从容器得到Bean定义信息，并且Bean定义信息不是虚构的，
		//则让工厂Bean生产Bean实例对象
		boolean synthetic = (mbd != null && mbd.isSynthetic());
		//实现工厂Bean生产Bean对象实例的过程
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

不同生命周期的都通过 create() 方法进行实例化和依赖注入，跳转到AbstractAutowireCapableBeanFactory.create() 方法。
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

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

	// 判断需要创建的Bean是否可以实例化，即是否可以通过当前的类加载器加载
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	//验证及准备覆盖的方法
	try {
		mbdToUse.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
				beanName, "Validation of method overrides failed", ex);
	}

	try {
		// 如果Bean配置了初始化后的处理器，则返回一个需要创建Bean的代理对象
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
				"BeanPostProcessor before instantiation of bean failed", ex);
	}

	try {
		//创建bean的入口
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isTraceEnabled()) {
			logger.trace("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
	catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
		throw ex;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
	}
}

继续跟进 doCreateBean 方法，这个方法才是真正完成 Bean 实例化和依赖注入。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {

	//封装被创建的Bean对象
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		//根据指定bean使用对应的策略创建实例对象，如：指定的工厂方法、根据参数选择构造函数、默认无参构造方法
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = instanceWrapper.getWrappedInstance();
	//获取实例化对象的类型
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	//允许后处理器修改合并的bean定义。
	//调用MergedBeanDefinitionPostProcessor后置处理器
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}

	// 向容器中缓存单例模式的Bean对象，以防止循环引用
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
			isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		if (logger.isTraceEnabled()) {
			logger.trace("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
		//为避免后期循环依赖，尽早持有对象的引用
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	//Bean对象的初始化，依赖注入在此触发，这个对象在初始化完成之后返回依赖注入完成后的Bean
	Object exposedObject = bean;
	try {
		//将Bean实例对象封装，并且将Bean定义中配置的属性值赋给实例对象
		populateBean(beanName, mbd, instanceWrapper);
		//初始化Bean对象,Bean实例对象的依赖注入完成之后，为Bean实例对象应用BeanPostProcessor后置处理器
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	catch (Throwable ex) {
		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
			throw (BeanCreationException) ex;
		}
		else {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
		}
	}

	if (earlySingletonExposure) {
		//获取指定名称的已注册的单例模式的Bean对象
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			//根据名称获取已注册的Bean和正在实例化的Bean是同一个
			if (exposedObject == bean) {
				//当前实例化的Bean初始化完成
				exposedObject = earlySingletonReference;
			}
			//当前Bean依赖其他Bean已经注入完成并且当发生循环引用时不允许创建新的实例对象
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				//获取依赖于指定bean的所有bean的名称
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				//遍历当前Bean所依赖的其他Bean
				for (String dependentBean : dependentBeans) {
					//对依赖Bean进行类型检查，判断是否已经创建过
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException(beanName,
							"Bean with name '" + beanName + "' has been injected into other beans [" +
							StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
							"] in its raw version as part of a circular reference, but has eventually been " +
							"wrapped. This means that said other beans do not use the final version of the " +
							"bean. This is often the result of over-eager type matching - consider using " +
							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}

	// 注册完成依赖注入的Bean
	try {
		//注册destroy方法在工厂关闭时调用
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}

	return exposedObject;
}

这里主要通过三个方法组成：

调用 createBeanInstance 方法进行实例化对象
调用 populateBean 方法进行依赖注入
调用 initializeBean 方法执行 BeanPostProcessor 后置处理器

实例化
我们依次进行查看，先来看 createBeanInstance 方法：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// 确认Bean是可实例化的
	Class<?> beanClass = resolveBeanClass(mbd, beanName);

	// 判断bean的访问是否是public级别
	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}

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

	//调用工厂方法进行实例化
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// 使用容器的自动装配方法进行实例化
	boolean resolved = false;
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			//一个类有多个构造函数，每个构造函数都会不同的参数，所以调用前需要先根据参数缩影构造函数和对应的工厂方法
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}

	if (resolved) {
		if (autowireNecessary) {
			//配置了自动装配属性，使用容器的自动装配进行实例化，容器的自动装配根据参数类型匹配Bean的构造方法
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			//使用默认构造函数构造
			return instantiateBean(beanName, mbd);
		}
	}

	// 使用Bean的构造方法进行实例化
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		//使用容器的自动装配特性，调用匹配的构造方法进行实例化
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// Preferred constructors for default construction?
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	//使用默认构造函数构造
	return instantiateBean(beanName, mbd);
}

可以看到这里分别调用自动注入构造方法 autowireConstructor 和默认无参构造方法 instantiateBean 进行实例化 Bean 对象。

具体实例化过程就不做展开，代码确实有点多容易晕。如果确实有人想要了解的话可以在底下留言，博主后期再进行补充。
依赖注入
接着我们来看依赖注入的 populateBean 方法，
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 {
			return;
		}
	}

	// 在设置属性之前，给所有InstantiationAwareBeanPostProcessor机会修改bean的状态。例如，它可以用于支持字段注入的样式。
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					return;
				}
			}
		}
	}
	//获取容器在解析Bean定义资源时为BeanDefinition设置的属性值
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	int resolvedAutowireMode = mbd.getResolvedAutowireMode();
	//对依赖注入处理，首先处理autowiring自动装配的依赖注入（此处的自动装配的依赖注入针对的是 XML 配置文件中的<Bean>下面的属性配置）
	if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
		//根据Bean名称进行autowiring自动装配处理
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}
		//根据Bean类型进行autowiring自动装配处理
		if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}
		//获取autowiring自动装配后的属性值，继续注入其他属性
		pvs = newPvs;
	}

	//对非autowiring的属性进行依赖注入处理
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

	PropertyDescriptor[] filteredPds = null;
	if (hasInstAwareBpps) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				//@Autowired、@Value、@Inject等注入注解就是在此处进入进行实现(AutowiredAnnotationBeanPostProcessor)
				PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					if (filteredPds == null) {
						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
					}
					pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						return;
					}
				}
				pvs = pvsToUse;
			}
		}
	}
	if (needsDepCheck) {
		if (filteredPds == null) {
			filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		}
		checkDependencies(beanName, mbd, filteredPds, pvs);
	}

	if (pvs != null) {
		//对属性进行注入
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

此处有关于@Autowried 注解的原理就不做展示，同样在后面的问题单独拎出来分析实现原理。
该方法统一将自动依赖注入和其他属性收集到 PropertyValues 对象中，最后统一进行赋值。

我们来看下自动装配的依赖注入是如何完成的，先来看通过 Bean 名称进行自动装配处理的 autowireByName 方法。
protected void autowireByName(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

	//对Bean对象中非简单属性(不是简单继承的对象，如原始类型，字符串，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.isTraceEnabled()) {
				logger.trace("Added autowiring by name from bean name '" + beanName +
						"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
			}
		}
		else {
			if (logger.isTraceEnabled()) {
				logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
						"' by name: no matching bean found");
			}
		}
	}
}

根据类型进行自动依赖的方法 autowireByType，源码如下：
protected void autowireByType(
		String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

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

	//存放解析的要注入的属性
	Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
	//对Bean对象中非简单属性(不是简单继承的对象，如原始类型，字符，URL等都是简单属性)进行处理
	String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
	for (String propertyName : propertyNames) {
		try {
			//获取指定属性名称的属性描述器
			PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
			//不对Object类型的属性进行按类型自动依赖注入
			if (Object.class != pd.getPropertyType()) {
				//获取属性的setter方法
				MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
				//检查指定类型是否可以被转换为目标对象的类型
				boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
				//创建一个要被注入的依赖描述
				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.isTraceEnabled()) {
						logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
								propertyName + "' to bean named '" + autowiredBeanName + "'");
					}
				}
				//释放已自动注入的属性
				autowiredBeanNames.clear();
			}
		}
		catch (BeansException ex) {
			throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
		}
	}

我们来看下最后是如何完成属性注入的
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<PropertyValue> original;

	if (pvs instanceof MutablePropertyValues) {
		mpvs = (MutablePropertyValues) pvs;
		//属性值已经转换
		if (mpvs.isConverted()) {
			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;
	}
	//创建一个Bean定义属性值解析器，将Bean定义中的属性值解析为Bean实例对象的实际值
	BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

	// Create a deep copy, resolving any references for values.
	//为属性的解析值创建一个副本，将副本的数据注入实例对象
	List<PropertyValue> 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();
			//转换后的属性值
			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);
			}
			//存储转换后的属性值，避免每次属性注入时的转换工作
			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);
	}
}

实际上就是通过反射完成属性注入的，具体就不做展开。
执行后置处理器
在完成了实例化和依赖注入后，我们接着来看看是如何调用 BeanPostProcessor 后置处理器的。看方法 initializeBean 源码：
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	//JDK的安全机制验证权限
	if (System.getSecurityManager() != null) {
		//通过匿名内部类根据实例化策略创建实例对象
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		//将实例化的对象信息封装起来，如bean名称，类加载器，所属容器等信息
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	//调用BeanPostProcessor后置处理器的回调方法，在Bean实例初始化前做一些处理
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	//通过反射调用Bean实例的初始化方法，这个初始化方法是在init-method指定的
	try {
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}
	//调用BeanPostProcessor后置处理器的回调方法，在Bean实例初始化之后做一些处理
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

可以看到 BeanPostProcessor 的 postProcessBeforeInitialization 和postProcessAfterInitialization 方法就是在初始化方法前后完成循环调用的。循环代码如下：
//调用BeanPostProcessor后置处理器实例初始化之前的处理方法
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
		throws BeansException {

	Object result = existingBean;
	//遍历容器为所创建的Bean添加所有BeanPortProcessor后置处理器
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		//调用Bean实例所有后置处理中初始化前的处理方法，为Bean实例对象在初始化之前做一些自定义的处理
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

//调用BeanPostProcessor后置处理器实例初始化之后的处理方法
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
		throws BeansException {

	Object result = existingBean;
	//遍历容器为所创建的Bean添加所有BeanPostProcessor后置处理器
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		//调用Bean实例所有的后置处理中初始化后的处理方法，为Bean实例对象在初始化之后做一些自定义的处理
		Object current = processor.postProcessAfterInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

至此我们自己完成了实例化、依赖注入和执行后置处理器的整体流程，得到了一个可用的 Bean 对象。
总结
我们可以知道 Bean 的完整生命周期



（1）实例化Bean：
对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext 容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。
（2）设置对象属性（依赖注入）：
实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息 以及通过BeanWrapper提供的设置属性的接口完成依赖注入。
（3）处理Aware接口：
Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给Bean：
①如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的就是Spring配置文件中Bean的id值；
②如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。
③如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文；
（4）BeanPostProcessor：
如果想对Bean进行一些自定义的处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。
（5）InitializingBean 与 init-method：
如果Bean实现InitializingBean接口，则直接调用afterPropertiesSet方法。例如执行自定义初始化或仅检查所有必需属性是否已设置。
如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。
（6）如果这个Bean实现了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj, String s)方法；由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术；
以上几个步骤完成后，Bean就已经被正确创建了，之后就可以使用这个Bean了。
（7）DisposableBean：
当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的destroy()方法；
（8）destroy-method：
最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。

Spring的控制反转（IOC），简单来说，就是运用反射技术，

动态生成对象
将配置文件中的属性值注入到对象中
具体的流程为，

Resource定位
BeanDefinition的载入和解析
BeanDefinition的注册
依赖注入
下面详细谈一下各个流程，


Resource定位

Resource资源就是xml配置文件，对xml的抽象，包含了BeanDefinition的定义信息。由于配置信息来源的多样化，所以Resource也有不同的抽象实现，



ClassPathResource可用来获取类路径下的资源文件。      
FileSystemResource可用来获取文件系统里面的资源。
UrlResource可用来代表URL对应的资源，它对URL做了一个简单的封装。通过给定一个URL地址，我们就能构建一个UrlResource。
ByteArrayResource是针对于字节数组封装的资源，它的构建需要一个字节数组。
ServletContextResource是针对于ServletContext封装的资源，用于访问ServletContext环境下的资源。
InputStreamResource是针对于输入流封装的资源，它的构建需要一个输入流。
针对以上各种Resource资源，运用ResourceLoader定位。ResourceLoader是一个接口，用于实现不同的Resource加载策略。



BeanDefinition的载入和解析
获取到Resource后，需要将Resource中对bean的定义转化为BeanDefinition。
BeanDefinition是对bean的描述，有属性值，构造参数和具体实现提供的其他信息。
过程包括，

读取配置文件
封装成BeanDefinition对象


BeanDefinition的注册
构建完数据表示后，需要对这些数据进行注册。具体是调用BeanDefinitionRegistry接口的实现类，完成向容器的注册，就是存入一个HashMap中。


依赖注入
运用反射机制，在getBean()方法调用时，生成对应的bean对象。实例化方法分为，

JVM反射
CGLIB
如果BeanDefinition中lazy-init设置的是true，则会在初始化过程中创建注入而不是在getBean()这里。

文章目录
Spring
简介
组成
spring 7 大模块
拓展
IoC
IoC理论
IOC本质
HelloSpring
IOC创建对象的方式
Spring配置
别名
bean的配置
import
DI 依赖注入
构造器注入
Set方式注入【重点】
拓展方式注入
bean的作用域
bean的自动装配
测试
byName自动装配
byType自动装配
使用注册实现自动装配
使用注解开发
使用Java的方式配置Spring
代理模式
静态代理
动态代理
AOP
什么是AOP?
AOP在Spring中的作用
使用Spring实现AOP
声明式事物
Spring中的事物管理

Spring
简介


目的：解决企业应用开发的复杂性


范围：任何Java应用


强大的向后兼容性，代码质量高标准


理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架


优点：

开源免费的框架（容器）
轻量级的、非入侵式的框架
控制反转、面向切面编程
支持事务的处理，对框架整合的支持



弊端：发展了太久，违背了原来的理念，配置十分繁琐，“配置地域”


总结：Spring是一个轻量级的控制反转(IoC)、面向切面编程(AOP)的框架


早期：SSH : Struct2 + Spring + Hibernate(全自动)


现代：SSM : SpringMvc + Spring + Mybatis（半自动）


组成
spring 7 大模块

拓展
现代化Java开发


Spring Boot

一个快速开发的脚手架
基于Spring Boot可以快速开发单个微服务
约定大于配置


Spring Cloud

基于Spring Boot实现的



IoC
IoC理论

之前在MovieLister中创建MovieFinder的具体实现，是写死的一种实现，当以后的test调用类需要换别的实现的时候，除了要修改test类，还需要修改原MovieLister程序重新编译，不能很好的适应变更


这种思想，从本质上解决了问题，程序员不用再去管理对象的创建，让用户去管，系统的耦合性大大降低
IOC本质
控制反转 Inversion of Control 是一种设计思想，依赖注入(DI)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的
控制反转是一种通过描述(XML或注解) 并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入
HelloSpring


导入Spring相关jar包
<dependency>
	<groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>



编写相关代码
Hello类
public class Hello{
    private String name;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public void show(){
        System.out.println("Hello" + name);
    }
}



编写spring配置文件，命名为beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--    使用spring来创建对象，在Spring这些都称为Bean
		id对应的是变量名
		class对应的是类型
		property对应的是内部属性-->
    <bean id="hello" class="com.yunthin.pojo.Hello">
        <property name="str" value="nbsszrx"/>
    </bean>
</beans>



测试
@Test
public void test(){
    //解析beans.xml文件，生成管理相应的Bean对象
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    //getBean : 参数为spring配置文件中bean的id
    Hello hello = (Hello) context.getBean("Hello");
    hello.show();
}

到现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓IoC，一句话：对象由Spring创建、管理、装配


思考问题


Hello是谁创建的？
Hello对象是由Spring创建的


Hello对象的属性是怎么设置的？
Hello对象的属性是由Spring容器设置的


这个过程就叫控制反转
控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的
反转：程序本身不创建对象，而变成被动的接收对象
依赖注入：就是利用set方法来进行注入的
IOC是一种编程思想，由主动的变成变成被动的接收
可以通过ClassPathXmlApplicationContext去浏览一下底层源码
IOC创建对象的方式


默认，使用无参构造函数创建对象


如果需要使用有参构造创建对象


下标赋值
<bean id="user" class="com.yunthin.pojo.User">
	<constructor-arg index="0" value="Yunthin Chow"/>
</bean>      



类型
<bean id="user" class="com.yunthin.pojo.User">
	<constructor-arg type="java.lang.String" value="Yunthin Chow"/>
</bean>



参数名
<bean id="user" class="com.yunthin.pojo.User">
	<constructor-arg name="name" value="Yunthin Chow"/>
</bean>





Spring配置
别名
别名区分大小写
<alias name="user" alias="userNew"/>
如果添加了别名，我们也可以使用别名获取到这个对象

bean的配置
name也是别名，而且更高级，可以同时取多个别名,逗号、空格分隔都可以
<bean id="userT" class="com.yunthin.pojo.UserT" name="user2,u2 u3">
	<property name="name" value="aaa"/>
</bean>

import
一般用于团队开发，可以将多个配置文件导入合并为一个
假设现在项目中有多个人开发，不同的人负责不同的类，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的，使用的时候，直接使用总的配置xml文件就可以了
applicationContext.xml
<import resource="beans1.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>

DI 依赖注入
构造器注入
前面已经说过了
Set方式注入【重点】

依赖注入：本质是set注入

依赖：bean对象的创建依赖于容器
注入：bean对象中的所有属性由容器来注入



【环境搭建】


复杂类型
package com.yunthin.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}



真实对象
package com.yunthin.pojo;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String, String> card;
    private Set<String> games;
    private Properties info;
    private String wife;
}
// 相应的get set方法省略




beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="address" class="com.yunthin.pojo.Address" />

    <bean id="student" class="com.yunthin.pojo.Student">
<!--        第一种， 普通值注入, value-->
        <property name="name" value="yunthin Chow"/>

<!--        第二种，Bean注入，ref-->
        <property name="address" ref="address"/>

<!--        第三种，数组注入-->
        <property name="books">
            <array>
                <value>《红楼梦》</value>
                <value>《西游记》</value>
                <value>《水浒传》</value>
            </array>
        </property>

<!--        第四种, List注入-->
        <property name="hobbys">
            <list>
                <value>听歌</value>
                <value>代码</value>
                <value>电影</value>
            </list>
        </property>

<!--        第五种, map注入-->
        <property name="card">
            <map>
                <entry key="身份证" value="123"/>
                <entry key="学生证" value="321"/>
                <entry key="银行卡" value="666"/>
            </map>
        </property>

<!--        第六种,set注入-->
        <property name="games">
            <set>
                <value>COH</value>
                <value>NFS</value>
            </set>
        </property>

<!--        第七种, null注入-->
        <property name="wife">
            <null/>
        </property>

<!--        第八种, Properties注入-->
        <property name="info">
            <props>
                <prop key="学号">181250</prop>
                <prop key="性别">男</prop>
            </props>
        </property>
    </bean>


</beans>



测试类
import com.yunthin.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class  Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
    }
}




拓展方式注入
可以使用 p 命名空间和 c 命名空间进行注入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--    p命名空间注入,可以直接注入属性的值: property-->
    <bean id="user" class="com.yunthin.pojo.User" p:name="a " p:age="18"/>

<!--    c命名空间注入,通过构造器注入: construct-args-->
    <bean id="user2" class="com.yunthin.pojo.User" c:age="20" c:name="chow yunthin"/>
</beans>

注意点：p命名和c命名空间不能直接使用，需要导入约束
bean的作用域



单例模式（Spring默认机制）
<bean id="user" class="com.yunthin.pojo" scope="singleton"/>






原型模式：每次从容器中get的时候，都会产生一个新对象
<bean id="user" class="com.yunthin.pojo" scope="prototype"/>





其余的 request、session、application这些只在web开发中使用到

bean的自动装配

自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性

Spring中有三种装配的方式

在xml中显式地配置
在java中显式配置
隐式地自动装配bean【重要】

测试

环境搭建

一个人有两个宠物



byName自动装配
会自动在容器上下文中查找和自己对象set方法后面的值（小写首字母）对应的bean的id
<bean id="people" class="class.yunthin.pojo.People" autowire="byName"/>

byType自动装配
会自动在容器上下文中查找，和自己对象属性类型相同的bean id
<bean class="com.yunthin.pojo.Cat"/>
<bean class="com.yunthin.pojo.Dog"/>
<bean id="people" class="class.yunthin.pojo.People" autowire="byType"/>

小结：

byName的时候，需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
byType的时候，需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一样

使用注册实现自动装配
jdk1.5支持的注解 ，Spring2.5就支持注解了
要使用注解须知：

导入约束：context约束
配置注解的支持：context:annotation-config

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
">
    <context:annotation-config/>
</beans>

@Autowired
​		官方建议在set方法上使用
​		可以直接在属性上使用，可以直接省掉set方法，但前提是这个自动装配的属性在IOC(Spring)容器中存在，且类型要与属性相符
​		可以与Qualifier(value=“id”)使用
public class People{
    @Autowired
    @Qualifier(value="cat111")
    private Cat cat;
    
    @Autowired
    @Qualifier(value="dog222")
    private Dog dog;
    
    private String name;
}

或者使用
@Resource(value=“qualifier”)
需要加个javax.annotation-api-1.3.2.jar包
<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

public class People{
    @Resource(name = "cat2")
    private Cat cat;
    
    @Resource
    private Dog dog;
}

小结：
@Resource 和 @Autowired 的区别：

都是用来自动装配的，都可以放在属性字段上
@Autowired 通过byType的方式实现，而且必须要求这个对象存在，如果有多个对应的对象，再通过byName
@Resource 默认通过byName的方式实现，找不到名字再byType

使用注解开发
在Spring4之后，要使用注解开发，必须要保证aop的包导入；使用注解需要导入context约束，增加注解的支持
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
">
    <context:annotation-config/>
</beans>



bean


属性如何注入
//等价于<bean id="user" class="com.yunthin.pojo.User"/>
@Component
public class User {
    @Value("yunthin")
    public String name;
}

//或者在set方法上注解
//等价于<bean id="user" class="com.yunthin.pojo.User"/>
@Component
public class User {
    public String name;

    @Value("yunthin")
    public void setName(String name) {
        this.name = name;
    }
}



衍生的注解
@Component有几个衍生的注解，功能和@Component等价，用于web开发中的mvc分层架构的区分，都是代表将某个类注册到Spring中，装配Bean

dao		     @Repository
service       @Service
controller  @Controller



自动装配置


作用域 @Scope


小结
xml与注解

xml更加万能，适用于任何场合，维护简单方便
注解 不是自己的类使用不了，维护相对复杂

最佳实践：

xml用来管理bean
属性使用注解注入
我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持



使用Java的方式配置Spring
我们现在要完全不使用Spring的xml配置了，全权交给Java来做
JavaConfig是Spring的一个子项目，在Spring 4之后，成为了一个核心功能
//这个也会Spring容器托管，注册到容器中，因为Configuration本来就是一个@Component
//@Configuration代表这是一个配置类，等同于之前看到的beans.xml
@Configuration
@ComponentScan("com.yunthin.pojo")
@Import(YunthinConfig.class)
public class YunthinConfig{
    //注册一个bean，就相当于我们之前写的一个bean标签
    //这个方法的名字，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();//就是返回要注入到bean的对象
    }
    
    //到时候用的时候就是：context.getBean("getUser")
}

测试类
public class MyTest{
    public static void main(String[] args){
        //如果完全使用配置类的方法去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(YunthinConfig.class);
        User user = (User)context.getBean("getUser");
        System.out.println(getUser.getName());  
    }
}

这种纯Java的配置方式，在SpringBoot中，随处可见
代理模式
因为这就是Spring AOP的底层 【SpringAOP 和 SpringMVC面试必问】
代理模式的分类：

静态代理
动态代理

静态代理
角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人

代码步骤：

接口
真实角色
代理角色
客户端访问代理角色

代理模式的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务就交给代理角色，实现了业务的分工，耦合性降低
公共业务发生扩展的时候，方便集中管理

静态代理缺点：

一个真实角色就会产生一个代理角色；代码量翻倍，开发效率变低（解决这个问题的方法就叫动态代理）

动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理

基于接口——JDK 动态代理 【在这里使用的】
基于类：cglib
java字节码实现：javasist



需要了解两个类：Proxy， InvocationHandler
InvocationHandler是lang.reflect反射包下的一个接口，是调用处理程序
Proxy是lang.reflect反射包下的一个类，是代理
动态代理的好处：

静态代理的好处全都有
一个动态代理类代理的是一个接口，一般就是对应的一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        ProxyIncovationHandler pih = new ProxyIncovationHandler();
        pih.setIntface_to_proxy(host);
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();
    }
}

public interface Rent {
    public void rent();
}
public class Host implements Rent{
    @Override
    public void rent() {
        System.out.println("房东要租房子");
    }
}

//用这个类，自动生成代理类
public class ProxyIncovationHandler implements InvocationHandler {
    Object intface_to_proxy;


    public void setIntface_to_proxy(Object intface_to_proxy) {
        this.intface_to_proxy = intface_to_proxy;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), intface_to_proxy.getClass().getInterfaces(),this);
    }


    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        return method.invoke(intface_to_proxy,args);
    }

    public void log(String msg){
        System.out.println("执行了" + msg + "方法");
    }
}


核心就是通过Proxy这个类的静态方法getProxy获得proxy对象，然后通过InvocationHandler的invoke方法，实现代理类方法的托管
AOP
什么是AOP?

AOP (Aspect Oriented Programming) 面向切面编程。通过预编译的方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的一种延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率


AOP在Spring中的作用
提供声明式事物；允许用户自定义切面

在SpringAOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice。即AOP在不改变原有代码的情况下，去增加新的功能

使用Spring实现AOP
【重点】使用AOP织入，需要导入一个依赖包
<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
</dependency>

方式一：使用Spring的api接口【主要SpringAPI接口实现】
方式二： 使用自定义类来实现【主要是切面定义】
方式三：使用注解实现
声明式事物

把一组业务当成一个业务来做，要么都成功，要么都失败
事物在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎
确保完整性和一致性

事物的ACID原则：

Atomicity 原子性
Consistenncy 一致性
Isolation 隔离性

多个业务可能操作同一个资源，防止数据损坏


Durability 持久性

事物一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化地写到储存器中



Spring中的事物管理

声明式事物：AOP
编程式事物：需要在代码中，进行事物的管理

思考：
为什么需要事物？

如果不配置事物，可能存在数据提交不一致的情况
如果我们不再Spring中去配置声明式事物，我们就需要在代码中手动配置事务
事物在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎