解析spring源码，IOC之bean的创建与获取

淡淡的烟草味﹌ 2022-03-16 15:06 291阅读 0赞

> **本文主要内容及做什么**
> 
> 主要针对spring中的ioc，采用debug方式讲解spring如何创建和获取bean，承接上篇博客[解析spring源码，IOC加载bean资源配置文件][spring_IOC_bean]

test代码为：

public class test {
    	public static void main(String[] args) {
    		ApplicationContext cx = new ClassPathXmlApplicationContext("applicationContext.xml");
    		PersonServiceImpl obj = cx.getBean(PersonServiceImpl.class);
    		System.out.println(obj.toString());
    	}
    }

getBean方法获取到了一个bean对象，进入其内部，了解其原理，下面debug进入 *PersonServiceImpl obj = cx.getBean(PersonServiceImpl.class);* 这行代码。

1、进入 cx.getBean() 方法：

public <T> T getBean(Class<T> requiredType) throws BeansException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBean(requiredType);
    	}

跳转到了 ***ClassPathXmlApplicationContext*** 类的父类 ***AbstractApplicationContext*** 中，***AbstractApplicationContext*** 为一个抽象类，***AbstractApplicationContext*** 有多个重载的getBean()方法，其中比较熟悉的最为 getBean(String name) 和 getBean(Class<T> requiredType)，分别传参为bean的id和bean对象类的class对象。***AbstractApplicationContext*** 抽象类间接的继承了 ***BeanFactory*** 接口，***BeanFactory*** 可以称为spring ioc鼻祖，所有接口、抽象类、普通类都继承了 ***BeanFactory*** ，相当于java中的***Object***类，***BeanFactory*** 接口中定义的方法并不是很多，主要是对bean的操作，有getBean()、containsBean()、isSingleton()等。

2、 getBeanFactory().getBean(requiredType)，首先 getBeanFactory() 获取已经创建好的BeanFactory，如果不存在或者关闭则抛出异常。

进入getBean方法，跳转到 ***DefaultListableBeanFactory*** 类中：

public <T> T getBean(Class<T> requiredType) throws BeansException {
    		Assert.notNull(requiredType, "Required type must not be null");
    		String[] beanNames = getBeanNamesForType(requiredType);
    		if (beanNames.length > 1) {
    			ArrayList<String> autowireCandidates = new ArrayList<String>();
    			for (String beanName : beanNames) {
    				if (getBeanDefinition(beanName).isAutowireCandidate()) {
    					autowireCandidates.add(beanName);
    				}
    			}
    			if (autowireCandidates.size() > 0) {
    				beanNames = autowireCandidates.toArray(new String[autowireCandidates.size()]);
    			}
    		}
    		if (beanNames.length == 1) {
    			return getBean(beanNames[0], requiredType);
    		}
    		else if (beanNames.length > 1) {
    			T primaryBean = null;
    			for (String beanName : beanNames) {
    				T beanInstance = getBean(beanName, requiredType);
    				if (isPrimary(beanName, beanInstance)) {
    					if (primaryBean != null) {
    						throw new NoUniqueBeanDefinitionException(requiredType, beanNames.length,
    								"more than one 'primary' bean found of required type: " + Arrays.asList(beanNames));
    					}
    					primaryBean = beanInstance;
    				}
    			}
    			if (primaryBean != null) {
    				return primaryBean;
    			}
    			throw new NoUniqueBeanDefinitionException(requiredType, beanNames);
    		}
    		else if (getParentBeanFactory() != null) {
    			return getParentBeanFactory().getBean(requiredType);
    		}
    		else {
    			throw new NoSuchBeanDefinitionException(requiredType);
    		}
    	}

方法 getBeanNamesForType(requiredType) 返回的是传入类类型已经存在的bean的名字集合，bean的名字即为id，进入getBeanNamesForType()方法可以看到spring使用ArrayList来存放bean名字集合，这里我们只指定了一个bean，所以beanNames的值也只有一个，beanNames.length的值为1。

3、进入 getBean(beanNames\[0\], requiredType)，跳转到 ***AbstractBeanFactory*** 抽象类中：

public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    		return doGetBean(name, requiredType, null, false);
    	}

再进入

protected <T> T doGetBean(
    			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
    			throws BeansException {
    
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    		// Eagerly check singleton cache for manually registered singletons.
    		Object sharedInstance = getSingleton(beanName);
    		if (sharedInstance != null && args == null) {
    			if (logger.isDebugEnabled()) {
    				if (isSingletonCurrentlyInCreation(beanName)) {
    					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
    							"' that is not fully initialized yet - a consequence of a circular reference");
    				}
    				else {
    					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
    				}
    			}
    			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);
    			}
    
    			// Check if bean definition exists in this factory.
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    				// Not found -> check parent.
    				String nameToLookup = originalBeanName(name);
    				if (args != null) {
    					// Delegation to parent with explicit args.
    					return (T) parentBeanFactory.getBean(nameToLookup, args);
    				}
    				else {
    					// No args -> delegate to standard getBean method.
    					return parentBeanFactory.getBean(nameToLookup, requiredType);
    				}
    			}
    
    			if (!typeCheckOnly) {
    				markBeanAsCreated(beanName);
    			}
    
    			try {
    				final 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 dependsOnBean : dependsOn) {
    						if (isDependent(beanName, dependsOnBean)) {
    							throw new BeanCreationException("Circular depends-on relationship between '" +
    									beanName + "' and '" + dependsOnBean + "'");
    						}
    						registerDependentBean(dependsOnBean, beanName);
    						getBean(dependsOnBean);
    					}
    				}
    
    				// Create bean instance.
    				if (mbd.isSingleton()) {
    					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
    						@Override
    						public Object getObject() throws BeansException {
    							try {
    								return createBean(beanName, mbd, args);
    							}
    							catch (BeansException ex) {
    								// Explicitly remove instance from singleton cache: It might have been put there
    								// eagerly by the creation process, to allow for circular reference resolution.
    								// Also remove any beans that received a temporary reference to the bean.
    								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 {
    						beforePrototypeCreation(beanName);
    						prototypeInstance = createBean(beanName, mbd, args);
    					}
    					finally {
    						afterPrototypeCreation(beanName);
    					}
    					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    				}
    
    				else {
    					String scopeName = mbd.getScope();
    					final Scope scope = this.scopes.get(scopeName);
    					if (scope == null) {
    						throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
    					}
    					try {
    						Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
    							@Override
    							public Object getObject() throws BeansException {
    								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;
    			}
    		}
    
    		// Check if required type matches the type of the actual bean instance.
    		if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
    			try {
    				return getTypeConverter().convertIfNecessary(bean, requiredType);
    			}
    			catch (TypeMismatchException ex) {
    				if (logger.isDebugEnabled()) {
    					logger.debug("Failed to convert bean '" + name + "' to required type [" +
    							ClassUtils.getQualifiedName(requiredType) + "]", ex);
    				}
    				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    			}
    		}
    		return (T) bean;
    	}

4、先看 Object sharedInstance = getSingleton(beanName) 方法：

public Object getSingleton(String beanName) {
    		return getSingleton(beanName, true);
    	}

/**
    	 * Return the (raw) singleton object registered under the given name.
    	 * <p>Checks already instantiated singletons and also allows for an early
    	 * reference to a currently created singleton (resolving a circular reference).
    	 */
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    		Object singletonObject = this.singletonObjects.get(beanName);
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    			synchronized (this.singletonObjects) {
    				singletonObject = this.earlySingletonObjects.get(beanName);
    				if (singletonObject == null && allowEarlyReference) {
    					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    					if (singletonFactory != null) {
    						singletonObject = singletonFactory.getObject();
    						this.earlySingletonObjects.put(beanName, singletonObject);
    						this.singletonFactories.remove(beanName);
    					}
    				}
    			}
    		}
    		return (singletonObject != NULL_OBJECT ? singletonObject : null);
    	}

/** Cache of singleton objects: bean name --> bean instance */
    	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);

注解的是使用给定的bean名称返回一个原生的singleton实例。首先根据给定名称在singletonObjects中取Object，singletonObjects为一个ConcurrentHashMap，用于存放bean实例，也可以说是缓存。由于并没有缓存bean对象，所以singletonObject为空。isSingletonCurrentlyInCreation()用于判断当前singleton实例是否已经处于正在创建的过程，此时应该返回是false，因为没有处于正在创建。

if (singletonObject == null && isSingletonCurrentlyInCreation(beanName))值为false，getSingleton()方法返空值为空。

5、再回到3中的getBean()方法中，sharedInstance为空，debug进了else代码块中，然后进了

if (!typeCheckOnly) {
    				markBeanAsCreated(beanName);
    			}

进入markBeanAsCreated()方法：

/**
    	 * Mark the specified bean as already created (or about to be created).
    	 * <p>This allows the bean factory to optimize its caching for repeated
    	 * creation of the specified bean.
    	 * @param beanName the name of the bean
    	 */
    	protected void markBeanAsCreated(String beanName) {
    		this.alreadyCreated.add(beanName);
    	}

注释为将指定的bean标识为已经创建或即将创建，alreadyCreated同样为hashmap，key为bean的名字，value为Boolean，spring有三级缓存，提前暴露，大幅度提高了访问和创建bean的效率。

6、再看代码块：

// Guarantee initialization of beans that the current bean depends on.
    				String[] dependsOn = mbd.getDependsOn();
    				if (dependsOn != null) {
    					for (String dependsOnBean : dependsOn) {
    						if (isDependent(beanName, dependsOnBean)) {
    							throw new BeanCreationException("Circular depends-on relationship between '" +
    									beanName + "' and '" + dependsOnBean + "'");
    						}
    						registerDependentBean(dependsOnBean, beanName);
    						getBean(dependsOnBean);
    					}
    				}

注释的是确保当前bean依赖的bean已经被创建好，涉及到ioc的依赖注入。

7、再看代码块：

// Create bean instance.
    				if (mbd.isSingleton()) {
    					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
    						@Override
    						public Object getObject() throws BeansException {
    							try {
    								return createBean(beanName, mbd, args);
    							}
    							catch (BeansException ex) {
    								// Explicitly remove instance from singleton cache: It might have been put there
    								// eagerly by the creation process, to allow for circular reference resolution.
    								// Also remove any beans that received a temporary reference to the bean.
    								destroySingleton(beanName);
    								throw ex;
    							}
    						}
    					});
    					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    				}

这里才是真正的去创建bean实例。

8、进入上述的 createBean(beanName, mbd, args) 方法，这方法中创建bean实例：

/**
    	 * Central method of this class: creates a bean instance,
    	 * populates the bean instance, applies post-processors, etc.
    	 * @see #doCreateBean
    	 */
    	protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    			throws BeanCreationException {
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Creating instance of bean '" + beanName + "'");
    		}
    		// Make sure bean class is actually resolved at this point.
    		resolveBeanClass(mbd, beanName);
    
    		// Prepare method overrides.
    		try {
    			mbd.prepareMethodOverrides();
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
    					beanName, "Validation of method overrides failed", ex);
    		}
    
    		try {
    			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    			Object bean = resolveBeforeInstantiation(beanName, mbd);
    			if (bean != null) {
    				return bean;
    			}
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"BeanPostProcessor before instantiation of bean failed", ex);
    		}
    
    		Object beanInstance = doCreateBean(beanName, mbd, args);
    		if (logger.isDebugEnabled()) {
    			logger.debug("Finished creating instance of bean '" + beanName + "'");
    		}
    		return beanInstance;
    	}

9、进入 Object beanInstance = doCreateBean(beanName, mbd, args)：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    		// Instantiate the bean.
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) {
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) {
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    
    		// Allow post-processors to modify the merged bean definition.
    		synchronized (mbd.postProcessingLock) {
    			if (!mbd.postProcessed) {
    				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    				mbd.postProcessed = true;
    			}
    		}
    
    		// Eagerly cache singletons to be able to resolve circular references
    		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    				isSingletonCurrentlyInCreation(beanName));
    		if (earlySingletonExposure) {
    			if (logger.isDebugEnabled()) {
    				logger.debug("Eagerly caching bean '" + beanName +
    						"' to allow for resolving potential circular references");
    			}
    			addSingletonFactory(beanName, new ObjectFactory<Object>() {
    				@Override
    				public Object getObject() throws BeansException {
    					return getEarlyBeanReference(beanName, mbd, bean);
    				}
    			});
    		}
    
    		// Initialize the bean instance.
    		Object exposedObject = bean;
    		try {
    			populateBean(beanName, mbd, instanceWrapper);
    			if (exposedObject != null) {
    				exposedObject = initializeBean(beanName, exposedObject, mbd);
    			}
    		}
    		catch (Throwable ex) {
    			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
    				throw (BeanCreationException) ex;
    			}
    			else {
    				throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    			}
    		}
    
    		if (earlySingletonExposure) {
    			Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) {
    				if (exposedObject == bean) {
    					exposedObject = earlySingletonReference;
    				}
    				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    					String[] dependentBeans = getDependentBeans(beanName);
    					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
    					for (String dependentBean : dependentBeans) {
    						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
    							actualDependentBeans.add(dependentBean);
    						}
    					}
    					if (!actualDependentBeans.isEmpty()) {
    						throw new BeanCurrentlyInCreationException(beanName,
    								"Bean with name '" + beanName + "' has been injected into other beans [" +
    								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
    								"] in its raw version as part of a circular reference, but has eventually been " +
    								"wrapped. This means that said other beans do not use the final version of the " +
    								"bean. This is often the result of over-eager type matching - consider using " +
    								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
    					}
    				}
    			}
    		}
    
    		// Register bean as disposable.
    		try {
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}

10、进入instanceWrapper = createBeanInstance(beanName, mbd, args)，createBeanInstance()方法为创建类的实例：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    		// Make sure bean class is actually resolved at this point.
    		Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    		}
    
    		if (mbd.getFactoryMethodName() != null)  {
    			return instantiateUsingFactoryMethod(beanName, mbd, args);
    		}
    
    		// Shortcut when re-creating the same bean...
    		boolean resolved = false;
    		boolean autowireNecessary = false;
    		if (args == null) {
    			synchronized (mbd.constructorArgumentLock) {
    				if (mbd.resolvedConstructorOrFactoryMethod != null) {
    					resolved = true;
    					autowireNecessary = mbd.constructorArgumentsResolved;
    				}
    			}
    		}
    		if (resolved) {
    			if (autowireNecessary) {
    				return autowireConstructor(beanName, mbd, null, null);
    			}
    			else {
    				return instantiateBean(beanName, mbd);
    			}
    		}
    
    		// Need to determine the constructor...
    		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    		if (ctors != null ||
    				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
    				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
    			return autowireConstructor(beanName, mbd, ctors, args);
    		}
    
    		// No special handling: simply use no-arg constructor.
    		return instantiateBean(beanName, mbd);
    	}

看最后两行代码，注释的是没有特殊的处理，使用无参数构造方法，创建类的实例需要使用其构造方法，这里使用默认无参构造方法来创建bean实例。

11、进入 instantiateBean(beanName, mbd)：

/**
    	 * Instantiate the given bean using its default constructor.
    	 * @param beanName the name of the bean
    	 * @param mbd the bean definition for the bean
    	 * @return BeanWrapper for the new instance
    	 */
    	protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
    		try {
    			Object beanInstance;
    			final BeanFactory parent = this;
    			if (System.getSecurityManager() != null) {
    				beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
    					@Override
    					public Object run() {
    						return getInstantiationStrategy().instantiate(mbd, beanName, parent);
    					}
    				}, getAccessControlContext());
    			}
    			else {
    				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    			}
    			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    			initBeanWrapper(bw);
    			return bw;
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    		}
    	}

12、再进入beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent)，返回的是bean的实例：

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
    		// Don't override the class with CGLIB if no overrides.
    		if (beanDefinition.getMethodOverrides().isEmpty()) {
    			Constructor<?> constructorToUse;
    			synchronized (beanDefinition.constructorArgumentLock) {
    				constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
    				if (constructorToUse == null) {
    					final Class<?> clazz = beanDefinition.getBeanClass();
    					if (clazz.isInterface()) {
    						throw new BeanInstantiationException(clazz, "Specified class is an interface");
    					}
    					try {
    						if (System.getSecurityManager() != null) {
    							constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
    								@Override
    								public Constructor<?> run() throws Exception {
    									return clazz.getDeclaredConstructor((Class[]) null);
    								}
    							});
    						}
    						else {
    							constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
    						}
    						beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
    					}
    					catch (Exception ex) {
    						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
    					}
    				}
    			}
    			return BeanUtils.instantiateClass(constructorToUse);
    		}
    		else {
    			// Must generate CGLIB subclass.
    			return instantiateWithMethodInjection(beanDefinition, beanName, owner);
    		}
    	}

这里解析出默认的无参构造方法。

13、再进入BeanUtils.instantiateClass(constructorToUse)，真正创建bean实例：

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
    		Assert.notNull(ctor, "Constructor must not be null");
    		try {
    			ReflectionUtils.makeAccessible(ctor);
    			return ctor.newInstance(args);
    		}
    		catch (InstantiationException ex) {
    			throw new BeanInstantiationException(ctor.getDeclaringClass(),
    					"Is it an abstract class?", ex);
    		}
    		catch (IllegalAccessException ex) {
    			throw new BeanInstantiationException(ctor.getDeclaringClass(),
    					"Is the constructor accessible?", ex);
    		}
    		catch (IllegalArgumentException ex) {
    			throw new BeanInstantiationException(ctor.getDeclaringClass(),
    					"Illegal arguments for constructor", ex);
    		}
    		catch (InvocationTargetException ex) {
    			throw new BeanInstantiationException(ctor.getDeclaringClass(),
    					"Constructor threw exception", ex.getTargetException());
    		}
    	}

public static void makeAccessible(Constructor<?> ctor) {
    		if ((!Modifier.isPublic(ctor.getModifiers()) || !Modifier.isPublic(ctor.getDeclaringClass().getModifiers()))
    				&& !ctor.isAccessible()) {
    			ctor.setAccessible(true);
    		}
    	}

makeAccessible()方法是防止bean类构造方法私有化，以致于不能被调用，这里重点关注ctor.newInstance(args)方法。

14，进入ctor.newInstance(args)：

public T newInstance(Object ... initargs)
            throws InstantiationException, IllegalAccessException,
                   IllegalArgumentException, InvocationTargetException
        {
            if (!override) {
                if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                    Class<?> caller = Reflection.getCallerClass();
                    checkAccess(caller, clazz, null, modifiers);
                }
            }
            if ((clazz.getModifiers() & Modifier.ENUM) != 0)
                throw new IllegalArgumentException("Cannot reflectively create enum objects");
            ConstructorAccessor ca = constructorAccessor;   // read volatile
            if (ca == null) {
                ca = acquireConstructorAccessor();
            }
            @SuppressWarnings("unchecked")
            T inst = (T) ca.newInstance(initargs);
            return inst;
        }

使用反射创建bean实例，spring创建bean实例是使用java反射机制创建，当获取到class类型之后，就可以使用java反射机制来创建该类的实例，再返回该实例。

创建完bean实例后，讲实例返回，spring将会对bean进行属性装配，把bean放入spring缓存中，beanname作为key，bean实例为value放入singletonObjects中，同时还会更新其他相应的缓存，当spring第二次获取相同bean时直接在缓存当中获取即可，不需要新创建。

[spring_IOC_bean]: https://blog.csdn.net/a281246240/article/details/87920037