这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析
Bean的加载和实例化Bean的方法
1. 查看源码相关的快捷键
| 快捷键 | 作用 |
|---|---|
| Ctrl + Shift+i | 出现类似于预览的小窗口 |
| Ctrl + Enter | （接上步）完全打开源码 |
| Ctrl + 鼠标左键 | 一步到位打开源码 = Ctrl + Shift+i –>Ctrl + Enter |
| Alt+7 | 查看类的有什么方法 |
| ctrl+f12 | 查看继承方法 |
| ctrl+h | 查看接口的实现类 |
| alt+7 | 查看类的有什么方法 |
| 2下shift | 全局搜索整个项目 |
一. getBean(“xxx”)源码分析
ApplicationContext context = new ClassPathXmlApplicationContext("aplicationContext.xml");
UserT usert = (UserT) context.getBean("usert");
System.out.println(usert.toString());
1. 进doGetBean() 源码进行分析
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 提取对应的beanName去掉&前缀,且如果bean有别名的话,优先使用别名
final String beanName = transformedBeanName(name);
Object bean;
//检查缓存中或者实例工厂中是否有对应的实例
//将ObjectFactory加入到缓存中，一旦下个bean创建时候需要依赖上个bean则直接使用ObjectFactory
//先尝试从缓存获取或者singletonFactories中的ObjectFactory中获取
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
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 = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//只有在单例情况才会尝试解决循环依赖
//判断指定的原型模式的bean是否当前正在创建(在当前线程内),如果是->则抛出异常(Spring不会解决原型模式bean的循环依赖)
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从parentBeanFactory中检测
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
// 递归到BeanFactory中寻找
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// 参数不为空,则委托parentBeanFactory使用显式参数调动
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// 参数为空,则委托parentBeanFactory使用标准的getBean方法获取bean
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
// 否则委托parentBeanFactory使用默认的getBean方法
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// 不仅仅做类型检查则是创建bean，将该bean标记为已经被创建或者即将被创建
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition，
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 若存在依赖则需要递归实例化依赖的bean
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 {
// 实例化依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// singleton模式的创建
//创建单例bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
// 创建bean
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// prototype模式的创建
// 创建原型模式bean
else if (mbd.isPrototype()) {
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 指定的scope上实例化bean
String scopeName = mbd.getScope();
final 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, () -> {
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;
}
}
// 检查需要的类型是否符合bean的实际类型
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
2. 上述代码执行的流程解释一下
-
提取对应的beanName去掉&前缀,且如果bean有别名的话,优先使用别名
-
尝试从缓存中加载单例。
检查缓存中或者实例工厂中是否有对应的实例，将ObjectFactory加入到缓存中，一旦下个bean创建时候需要依赖上个bean则直接使用ObjectFactory，先尝试从缓存获取或者singletonFactories中的ObjectFactory中获取
-
bean的实例化。
如果从缓存中得到了bean的原始状态，则需要对bean进行实例化。返回对应的实例，有时候并不是直接返回实例本身而是返回指定方法返回的实例
-
原型模式的依赖检查。
只有在单例情况才会尝试解决循环依赖,判断指定的原型模式的bean是否当前正在创建(在当前线程内),如果是->则抛出异常(Spring不会解决原型模式bean的循环依赖)
-
检测parentBeanFactory。
如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从parentBeanFactory中检测
-
将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition。
因为从XML配置文件中读取到的Bean信息是存储在GenericBeanDefinition中的，但是所有的Bean后续处理都是针对于RootBeanDefinition的，所以这里需要进行转换，转换的同时如果父类bean不为空的话，则会一并合并父类的属性。
-
根据 Scope 进行 bean 的创建。
我们都知道，在 Spring 中存在着不同的 scope ，其中默认的是 singleton ，但是还有些其他的配置诸如 prototype、 request 之类的。Sring会根据不同的配置进行不同的初始化策略。
-
检查需要的类型是否符合bean的实际类型
二. 从缓存中获取单例bean
1.transformedBeanName() 方法解析
protected String transformedBeanName(String name) {
// 转换并规范beanName
//转换beanName
//该方法的作用是返回bean的真实名称,去掉FactoryBean引用前缀&符号
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
public static String transformedBeanName(String name) {
//返回bean的真实名称,去掉FactoryBean引用前缀
Assert.notNull(name, "'name' must not be null");
if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
return name;
}
return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
do {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
//beanName前缀为&,循环截取直至所有&被去掉
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
return beanName;
});
}
public String canonicalName(String name) {
//确定原始名称，将别名解析为规范名称。
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
//从别名缓存Map中获取对应beanName
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
2. DefaultSingletonBeanRegistry
Spring在创建bean之后都会缓存bean的实例，方便下次使用
1. DefaultSingletonBeanRegistry 源码解析
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
//缓存beanName和bean实例 key-->beanName,value-->beanInstance
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//缓存beanName和beanFactory key–>beanName,value–>beanFactory
//解决bean的循环依赖引用
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
//缓存beanName和bean实例 key–>beanName,value–>beanInstance
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
//缓存所有注册的单例beanName
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
3. 测试
ApplicationContext context = new ClassPathXmlApplicationContext("aplicationContext.xml");
// 1、创建新的usert实例
UserT usert = (UserT) context.getBean("usert",UserT.class);
// 2、从缓存中获取usert实例
usert = (UserT) context.getBean("usert",UserT.class);
System.out.println(usert.toString());
4. getSingleton()方法解析
该方法的作用是从IoC容器获取bean的实例
在doGetBean() 方法中进入getSingleton
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 1、从缓存中获取bean
Object singletonObject = this.singletonObjects.get(beanName);
// 2、未能获取到bean,但是允许对当前创建的单例的早期引用(解决循环引用)
// isSingletonCurrentlyInCreation-->判断指定的单例bean是否当前正在创建(Spring只解决单例bean的循环依赖问题)
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从earlySingletonObjects获取提前曝光的bean
singletonObject = this.earlySingletonObjects.get(beanName);
// 未能获取到提前曝光的bean且当前的bean允许被创建早期依赖
if (singletonObject == null && allowEarlyReference) {
// 从缓存中获取BeanFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 通过getObject()方法获取bean,注意:通过此方法获取的bean不是被缓存的
singletonObject = singletonFactory.getObject();
// 将获取到的singletonObject缓存至earlySingletonObjects
this.earlySingletonObjects.put(beanName, singletonObject);
// 从singletonFactories移除bean
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
5. getObjectForBeanInstance
无论是从缓存获取单例bean还是新创建的单例bean，在bean实例化之后都会调用getObjectForBeanInstance方法，该方法的作用就是判断到底是应该返回一个普通的bean的实例还是返回FactoryBean的实例。
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 1、判断bean是否factoryBean
// 因BeanFactoryUtils.isFactoryDereference(name)-->只是从bean名称上进行了判断,我们通过getBean("&myBean")可以人为将一个非factoryBean当做factoryBean
// 所以这里必须要判断beanInstance是否为FactoryBean的实例
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
// 当前bean是factoryBean,但是不是FactoryBean的实例,则抛出异常
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
//可以确定当前获取的是普通的bean实例
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
// 现在我们有了bean实例，它可能是一个普通的bean，也可能是一个FactoryBean。
// 如果它是FactoryBean，我们使用它创建一个bean实例，除非调用者实际上需要工厂的引用。
Object object = null;
// 如果beanDefinition为null,则尝试从缓存中获取给定的FactoryBean公开的对象
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
object = getCachedObjectForFactoryBean(beanName);
}
// 未能从缓存中获得FactoryBean公开的对象,则说明该bean是一个新创建的bean
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// rootBeanDefinition为null,但是在beanDefinitionMap中缓存了对应的beanName
if (mbd == null && containsBeanDefinition(beanName)) {
//合并beanDefinition(包括父类bean)
mbd = getMergedLocalBeanDefinition(beanName);
}
// 如果beanDefinition不为null,则要判断该beanDefinition对象是否通过合成获得
// 如果不是,则说明该beanDefinition不由有程序本身定义的
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 从给定的FactoryBean中获取指定的beanName对象
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
三. 无参构造方法实例化单例bean
1. doCreateBea() 源码分析
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 实例化bean
BeanWrapper instanceWrapper = null;
//factoryBeanInstanceCache是ConcurrentMap,remove方法会返回删除的键值(如果不存在返回null)
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 如果factoryBeanInstanceCache没有缓存对应的BeanWrapper,则重新创建bean实例
if (instanceWrapper == null) {
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//允许MergedBeanDefinitionPostProcessor后处理器修改已合并的bean定义。
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;
}
}
// 提前缓存ObjectFactory以解决bean之间的循环依赖
// mbd.isSingleton()->是否单例
//allowCircularReferences->是否允许循环依赖
// isSingletonCurrentlyInCreation->该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已经完成了实例化,但是还没有完成初始化的操作,如bean的属性填充
Object exposedObject = bean;
try {
// 填充bean属性
populateBean(beanName, mbd, instanceWrapper);
// 初始化bean
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<>(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.");
}
}
}
}
// 根据bean的作用域注册bean
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
//返回bean实例
return exposedObject;
}
createBeanInstance() 源码分析
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
//确保此时beanClass已经被解析
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// beanClass不为空,且beanClass的修饰符为不为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);
}
//如果有工厂方法的话,则使用工厂方法实例化bean
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
//当创建一个相同的bean时,使用之间保存的快照
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 如果该bean已经被解析过
if (resolved) {
// 使用已经解析过的构造函数实例化
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
}
// 使用默认无参构造函数实例化
else {
return instantiateBean(beanName, mbd);
}
}
//确定需要使用的构造函数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// 无任何的特殊处理,则使用默认的无参构造函数实例化bean
return instantiateBean(beanName, mbd);
}
以上步骤分三步走
- 工厂方法（实例工厂和静态工厂）
- 构造函数实例化（无参构造和有参构造）
- 通过实例提供者实例化（Spring5新增的实例化策略）
无参构造函数实例化分析
instantiateBean() 源码分析
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
// 1、如果权限管理器不为空,需要校验
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
// 2、获取实例化策略并实例化bean
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
// 3、实例并初始化BeanWrapper对象
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
- 获取实例化策略
- 除了new关键字之外，通过JDK的反射机制或CGLIB动态代理来创建对象实例
instantiate() 源码分析
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
/ // 1、如果没有使用方法覆盖(replace-method或lookup-method注入),则直接使用反射创建bean的实例
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
synchronized (bd.constructorArgumentLock) {
// 尝试获取已经解析的构造方法
constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = AccessController.doPrivileged(
(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
}
else {
// 未能获取到已经解析过的构造方法，则通过getDeclaredConstructor方法获取构造方法
constructorToUse = clazz.getDeclaredConstructor();
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
}
catch (Throwable ex) {
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
}
}
// 通过BeanUtils类实例化bean
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// 否则必须使用CGLIB实例化策略
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
-
通过BeanDefinition判断有没有replace-method或lookup-method注入即可；如果没有则默认使用反射机制实例化bean，否则必须使用CGLIB实例bean
-
反射机制实例化bean
instantiateClass() 源码分析
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 KotlinDelegate.instantiateClass(ctor, args);
}
else {
Class<?>[] parameterTypes = ctor.getParameterTypes();
Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
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];
}
}
//通过ctor.newInstance(args)方法创建了Bean的实例
return ctor.newInstance(argsWithDefaultValues);
}
}
catch (InstantiationException ex) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
}
catch (IllegalAccessException ex) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
}
catch (IllegalArgumentException ex) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
}
catch (InvocationTargetException ex) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
}
}
- CGLIB实例bean
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
}
instantiateWithMethodInjection() 源码分析
@Override
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
return instantiateWithMethodInjection(bd, beanName, owner, null);
}
@Override
protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
@Nullable Constructor<?> ctor, Object... args) {
// Must generate CGLIB subclass...
return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
}
instantiate() 源码分析
public Object instantiate(@Nullable Constructor<?> ctor, Object... args) {
// 1、生成增强子类
Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
Object instance;
// 2、实例化增强子类 采用了jdk的反射机制
if (ctor == null) {
instance = BeanUtils.instantiateClass(subclass);
}
else {
try {
Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
instance = enhancedSubclassConstructor.newInstance(args);
}
catch (Exception ex) {
throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
"Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
}
}
// 3、设置回调
Factory factory = (Factory) instance;
factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
return instance;
}
四. 有参构造方法实例化单例bean
- 如果该bean的构造函数已经被解析并缓存的话，则优先使用已经被解析的构造函数实例化，否则解析bean的构造函数并实例化。
- 解析构造函数
3. 创建ConstructorResolver对象
autowireConstructor() 源码分析
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
Constructor<?> constructorToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
// 1、 判断有无显式指定参数,如果有则优先使用
if (explicitArgs != null) {
argsToUse = explicitArgs;
}
// 2、 没有显式指定参数,则解析配置文件中的参数
else {
Object[] argsToResolve = null;
// 3、 优先尝试从缓存中获取,spring对参数的解析过程是比较复杂也耗时的,所以这里先尝试从缓存中获取已经解析过的构造函数参数
synchronized (mbd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached constructor...
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
// 缓存中存在,则解析构造函数参数类型
if (argsToResolve != null) {
argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
}
}
// 4、 缓存中不存在,则需要解析构造函数参数,以确定使用哪一个构造函数来进行实例化
if (constructorToUse == null || argsToUse == null) {
//5、 使用指定的构造函数(如果有的话)。
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
try {
// 6、 如果指定的构造函数不存在,则根据方法访问级别,获取该bean所有的构造函数
candidates = (mbd.isNonPublicAccessAllowed() ?
beanClass.getDeclaredConstructors() : beanClass.getConstructors());
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Resolution of declared constructors on bean Class [" + beanClass.getName() +
"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
}
}
if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
Constructor<?> uniqueCandidate = candidates[0];
if (uniqueCandidate.getParameterCount() == 0) {
synchronized (mbd.constructorArgumentLock) {
mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
mbd.constructorArgumentsResolved = true;
mbd.resolvedConstructorArguments = EMPTY_ARGS;
}
bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
return bw;
}
}
// Need to resolve the constructor.
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
ConstructorArgumentValues resolvedValues = null;
// 这里定义了一个变量,来记录最小的构造函数参数个数
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
}
else {
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}
// 对构造函数按照参数个数和参数类型进行排序,参数最多的构造函数会排在第一位
AutowireUtils.sortConstructors(candidates);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Constructor<?>> ambiguousConstructors = null;
LinkedList<UnsatisfiedDependencyException> causes = null;
// 循环所有bean类中的构造函数,解析确定使用哪一个构造函数
for (Constructor<?> candidate : candidates) {
Class<?>[] paramTypes = candidate.getParameterTypes();
if (constructorToUse != null && argsToUse != null && argsToUse.length > paramTypes.length) {
// Already found greedy constructor that can be satisfied ->
// do not look any further, there are only less greedy constructors left.
break;
}
if (paramTypes.length < minNrOfArgs) {
continue;
}
// 获取ArgumentsHolder对象,直接理解为一个参数持有者即可
ArgumentsHolder argsHolder;
if (resolvedValues != null) {
try {
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
if (paramNames == null) {
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
paramNames = pnd.getParameterNames(candidate);
}
}
argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
}
catch (UnsatisfiedDependencyException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
}
// Swallow and try next constructor.
if (causes == null) {
causes = new LinkedList<>();
}
causes.add(ex);
continue;
}
}
else {
// Explicit arguments given -> arguments length must match exactly.
if (paramTypes.length != explicitArgs.length) {
continue;
}
argsHolder = new ArgumentsHolder(explicitArgs);
}
// 通过构造函数参数权重对比,得出最适合使用的构造函数
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// 如果此构造函数表示最接近的匹配，则选择此构造函数
if (typeDiffWeight < minTypeDiffWeight) {
// 将解析到的构造函数赋予constructorToUse
constructorToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousConstructors = null;
}
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
if (ambiguousConstructors == null) {
ambiguousConstructors = new LinkedHashSet<>();
ambiguousConstructors.add(constructorToUse);
}
ambiguousConstructors.add(candidate);
}
}
// 异常处理
if (constructorToUse == null) {
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
this.beanFactory.onSuppressedException(cause);
}
throw ex;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Could not resolve matching constructor " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
}
else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Ambiguous constructor matches found in bean '" + beanName + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousConstructors);
}
// 缓存解析的构造函数
if (explicitArgs == null && argsHolderToUse != null) {
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
Assert.state(argsToUse != null, "Unresolved constructor arguments");
// 返回BeanWrapper包装类
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;
}
过程分析
- 判断有无显式指定参数,如果有则优先使用
- 优先尝试从缓存中获取，先尝试从缓存中获取已经解析过的构造函数参数
- 缓存中不存在,则需要解析构造函数参数
- 使用指定的构造函数，这里说的指定构造函数,并不是我们在配置文件中指定的构造函数,而是通过解析SmartInstantiationAwareBeanPostProcessor得出的构造函数。
- 如果指定的构造函数不存在,则根据方法访问级别,获取该bean所有的构造函数，该步骤获取的是类的构造函数，而不是在配置文件中的构造函数。
- 对构造函数按照参数个数和参数类型进行排序,参数最多的构造函数会排在第一位
- 循环所有bean类中的构造函数,解析确定使用哪一个构造函数
- 首先因为构造函数已经按照参数的个数排序，参数个数最多的排在最前面，
- 其次将解析到的构造函数封装至ArgumentsHolder对象。
- 最后通过构造函数参数权重对比,得出最适合使用的构造函数。
- 处理异常，缓存解析过的构造函数。
- 获取实例化策略并执行实例化，射或CGLIB实例化bean
- 返回BeanWrapper包装类
扫一扫
714
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
