Spring技术内幕：深入解析Spring架构与设计原理（第2版）【阅读笔记】
用着spring当然得懂核心技术以及原理啦~~~
话不多说，开干！不定期增加内容。
本文源码来自于spring4.1.3
spring 核心实现
什么是IoC
一个引用自https://www.zhihu.com/question/23277575的故事
我开了一家薯条店，底下有一百家分店
一开始我懒，让分店自己去炸薯条，反正只要他们按照统一的配方来就好，比如油温170度，炸两分钟
有一天我突然发现油温169度炸出来的薯条更好次，kao！我得打100个电话，告诉分店经理改配方！（就是你要改很多处代码）
有了这次教训，我觉得让总店（就是Spring容器）来统一炸好薯条，然后送到各个分店去，要吃的时候再拿出来炸热一下就ok了
本来是分店自己决定怎么炸薯条的，虽然我给了他们配方，但是最终决定权在他们手上，他们偷偷少炸几秒钟、少放点油，我都管不着，现在我霸道了，把炸薯条权收归中央，这不就是控制反转（IOC）了吗？
换个角度讲，现在分店的薯条，都是我总店炸好送过去的，分店依赖总店的薯条，这不就是依赖注入了吗？
IoC 容器系列的设计与实现
BeanFactory
BeanFactory是容器的最基本接口定义。
public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";
// 获取指定名字的bean
Object getBean(String name) throws BeansException;
// 获取指定名字与类型的bean
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
// 获取指定类型的bean
<T> T getBean(Class<T> requiredType) throws BeansException;
// 获取指定名字的bean并覆盖bean的默认参数
Object getBean(String name, Object... args) throws BeansException;
// 获取指定类型的bean并覆盖bean的默认参数
<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
// 判断IOC容器中是否有指定名字的bean
boolean containsBean(String name);
// 判断指定名字的bean是否为单例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;
// 获取指定名字的bean的类型
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
// 获取指定名字的bean的别名
String[] getAliases(String name);
}IOC容器的初始化过程
BeanDefinition的Resource定位
首先定义一个Resource来定位容器使用BeanDefinition。
常见几种读取方式
FileSystemXmlApplicationContext(从文件系统载入Resource)
- ClassPathXmlApplicationContext(从classpath载入Resource)
XmlWebApplicationContext(从web容器中载入Resource)
BeanDefinition的载入和解析
BeanDefinition在IoC容器中的注册
ApplicationContext
AbstractApplicationContext
refresh()
refresh方法的作用是加载spring容器
首先看一下refresh内部的执行过程
public void refresh() throws BeansException, IllegalStateException {
// 加上synchronized，防止出现竞态条件（初始化的过程中被销毁）
synchronized (this.startupShutdownMonitor) {
//
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
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;
}
}
}第一步：刷新beanFactory之前的初始化(prepareRefresh)：
protected void prepareRefresh() {
// 获取启动容器时系统时间
this.startupDate = System.currentTimeMillis();
// 确定启动的标识，this.active是AtomicBoolean类型
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// 初始化上下文环境，在AbstractApplicationContext中没有具体实现
initPropertySources();
// 验证必要的参数(initPropertySources方法初始化后的参数)是否完整
getEnvironment().validateRequiredProperties();
}第二步：获取刷新后的beanFactory(obtainFreshBeanFactory)
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 刷新beanFactory，在AbstractApplicationContext中没有具体实现，具体实现在AbstractRefreshableApplicationContext与GenericApplicationContext中实现
refreshBeanFactory();
// 获取刷新后的beanFactory，在AbstractApplicationContext中没有具体实现，具体实现在AbstractRefreshableApplicationContext与GenericApplicationContext中实现
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}bean的载入过程(refreshBeanFactory)
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
// 载入
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}第三步：初始化刷新后的beanFactory(prepareBeanFactory)
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置表达式解析器，比如解析SpEL表达式
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 添加属性编辑器，比如某些特定格式的转换
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// [详见BeanPostProcessor](#BeanPostProcessor)，主要作用：修改bean对象(初始化之前和初始化之后)
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 在AbstractAutowireCapableBeanFactory类中有具体实现，作用：忽略自动装配的接口（因为在bean初始化之前会调用ApplicationContextAwareProcessor.postProcessBeforeInitialization方法，就已经做了依赖处理）
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
// 注册依赖
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 对Aspect的支持
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 对系统变量进行注入
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}DefaultListableBeanFactory
BeanPostProcessor
AbstractAutowireCapableBeanFactory
PostProcessor 后置处理器
第四步：允许在bean加载完后，初始化前对beanFactory进行修改(postProcessBeanFactory)，在其子类中实现自定义的需求
以AbstractRefreshableWebApplicationContext类为例
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
// 注册request/session作用域
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}
第五步：调用beanFactory的后置处理器(invokeBeanFactoryPostProcessors)
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}详见PostProcessorRegistrationDelegate类中的部分方法
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
Set<String> processedBeans = new HashSet<String>();
// 首先处理BeanDefinitionRegistryPostProcessor
// BeanDefinitionRegistryPostProcessor的作用是注册bean
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 普通的后置处理器
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
// 需要自定义注册bean的后置处理器(下文有解释)
List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
new LinkedList<BeanDefinitionRegistryPostProcessor>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// 判断是哪种后置处理器
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryPostProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 调用自定义注册的方法
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
registryPostProcessors.add(registryPostProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// 获取所有BeanDefinitionRegistryPostProcessor类型的后置处理器的名字
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 1.选出实现了PriorityOrdered接口的bean(优先排序、调用)
List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
// 如果实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
OrderComparator.sort(priorityOrderedPostProcessors);
registryPostProcessors.addAll(priorityOrderedPostProcessors);
invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
OrderComparator.sort(orderedPostProcessors);
registryPostProcessors.addAll(orderedPostProcessors);
invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
registryPostProcessors.add(pp);
processedBeans.add(ppName);
pp.postProcessBeanDefinitionRegistry(registry);
reiterate = true;
}
}
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
OrderComparator.sort(priorityOrderedPostProcessors);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
OrderComparator.sort(orderedPostProcessors);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}
BeanFactoryPostProcessor 与 BeanDefinitionRegistryPostProcessor的区别
首先看一下BeanFactoryPostProcessor的源码
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}postProcessBeanFactory方法的作用在上文（第四步）也提到过，可以对beanFactory进行修改。
以下是BeanDefinitionRegistryPostProcessor的源码
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor，提供了postProcessBeanDefinitionRegistry方法，作用是可以根据自己的需求注册bean。
等待后文
...
...
...
...
...
...
...
...
...
...
...
...
...
等待后文...
扫一扫
1267
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
