ClassPathXmlApplicationContext源码
一个简单的Spring启动代码
public class Test {
public static void main(String[] args) {
ClassPathXmlApplicationContext cxc= new ClassPathXmlApplicationContext("applicationContext.xml");
}
}
点进ClassPathXmlApplicationContext源码
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
//初始化父类对象
super(parent);
//设置配置文件路径
setConfigLocations(configLocations);
if (refresh) {
//Spring上下文初始化
refresh();
}
}
refresh源码
public void refresh() throws BeansException, IllegalStateException {
//加锁，保证Spring上下文初始化并发安全
this.startupShutdownLock.lock();
try {
//获取当前线程
this.startupShutdownThread = Thread.currentThread();
//创建StartupStep对象
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
//在初始化前做一些准备工作
//主要是创建Environment对象、监听器集合以及事件集合
prepareRefresh();
// 创建DefaultListableBeanFactory对象
// 解析xml文件，生成BeanDefinition对象，并且将对象放到Bean工厂的BeanDefinitionMap中
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 给BeanFactory对象的属性初始化
prepareBeanFactory(beanFactory);
try {
// 空方法，等待实现
postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// 实例化并且调用所有已注册的BeanFactoryPostProcessor对象
invokeBeanFactoryPostProcessors(beanFactory);
// 实例化所有的BeanPostProcessor
// 在实例化Bean之后，会调用BeanPostProcessor方法
// 所以需要在实例化Bean之前将BeanPostProcessor准备好
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// 与国际化业务相关
initMessageSource();
// 初始化事件广播器
initApplicationEventMulticaster();
// 初始化特殊的Bean，在Spring中是空方法
// 在SpringBoot中，此方法用于初始化Web容器
onRefresh();
// 注册监听器对象
registerListeners();
// 实例化非懒加载的Bean
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (RuntimeException | Error ex ) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
contextRefresh.end();
}
}
finally {
this.startupShutdownThread = null;
this.startupShutdownLock.unlock();
}
}
prepareRefresh源码
protected void prepareRefresh() {
// 记录prepareRefresh开始时间
this.startupDate = System.currentTimeMillis();
// 设置closed标志为false，active标志为true
this.closed.set(false);
this.active.set(true);
// 设置日志信息
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
// 在上下文环境中初始化占位符属性资源
initPropertySources();
// 初始化Environment对象，并且对必要属性进行校验
getEnvironment().validateRequiredProperties();
// 初始化监听器集合和事件集合
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
this.earlyApplicationEvents = new LinkedHashSet<>();
}
obtainFreshBeanFactory源码
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
return getBeanFactory();
}
protected final void refreshBeanFactory() throws BeansException {
//如果存在BeanFactory
//销毁已有的Bean和BeanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
//创建DefaultListableBeanFactory对象
DefaultListableBeanFactory beanFactory = createBeanFactory();
//设置DefaultListableBeanFactory对象属性值
beanFactory.setSerializationId(getId());
beanFactory.setApplicationStartup(getApplicationStartup());
customizeBeanFactory(beanFactory);
//解析xml文件，生成BeanDefinition对象，并且将对象放到Bean工厂的BeanDefinitionMap中
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
invokeBeanFactoryPostProcessors源码
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
//getBeanFactoryPostProcessors()方法可以获取所有已注册的BeanFactoryPostProcessor对象
//invokeBeanFactoryPostProcessors()方法会调用这些对象中的方法
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null &&
beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
finishBeanFactoryInitialization源码
// 完成非懒加载的单例Bean的实例化
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 实例化类型转换的Bean
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));
}
// 实例化LoadTimeWeaverAware对象
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
beanFactory.getBean(weaverAwareName, LoadTimeWeaverAware.class);
}
// beanFactory的tempClassLoade属性设置为null
beanFactory.setTempClassLoader(null);
// 将元属性值（BeanDefinition的属性）不做修改的Bean放到一个缓存中
beanFactory.freezeConfiguration();
// 实例化非懒加载的单例Bean
beanFactory.preInstantiateSingletons();
}
preInstantiateSingletons源码
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Pre-instantiating singletons in " + this);
}
// 将所有的Bean名称放到beanNames集合中
List<String> beanNames = new ArrayList(this.beanDefinitionNames);
Iterator var2 = beanNames.iterator();
String beanName;
while(var2.hasNext()) {
beanName = (String)var2.next();
// 将具有父类的子类合并父类的属性，生成RootBeanDefinition对象
RootBeanDefinition bd = this.getMergedLocalBeanDefinition(beanName);
// 如果Bean不是抽象的、不是懒加载的、是单例的，立即创建
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 如果Bean实现了FactoryBean，那么就走FactoryBean的创建流程，否则走Spring创建流程
if (this.isFactoryBean(beanName)) {
Object bean = this.getBean("&" + beanName);
if (bean instanceof SmartFactoryBean) {
SmartFactoryBean<?> smartFactoryBean = (SmartFactoryBean)bean;
if (smartFactoryBean.isEagerInit()) {
this.getBean(beanName);
}
}
} else {
// 创建Bean
this.getBean(beanName);
}
}
}
var2 = beanNames.iterator();
while(var2.hasNext()) {
beanName = (String)var2.next();
Object singletonInstance = this.getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize").tag("beanName", beanName);
smartSingleton.afterSingletonsInstantiated();
smartInitialize.end();
}
}
}
preInstantiateSingletons方法中的getBean方法
public Object getBean(String name) throws BeansException {
// doGetBean是真正要创建Bean的方法
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
// 将BeanName进行转换
// 如果这个 name 是 FactoryBean 的beanName (&+beanName),就删除&, 返回beanName
// 传入的name也可以是别名，也需要做转换
String beanName = this.transformedBeanName(name);
// 根据beanName尝试从singletonObjects获取Bean
// 获取不到则再尝试从earlySingletonObjects,singletonFactories 中获取Bean
// 这段代码和解决循环依赖有关
Object sharedInstance = this.getSingleton(beanName);
Object beanInstance;
// Spring项目刚启动时，sharedInstance应该是null
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 如果sharedInstance不为null，也就是非第一次进入
// getObjectForBeanInstance方法判断当前Bean是不是FactoryBean,
// 如果是，传入的name变量如果是(&beanName)，那么beanName变量就是(beanName)，程序在这里要返回FactoryBean
// 如果传入的name变量(beanName)，beanName变量也是(beanName)，但是，之前获取的sharedInstance可能是FactoryBean，需要通过sharedInstance来获取对应的Bean
// 如果传入的name变量(beanName)，那么beanName变量也是(beanName)，获取的sharedInstance就是对应的Bean的话,就直接返回Bean
beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
// Spring项目刚启动时，应该走这里
// 判断是否循环依赖
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取父BeanFactory
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
// 父BeanFactory不为null，走这里
// 从父BeanFactory中尝试获取Bean
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
AbstractBeanFactory abf = (AbstractBeanFactory)parentBeanFactory;
return abf.doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return parentBeanFactory.getBean(nameToLookup);
}
// 创建的Bean是否需要进行类型验证
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate").tag("beanName", name);
try {
if (requiredType != null) {
Objects.requireNonNull(requiredType);
beanCreation.tag("beanType", requiredType::toString);
}
// 获取其父类Bean定义,子类合并父类公共属性
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
// 获取当前Bean依赖的Bean的名称
// 即定义Bean时使用的DependsOn指定的Bean
String[] dependsOn = mbd.getDependsOn();
String[] var12;
if (dependsOn != null) {
// 依赖的Bean不为null，先实例化依赖的Bean
var12 = dependsOn;
int var13 = dependsOn.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dep = var12[var14];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
this.registerDependentBean(dep, beanName);
try {
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var33) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var33);
} catch (BeanCreationException var34) {
if (requiredType != null) {
String var10002 = mbd.getResourceDescription();
String var10004 = var34.getBeanName();
throw new BeanCreationException(var10002, beanName, "Failed to initialize dependency '" + var10004 + "' of " + requiredType.getSimpleName() + " bean '" + beanName + "': " + var34.getMessage(), var34);
}
throw var34;
}
}
}
if (mbd.isSingleton()) {
// 创建单例Bean
sharedInstance = this.getSingleton(beanName, () -> {
try {
//createBean方法中包含了创建Bean的逻辑
//1.Bean实例化
//2.Bean依赖注入
//3.Bean初始化
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
// 创建prototype Bean，每次都会创建一个新的对象
var12 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
beanInstance = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
// 既不是单例Bean，也不是prototype
// 获取Bean的作用域，根据作用域创建Bean
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
}
Scope scope = (Scope)this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
// 创建Bean
Object scopedInstance = scope.get(beanName, () -> {
this.beforePrototypeCreation(beanName);
Object var4;
try {
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
beanInstance = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var32) {
throw new ScopeNotActiveException(beanName, scopeName, var32);
}
}
} catch (BeansException var35) {
beanCreation.tag("exception", var35.getClass().toString());
beanCreation.tag("message", String.valueOf(var35.getMessage()));
this.cleanupAfterBeanCreationFailure(beanName);
throw var35;
} finally {
beanCreation.end();
if (!this.isCacheBeanMetadata()) {
this.clearMergedBeanDefinition(beanName);
}
}
}
return this.adaptBeanInstance(name, beanInstance, requiredType);
}
createBean源码
//创建Bean的入口方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
}
}
Object beanInstance;
try {
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var10) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
}
try {
//创建Bean
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
throw var7;
} catch (Throwable var8) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
}
}
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//缓存中没有获取到Bean
//创建Bean
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.markAsPostProcessed();
}
}
//解决循环依赖
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
//为实例化的Bean填充属性
this.populateBean(beanName, mbd, instanceWrapper);
//Bean初始化
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException) {
BeanCreationException bce = (BeanCreationException)var18;
if (beanName.equals(bce.getBeanName())) {
throw bce;
}
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, var18.getMessage(), var18);
}
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
//注册Bean的销毁方法
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
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());
} else {
if (args == null) {
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return this.obtainFromSupplier(instanceSupplier, beanName, mbd);
}
}
if (mbd.getFactoryMethodName() != null) {
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized(mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
//获取构造器
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
//获取指定使用的构造器
ctors = mbd.getPreferredConstructors();
//如果有指定使用的构造器，就使用
//没有指定的构造器，调用instantiateBean方法
return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
return this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
}
}
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
//instantiate方法创建Bean
Object beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
this.initBeanWrapper(bw);
return bw;
} catch (Throwable var5) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, var5.getMessage(), var5);
}
}
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
if (!bd.hasMethodOverrides()) {
Constructor constructorToUse;
synchronized(bd.constructorArgumentLock) {
constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
constructorToUse = clazz.getDeclaredConstructor();
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable var9) {
throw new BeanInstantiationException(clazz, "No default constructor found", var9);
}
}
}
//使用构造器创建Bean
return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
} else {
return this.instantiateWithMethodInjection(bd, beanName, owner);
}
}
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
ReflectionUtils.makeAccessible(ctor);
if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
return BeanUtils.KotlinDelegate.instantiateClass(ctor, args);
} else {
int parameterCount = ctor.getParameterCount();
Assert.isTrue(args.length <= parameterCount, "Can't specify more arguments than constructor parameters");
if (parameterCount == 0) {
return ctor.newInstance();
} else {
Class<?>[] parameterTypes = ctor.getParameterTypes();
Object[] argsWithDefaultValues = new Object[args.length];
for(int i = 0; i < args.length; ++i) {
if (args[i] == null) {
Class<?> parameterType = parameterTypes[i];
argsWithDefaultValues[i] = parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null;
} else {
argsWithDefaultValues[i] = args[i];
}
}
//使用构造器，通过反射的方式创建Bean
return ctor.newInstance(argsWithDefaultValues);
}
}
} catch (InstantiationException var7) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", var7);
} catch (IllegalAccessException var8) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", var8);
} catch (IllegalArgumentException var9) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", var9);
} catch (InvocationTargetException var10) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", var10.getTargetException());
}
}
