/**
 * 一个单例bean的依赖注入和查找
 */
public class SingletonBeanInjectLock {
    public static void main(String[] args) {
        // 创建Ioc容器
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        // 定义初始化类
        beanDefinition.setBeanClass(Person.class);
        // 用构造函数的方式初始化类
        ConstructorArgumentValues constructorArgumentValues = new ConstructorArgumentValues();
        constructorArgumentValues.addGenericArgumentValue("张三");
        constructorArgumentValues.addGenericArgumentValue("北京");
        constructorArgumentValues.addGenericArgumentValue(14212123);
        beanDefinition.setConstructorArgumentValues(constructorArgumentValues);
        //将beanDefinition注册到容器中
        beanFactory.registerBeanDefinition("person",beanDefinition);

        System.out.println(beanFactory.getBean("person"));
    }

}

这里我们直接定义了一个实例，采用手动注册的方式将bean对象注入到ioc容器中。我们来看这段代码在源码中具体做了哪些事情。

第一步创建DefaultListableBeanFactory对象这个就不用说了，看下面的GenericBeanDefinition。之前我们说过beanDefinition是spring中bean对象的描述类，包含一些bean对象的配置信息。比如像作用域啊，bean对象的类、构造函数、init-method、工厂类之类的。
​

这里我们创建了一个GenericBeanDefinition，并且将他的类设置为Person，并且设置了它的构造函数的参数，用构造函数初始化Bean对象。然后通过registerBeanDefinition注册到容器中。
​

这里的注入具体干了什么事情呢？
​

	@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		// 根据beanName查看是否已经有该bean对象存在
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		if (existingDefinition != null) {
			// 将之前的beanDefinition覆盖掉
            // （这里删除了部分代码，实际上容器有个allowBeanDefinitionOverriding信息
            // 默认为true，如果不为true不会进行覆盖操作）
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
            // 这里是判断当前是否已经有bean被创建了，如果有的话，需要加锁来保障线程安全
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
                    // 保存该beanDefinition
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
                    // 从手动注册的bean类表中删除
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				this.beanDefinitionMap.put(beanName, beanDefinition);
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}
		
        // 如果当前已经有缓存的beanDefinition，则重置beanDefinition
		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
		else if (isConfigurationFrozen()) {
             // 清空allBeanNamesByType、singletonBeanNamesByType缓存信息
			clearByTypeCache();
		}
	}

​

这样就把bean对象存到了Ioc容器中。那么当我们调用getBean时做了什么呢？
​

	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

		String beanName = transformedBeanName(name);
		Object bean;

		// 查看当前是否是单例Bean对象
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			// 从缓存中获取单例Bean对象
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 找到对应的BeanDefinition对象
			BeanFactory parentBeanFactory = getParentBeanFactory();
            // 类似双亲委派机制，先找父容器中是否有，优先从父容器中获取bean信息
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else if (requiredType != null) {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}
			
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
                
                // 这里可以有些疑问，什么是MergedBeanDefinition？
                // 实际上之前我们在DefaultListableBeanFactory注册成功之后，
                // 把对应的beanDefinition存到beanDefinitionMap中了。
                // 但是在AbstractBeanFactory中有个mergedBeanDefinitions，
                // 我们最终取的BeanDefinition也是从mergedBeanDefinitions中取的，
                // 所以我们需要合并到mergedBeanDefinitions中。
                // 这个地方做的事情就是如果当前这个BeanDefinition需要合并，就放到
                // mergedBeanDefinitions中，再返回该对象。
                
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
                // 查找依赖，并将依赖实例化
				String[] dependsOn = mbd.getDependsOn();
				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 + "'");
						}
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance.
                // 创建bean实例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
                            // 这个方法实际上是写在AbstractAutowireCapableBeanFactory类中的
                            // 待会再看
							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.
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
                        // 跟上面的isPrototypeCurrentlyInCreation对应
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
                    // 这个地方是给其他作用域用的 比如RequestScope、SessionScope
					String scopeName = mbd.getScope();
					if (!StringUtils.hasLength(scopeName)) {
						throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
					}
					Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, () -> {
                            // 跟上面的isPrototypeCurrentlyInCreation对应
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						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;
			}
		}

	
		return (T) bean;
	}

spring创建对象的类：
实际上最后是InstantiationStrategy决定用哪种策略去创建初始化bean对象。

一共是两种，上面的SimpleInstantiationStrategy直接就用的Java反射。CglibSubclassingInstantiationStrategy采用cglib生成类方式，实例化对象。