一:原理
当bean是单例时,从缓存获取单例bean;如果没有,则创建单例bean,创建单例bean时用反射获取bean的构造器,通过构造器实例化bean,然后在组装bean,组装bean的时候进行依赖注入;之后把单例bean放入缓存中,无需二次创建。
当bean是多例时,创建过程与单例创建一致,但是不会放在缓存中,那每次调用都会新建多例bean
二:源码解析
org.springframework.beans.factory.support.AbstractBeanFactory#getBean(java.lang.String)
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
// Eagerly check singleton cache for manually registered singletons.
//bean是单例的话,从缓存读取
Object sharedInstance = getSingleton(beanName);
//如果缓存有,直接返回从缓存中获取的bean
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);
}
........................
//缓存中没有,获取该bean的BeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
2.1.单例
// Create bean instance.
//该BeanDefinition是单例的话
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);
}
注:单例为何会只创建一次的原因
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory<?>)
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingleton
/** Cache of singleton objects: bean name --> bean instance */
//单例缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
创建单例实例
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//实例化bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
.......................
try {
//把依赖bean注入
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
通过反射生成实例
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance
// 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.
//instantiateBean实例化bean
return instantiateBean(beanName, mbd);
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean
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);
}
org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition,java.lang.String,org.springframework.beans.factory.BeanFactory)
RootBeanDefinition bd
//用反射,获取class对象,拿到构造器constructorToUse
final Class<?> clazz = bd.getBeanClass();
constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
org.springframework.beans.BeanUtils#instantiateClass(java.lang.reflect.Constructor<T>, java.lang.Object...)
//通过反射,用构造器生成实例
ReflectionUtils.makeAccessible(ctor);
return ctor.newInstance(args);
依赖注入
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
t-->
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
//根据名字注入
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
//根据类型注入
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
.....................
//将PropertyValues pvs放入 BeanWrapper bw中
applyPropertyValues(beanName, mbd, bw, pvs);
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireByName
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
//递归调用,生成依赖链对象
Object bean = getBean(propertyName);
//将bean的依赖bean放入容器中
pvs.add(propertyName, bean);
registerDependentBean(propertyName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("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");
}
}
}
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyPropertyValues
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
//将PropertyValues pvs放入 BeanWrapper bw中
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
}
2.2. 多例
//多例
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);
}