共计 6700 个字符，预计需要花费 17 分钟才能阅读完成。
前言
spring 作为一个容器，能够治理对象的生命周期、对象与对象之间的依赖关系。能够通过配置文件，来定义对象，以及设置其与其余对象的依赖关系。
main 测试类
public static void main(String[] args) {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Bean bean = applicationContext.getBean(Bean.class);
System.out.println(bean);
}
ClassPathXmlApplicationContext 类
- application 建设当前，能够通过 refresh()进行重建，这样会将原来的 application 销毁，而后从新执行初始化
-
构造方法
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) throws BeansException {super(parent); // 设置配置文件 setConfigLocations(configLocations); if (refresh) { // 外围办法 refresh();} }
AbstractApplicationContext 类
refresh 办法
@Override
public void refresh() throws BeansException, IllegalStateException {
// 同步，避免你在初始化的过程中被打断
synchronized (this.startupShutdownMonitor) {
// 筹备工作
prepareRefresh();
// 配置文件被拆分成 Bean 定义，注册在 BeanFactory 中。// 也就是 Map<beanName, beanDefinition>
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// 到这一步，所有的 Bean 加载和注册都曾经实现，然而还没开始初始化
// 如果实现了 BeanFactoryPostProcessor 接口，能够在初始化的时候做点事件
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 办法
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 注册 BeanPostProcessor 的实现类，留神看和 BeanFactoryPostProcessor 的区别
// 此接口两个办法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 两个办法别离在 Bean 初始化之前和初始化之后失去执行。留神，到这里 Bean 还没初始化
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 初始化以后 ApplicationContext 的 MessageSource, 国际化等
initMessageSource();
// Initialize event multicaster for this context.
// 初始化以后 ApplicationContext 的事件播送器
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 从办法名就能够晓得，典型的模板办法(钩子办法)，// 具体的子类能够在这里初始化一些非凡的 Bean（在初始化 singleton beans 之前）onRefresh();
// Check for listener beans and register them.
// 注册监听，监听器须要实现 ApplicationListener 接口
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 初始化所有的 singletons，non-lazy 除外
// 次要办法
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 最初一步，公布事件播送
finishRefresh();}
catch (BeansException 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 {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();}
}
}
obtainFreshBeanFactory()办法
1、初始化 BeanFactory-》DefaultListableBeanFactory.class
DefaultListableBeanFactory beanFactory = createBeanFactory();
2、定义工厂的属性: 是否容许 Bean 笼罩、是否容许循环援用
3、加载 Bean 到 BeanFactory 中 -》loadBeanDefinitions()办法
3.1 读取 xml 配置文件，查看，解析
preProcessXml(root); // 钩子
parseBeanDefinitions(root, this.delegate); // 次要代码：将信息放在 Factory 的相干 map 中
postProcessXml(root); // 钩子
3.2 将 xml 配置文件的信息放到工厂的 map 里。
parseBeanDefinitions() => DefaultListableBeanFactory.class 的 registerBeanDefinition() 办法
this.beanDefinitionMap.put(beanName, beanDefinition);
// beanName 的汇合，和 Map 的 key（beanName）对应
this.beanDefinitionNames.add(beanName);
具体不细讲，简述一下过程，就是 factory 有几个 map，这里将 xml 里读出来的对象以 Map<beanName, beanDefinition> 的模式存储。
以及一个 list 保留了所有的 beanName。
beanDefinition 只是一个类的形容而已，和咱们须要的对象还差了一大截。
4、返回携带各种信息的 factory
finishBeanFactoryInitialization()办法
依据 factory 初始化所有的 singletons，non-lazy 除外
1、初始化非凡类，不开展啦。
2、缓存。还是 DefaultListableBeanFactory.class。把之前咱们下面讲到的带 beanName 的 List 转为数组保留到 frozenBeanDefinitionNames 里。
public void freezeConfiguration() {
this.configurationFrozen = true;
this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}
3、初始化。
3.1 拿到带 beanName 的 List，遍历循环
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
3.2 非凡类 FactoryBean 等非凡解决，不开展了。
3.3 进入对象实例化。
AbstractBeanFactory 类的 doGetBean()办法
AbstractAutowireCapableBeanFactory 类的 doCreateBean()
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
...
if (instanceWrapper == null) {
// 这里实例化 Bean，instanceWrapper = createBeanInstance(beanName, mbd, args);
}
...
}
AbstractAutowireCapableBeanFactory 类的 createBeanInstance()
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// Make sure bean class is actually resolved at this point.
// 确保曾经加载了此 class
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) {
// 采纳工厂办法实例化，留神，不是 FactoryBean
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 如果不是第一次创立，比方第二次创立 prototype 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);
}
}
// Candidate constructors for autowiring?
// 判断是否采纳有参构造函数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == 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);
}
AbstractAutowireCapableBeanFactory 类的 instantiateClass()
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);
}
}
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); // 构造函数初始化对象
}
...
} 最初
感激你看到这里，文章有什么有余还请斧正，感觉文章对你有帮忙的话记得给我点个赞，每天都会分享 java 相干技术文章或行业资讯，欢送大家关注和转发文章！
正文完