一、Spring容器
The org.springframework.context.ApplicationContext interface represents the Spring IoC container and is responsible for instantiating, configuring, and assembling the beans.
翻译下来大概就是：
- Spring IOC容器就是一个org.springframework.context.ApplicationContext的实例化对象
- 容器负责了实例化，配置以及装配一个bean
下图是 Spring 如何工作的高级视图：
Spring容器通过我们提交的pojo类以及配置元数据产生一个充分配置的可以使用的系统
这里说的配置元数据，实际上我们就是我们提供的XML配置文件，或者通过注解方式提供的一些配置信息
Spring 提供了以下两种不同类型的容器。
| 序号 | 容器 & 描述 |
|---|---|
| 1 | Spring BeanFactory 容器 它是最简单的容器，给 DI 提供了基本的支持，它用 org.springframework.beans.factory.BeanFactory 接口来定义。BeanFactory 或者相关的接口，如 BeanFactoryAware，InitializingBean，DisposableBean，在 Spring 中仍然存在具有大量的与 Spring 整合的第三方框架的反向兼容性的目的。 |
| 2 | Spring ApplicationContext 容器 该容器添加了更多的企业特定的功能，例如从一个属性文件中解析文本信息的能力，发布应用程序事件给感兴趣的事件监听器的能力。该容器是由 org.springframework.context.ApplicationContext 接口定义。 |
ApplicationContext 容器包括 BeanFactory 容器的所有功能，所以通常推进使用ApplicationContext 。BeanFactory 仍然可以用于轻量级的应用程序，如移动设备或基于 applet 的应用程序，其中它的数据量和速度具有优势。
二、BeanFactory 容器
2.1 接口体系
BeanFactory是一个顶级接口，它是访问Spring Bean容器的根接口，是Bean容器的基本视图。
接口体系：
BeanFactory 是Spring bean容器的根接口.提供获取bean,是否包含bean,是否单例与原型,获取bean类型,bean 别名的api.
-- AutowireCapableBeanFactory 添加集成其他框架功能.如果集成WebWork则可以使用Spring对Actions等进行管理.
-- HierarchicalBeanFactory 提供父容器的访问功能，
-- -- ConfigurableBeanFactory ,提供factory的配置功能,眼花缭乱好多api
-- -- -- ConfigurableListableBeanFactory 集大成者,提供解析,修改bean定义,并与初始化单例.
-- ListableBeanFactory 提供容器内bean实例的枚举功能.这边不会考虑父容器内的实例.
这边清晰地定义了如下的体系:
根接口BeanFactory(基础容器)
第二层: 第三方集成,继承体系,遍历bean
第三层: 配置功能
第四层: 配置+迭代
2.2 主要功能
接口里定义了一个变量String FACTORY_BEAN_PREFIX = "&";
这是用来区分是获取FactoryBean还是FactoryBean的createBean创建的实例.如果&开始则获取FactoryBean;否则获取createBean创建的实例.
我们来看下定义的方法:
- 获取bean,这边可以实现单例,原型
Object getBean(String name) throws BeansException; 可以用别名查找哦
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException; 这边的类型可以是接口或者子类,但不能是null
Object getBean(String name, Object... args) throws BeansException;
- 判断是否包含bean.陷阱出现:这边不管类是否抽象类,懒加载,是否在容器范围内,只要符合都返回true,所以这边true,不一定能从getBean获取实例
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;
String[] getAliases(String name);
2.3 实现原理
先来看看Java代码获取Spring中Bean的代码（一共有五种方式，这里只展示其中一种方法）：
Resource resource = new FileSystemResource("beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
factory.getBean("userService");pring中的BeanFactory用到的就是简单工厂模式。
现在的思路就更加清晰了，要想实现Spring中的BeanFactory，无非就用到了以下几个技术：
1.使用简单工厂模式来处理bean容器。
2.解析xml文件，获取配置中的元素信息。
3.利用反射获实例化配置信息中的对象。
4.如果有对象注入，使用invoke()方法。
5.实例化的对象放入bean容器中，并提供getBean方法。
通过以上步骤就实现了spring的BeanFactory功能，只要在配置文件中配置好，实例化对象的事情交给BeanFactory来实现，用户不需要通过new对象的方式实例化对象，直接调用getBean方法即获取对象实例。
具体实现代码：
新建一个xml文件，内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="courseDao" class="com.qcjy.learning.Dao.impl.CourseDaoImpl">
<bean id="courseService" class="com.qcjy.learning.service.impl.CourseServiceImpl">
<!-- 控制调用setCourseDao()方法，将容器中的courseDao bean作为传入参数 -->
<property name="courseDao" ref="courseDao"></property>
</bean>
</beans>接下来实现BeanFactory工厂，提供init方法，和getBean方法，在init方法中解析xml，利用反射实例话对象，存入bean容器中，代码如下：
import java.beans.BeanInfo;
import java.beans.PropertyDescriptor;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
public class BeanFactory {
//bean容器
private Map<String, Object> contianer = new HashMap<String, Object>();
/**
* <p>Discription:bean工厂的初始化</p>
* @param xml xml配置文件路径
* @author : lcma
* @update : 2016年9月20日上午9:04:41
*/
public void init(String xml) {
try {
// 读取指定的配置文件
SAXReader reader = new SAXReader();
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
// 从class目录下获取指定的xml文件
InputStream ins = classLoader.getResourceAsStream(xml);
Document doc = reader.read(ins);
Element root = doc.getRootElement();
Element foo;
// 遍历bean
for (Iterator i = root.elementIterator("bean"); i.hasNext();) {
foo = (Element) i.next();
// 获取bean的属性id和class
Attribute id = foo.attribute("id");
Attribute cls = foo.attribute("class");
// 利用Java反射机制，通过class的名称获取Class对象
Class<?> bean = Class.forName(cls.getText());
// 获取对应class的信息
java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
// 获取其属性描述
java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
// 设置值的方法
Method mSet = null;
// 创建一个对象
Object obj = bean.newInstance();
// 遍历该bean的property属性
for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {
Element foo2 = (Element) ite.next();
// 获取该property的name属性
Attribute name = foo2.attribute("name");
String value = null;
// 获取该property的子元素value的值
for (Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
Element node = (Element) ite1.next();
value = node.getText();
break;
}
for (int k = 0; k < pd.length; k++) {
if (pd[k].getName().equalsIgnoreCase(name.getText())) {
mSet = pd[k].getWriteMethod();
// 利用Java的反射机制调用对象的某个set方法，并将值设进去
mSet.invoke(obj, value);
}
}
}
// 将对象放入beanMap中，其中key为id值，value为对象
contianer.put(id.getText(), obj);
}
} catch (Exception e) {
System.out.println(e.toString());
}
}
/**
* <p>Discription:通过bean的id在容器中获取bean对象</p>
* @param beanName bean的唯一标识id
* @return
* @author : lcma
* @update : 2016年9月20日上午9:05:00
*/
public Object getBean(String beanName) {
Object obj = contianer.get(beanName);
return obj;
}
}测试方法：
/**
* <p>Discription:测试方法</p>
* @param args
* @author : lcma
* @update : 2016年9月20日上午9:06:06
*/
public static void main(String[] args) {
//实例化BeanFactory
BeanFactory factory = new BeanFactory();
//调用初始化方法，传入xml路径
factory.init("spring.xml");
//通过bean id 获取对象
CourseService courseService = (CourseService) factory.getBean("courseService");
//调用对象方法
courseService.findAll();
}还要提供CourseService和CourseDao两个接口及实现类，这里就不提供了。
上面的代码已经简单的模拟实现了BeanFactory的功能啦，Spring框架里面的代码要比我们这个复杂的多，因为要考虑到安全性、稳定性、异常等等因素，但是原理都一样。
三、ApplicationContext 容器
3.1 体系结构
ApplicationContext是spring继BeanFactory之外的另一个核心接口或容器，允许容器通过应用程序上下文环境创建、获取、管理bean。为应用程序提供配置的中央接口。在应用程序运行时这是只读的，但如果实现支持这一点，则可以重新加载。
一个ApplicationContext提供:
•访问应用程序组件的Bean工厂方法。从org.springframework.beans.factory.ListableBeanFactory继承。
•以通用方式加载文件资源的能力。继承自org.springframe .core.io。ResourceLoader接口。---beanXML
•向注册侦听器发布事件的能力。继承自ApplicationEventPublisher接口。
•解析消息的能力，支持国际化。继承自MessageSource接口。
•从父上下文继承。后代上下文中的定义总是优先级。例如，这意味着单个父上下文可以被整个web应用程序使用，而每个servlet都有自己独立于任何其他servlet的子上下文。
体系结构：
其接口主要子类(接口)包括：ConfigurableApplicationContext、WebApplicationContext
- ConfigurableApplicationContext：该接口提供了根据配置创建、获取bean的一些方法，其中主要常用的实现包括：ClassPathXmlApplicationContext、FileSystemXmlApplicationContext等。提供了通过各种途径去加载实例化bean的手段。
- AnnotationConfigWebApplicationContext：WebApplicationContext实现，它接受带注释的类作为输入—特别是@Configuration-annotated类，但也接受普通的@Component类和使用javax兼容JSR-330的类。注入注解。允许逐个注册类(指定类名作为配置位置)以及类路径扫描(指定基本包作为配置位置)。对于多个@Configuration类，后面的@Bean定义将覆盖前面加载的文件中定义的类。可以利用这一点，通过额外的配置类故意覆盖某些bean定义。提供了注册注解类和扫描注解类等操作
- XmlWebApplicationContext：WebApplicationContext实现，它从XML文档获取配置，默认情况下，配置将取自“/WEB-INF/applicationContext”。xml" for the root context, and "/WEB-INF/test-servlet。对于具有名称空间“test-servlet”的上下文(类似于对于具有servlet-name“test”的DispatcherServlet实例)。
3.2 refresh()
ClassPathXmlApplicationContext对象的创建过程可以分为三个步骤，依次向上调用父类构造器，设定配置文件位置，功能扩展。
其中refresh()方法是ApplicationContext最关键最核心的方法，就是用来刷新当前spring所处的上下文。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// 准备刷新上下文环境
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 读取xml并初始化BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 填充BeanFactory功能
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 子类覆盖方法额外处理(空方法)
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 调用各种BeanFactory处理器
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 注册拦截Bean创建的Bean处理器
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
// 初始化Message资源
initMessageSource();
// Initialize event multicaster for this context.
// 初始化应用消息广播器
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 留给子类初始化其他Bean
onRefresh();
// Check for listener beans and register them.
// 在所有注册Bean中查找Listener Bean,并注册到消息广播器中
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
// 初始化剩下的单例Bean(非延迟加载的)
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人
finishRefresh();
}
catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
// 销毁已经创建的Bean
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();
}
}
}
refresh()方法有几点是值得我们学习的：
- 方法是加锁的，这么做的原因是避免多线程同时刷新 Spring 上下文；
- 尽管加锁可以看到是针对整个方法体的，但是没有在方法前加 synchronized 关键字，而使用了对象锁 startUpShutdownMonitor，这样做有两个好处：
(1) refresh()方法和 close()方法都使用了 startUpShutdownMonitor 对象锁加锁，这就保证了在调用 refresh()方法的时候无法调用 close()方法，反之依然，这样就避免了冲突。
(2) 使用对象锁可以减小同步的范围，只对不能并发的代码块进行加锁，提高了整体代码运行的速率。 - 在 refresh()方法中整合了很多个子方法，使得整个方法流程清晰易懂，方便代码的可读性和可维护性。
- 运用了模板模式，抽象父类定义子类必须实现的模板方法，统一并规范代码。
1434
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
