Srping入口
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
Test test = (Test)bf.getBean("test");XmlBeanFactory类图
从上往下，从左到右，依次为:
- AliasRegistry:定义对alias的简单增删改查(alias指的是别名)
- BeanDefinitionRegistry:定义对BeanDefinition的各种增删改查(BeanDefinition存储着配置文件中Bean的信息)
- SimpleAliasRegistry:实现AliasRegistry，使用map作为alias的缓存
- SingletonBeanRegistry:定义对单例的注册及获取
- BeanFactory:定义获取Bean及Bean的各种属性
- DefaultSingletonBeanRegistry:对SingletonBeanRegistry函数的实现
- HierarchicalBeanFactory:继承BeanFactory，也就是在BeanFactory定义的功能的基础上增加了对parentFactory的支持
- ListableBeanFactory:根据各种条件获取bean的配置清单
- FactoryBeanRegistrySupport:在DefaultSingletonBeanRegistry基础上增加了对FactoryBean的特殊处理功能
- ConfigurableBeanFactory:提供配置Factory的各种方法(类似ClassLoader、类型转换器等等)
- AbstractBeanFactory:实现FactoryBeanRegistrySupport和ConfigurableBeanFactory的功能
- AutowireCapableBeanFactory:提供创建Bean、自动注入、初始化以及应用Bean的后处理器
- AbstractAutowireCapableBeanFactory:综合AbstractBeanFactory并且实现AutowireCapableBeanFactory
上面的解释很枯燥，而且看起来很庞大，我们先不管上面的类有什么用，大概知道体系是这样就行了。
Spring执行的顺序是 读取配置文件 把配置信息填充到 BeanDefinition(包括别名、类的全限命名、属性、id等等) 然后根据BeanDefinition的信息进行创建Bean。
按道理我们应该按顺序分析源码时应该从读取配置文件开始，但是如果我们假定这个过程已经完成，就像是我们在配置文件中配置一个Bean，如下：
<bean id="test" class="com.spring.test" />并且这个bean标签中的id属性、class属性已经填充到BeanDefinition，实际上这是一个解析XML文件的过程，我们可以跳过，我们应该专注到点上--Spring是如何利用这些信息创建加载Bean。
如果现在Spring没有被设计出来或者不存在，单靠class的全限命名，通过反射就可以获取一个实例，假设这个bean有个属性，通过set的方式注入这个属性，这是我认为的最本质的东西，从这个角度上来讲，也就实现了解耦了，因为当class改变了之后，生成的实例也会跟着变，而java代码没有发生变动。但是Spring做的东西太多太多，例如配置文件以字符串的形式存着，而这个属性是整数型，在这个过程中也需要进行类型转换，当然还有其他功能像AOP。
虽然我们跳过了读取配置文件的过程中，但我先总结一下这个过程，把这个文件封装到ClassPathResource文件，然后将该文件转换成流，通过dom4j去解析这个流，从root节点往下解析，然后按照标签分别填充到BeanDefinition属性当中。来执行这个过程的类是XmlBeanDefinitionReader。
直接探索Bean加载过程:
bf.getBean("test");
getBean
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
doGetBean
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//假设a是b的别名，b是c的别名，这个函数是将a转换到c
final String beanName = transformedBeanName(name);
Object bean;
//尝试从缓存获取该bean(这里的缓存指的是三级缓存 分别是singletonObjects、earlySingletonObjects、singletonFactories)
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 + "'");
}
}
//返回对象的实例，有时候存在诸如BeanFactory的情况并不是直接返回实例本身而是返回指定方法返回的实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//如果该beanName处于创建当中或者完成但是从缓存中获取不到
//我们可以假定是在循环引用当中
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//如果该beanName在该beanFactory获取不到，我们可以尝试从parentBeanFactory中获取
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);
}
}
//如果不是仅仅做类型检查则创建bean，并且要进行记录
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//合并主要是和父类BeanDefinition合并
//首先获取父类的Beanfinition
//然后override父类的方法
//然而某些属性保留父类 像scope
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查mbd是否为abstract，因为抽象类不能实例化
checkMergedBeanDefinition(mbd, beanName, args);
// 保证初始化当前bean所依赖的bean.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
if (isDependent(beanName, dependsOnBean)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
}
registerDependentBean(dependsOnBean, beanName);
//这里getBean是将该Bean存在缓存当中，等到注入的时候从缓存中获取
getBean(dependsOnBean);
}
}
// 如果从缓存中获取不到而且不存在循环依赖则开始创建.
if (mbd.isSingleton()) {
//这里实现匿名内部类和匿名对象 实现ObjectFactory中的getObject方法
//并且将createBean作为回调函数
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 {
//原型模式下由于不需要缓存可以直接创建createBean
//这里需要记录下状态，因为原型状态下不能解决循环依赖
//若出现循环依赖并且检测到状态为原型则抛出异常
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
//其他scope的情况
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;
}
}从上面一段代码我们总结一下这个函数的流程，如果是单例，则访问单例缓存是否存在，如果存在则返回，如果不存在则从ParentBeanFactory获取，如果仍然不存在则根据Scope来创建实例。
上面代码中多次出现的代码
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);getObjectForBeanInstance
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
//如果指定的name是工厂相关的(以&为前缀)且beanInstance又不是Factory类型则抛出异常.
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// 现在我们已经有bean实例，这个实例有可能是正常的bean或者是FactoryBean.
// 如果是FactoryBean我们使用它创建实例，如果用户用户想要直接获取工厂实例而不是工厂的getObject方法对应的实例那么传入的name应该加入前缀&
//这个方法如果不是Factory 或者 要直接返回工厂实例 则return
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
//那么下面的情况是通过FactoryBean间接获取实例
Object object = null;
if (mbd == null) {
//尝试从缓存中获取
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
//将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition 如果指定BeanName是子bean的话则同时合并父类的属性.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
//是否是用户定义的而不是应用程序本身定义的
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}getObjectFromFactoryBean
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//这里两个条件分别判断factory生成的实例是否是单例的 以及 factory本身是否是单例
//因为如果factory生成的实例是单例而factory本身不是单例
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
//这里是最关键的地方 调用FactoryBean接口的getObject()方法
object = doGetObjectFromFactoryBean(factory, beanName);
//alreadyThere的出现有可能是doGetObjectFromFactoryBean
//调用了factoryBeanObjectCache的get方法
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (object != null && shouldPostProcess) {
try {
//BeanPostProcessor后置处理器postProcessAfterInitialization
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
//缓存单例实例
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
}
return (object != NULL_OBJECT ? object : null);
}
}
else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (object != null && shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}doGetObjectFromFactoryBean
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// Do not accept a null value for a FactoryBean that's not fully
// initialized yet: Many FactoryBeans just return null then.
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}接下来下面我们来重点关注一下单例模式下创建Bean的过程
当从三级缓存以及ParentBeanFactory找不到该实例时，则开始创建Bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
//将createBean作为回调函数return
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);
}getSingleton(String beanName, ObjectFactory<?> singletonFactory)
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
//第二次从一级缓存中获取
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while the singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//记录SingleCreation状态
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
//调用getObject方法,从而调用回调函数createBean
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}createBean
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
throws BeanCreationException;@Override
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
// 确保此时bean类已经被实际解析.
// 由于class在BeanDefinition以String的方式存储，而真正的Class<?>类型的beanClass属性需要用
// classLoader来loadClass来返回Class<?>对象
resolveBeanClass(mbd, beanName);
//准备MethodOverride.
try {
mbd.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//给后置处理器一个机会来返回一个代理对象并替换目标对象
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);
}
//开始真正创建bean
Object beanInstance = doCreateBean(beanName, mbd, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}resolveBeforeInstantiation
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// mbd是非合成的 并且有InstantiationAwareBeanPostProcessors的情况下
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//确定TargetType
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}determineTargetType
@Nullable
protected Class<?> determineTargetType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
//首先从targetType target为bean最终的目标class
Class<?> targetType = mbd.getTargetType();
if (targetType == null) {
//如果为targetType为空 可以从factorymethod中获取返回的type
//或者解析mbd获取BeanClass
targetType = (mbd.getFactoryMethodName() != null ?
getTypeForFactoryMethod(beanName, mbd, typesToMatch) :
resolveBeanClass(mbd, beanName, typesToMatch));
if (ObjectUtils.isEmpty(typesToMatch) || getTempClassLoader() == null) {
mbd.resolvedTargetType = targetType;
}
}
return targetType;
}resolveBeanClass
@Nullable
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
throws CannotLoadBeanClassException {
try {
//如果mbd已经解析了beanclass直接return
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
}
//如果没有解析 则开始解析
else {
return doResolveBeanClass(mbd, typesToMatch);
}
}
catch (PrivilegedActionException pae) {
ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}
catch (ClassNotFoundException ex) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}
catch (LinkageError err) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
}
}doResolveBeanClass
@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
throws ClassNotFoundException {
// 这里首先获取 对应的ClassLoader ，从 当前的Thread级别->class级别->system级别 获取
ClassLoader beanClassLoader = getBeanClassLoader();
ClassLoader dynamicLoader = beanClassLoader;
boolean freshResolve = false;
if (!ObjectUtils.isEmpty(typesToMatch)) {
// When just doing type checks (i.e. not creating an actual instance yet),
// use the specified temporary class loader (e.g. in a weaving scenario).
//如果仅仅做类型检查 则使用特定的临时的类加载器
ClassLoader tempClassLoader = getTempClassLoader();
if (tempClassLoader != null) {
dynamicLoader = tempClassLoader;
freshResolve = true;
if (tempClassLoader instanceof DecoratingClassLoader) {
DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
for (Class<?> typeToMatch : typesToMatch) {
//排除该class
//如果你不想你的类被自定义的类加载器管理，可以把它添加到集合当中
//这样就是使用jdk默认的类加载机制
dcl.excludeClass(typeToMatch.getName());
}
}
}
}
//获取mbd中String类型的beanclassname
String className = mbd.getBeanClassName();
if (className != null) {
//这里用到了SPEL表达式解析器 是因为这个String类型的beanClassName可能用到该表达式
Object evaluated = evaluateBeanDefinitionString(className, mbd);
if (!className.equals(evaluated)) {
// A dynamically resolved expression, supported as of 4.2...
//如果解析成功并且解析的值为Class类型直接返回
if (evaluated instanceof Class) {
return (Class<?>) evaluated;
}
else if (evaluated instanceof String) {
//如果仍为String类型 需要loadClass
className = (String) evaluated;
freshResolve = true;
}
else {
throw new IllegalStateException("Invalid class name expression result: " + evaluated);
}
}
//freshResolve为true的条件有两个
//第一个temporary class loader不为空
//第二个通过spel解析器解析的值仍为String类型时
if (freshResolve) {
// When resolving against a temporary class loader, exit early in order
// to avoid storing the resolved Class in the bean definition.
//符合第一个条件
if (dynamicLoader != null) {
try {
return dynamicLoader.loadClass(className);
}
catch (ClassNotFoundException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
}
}
}
//符合第二个条件(这时dynamicLoader虽然为空 但是进入函数后会获取默认的类加载器)
return ClassUtils.forName(className, dynamicLoader);
}
}
// 如果beanclassname为null 正常处理beanclass
return mbd.resolveBeanClass(beanClassLoader);
}
6831
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
