前言
上一节我们分析了Spring的实例化和IOC过程。在熟悉了Spring的处理流程后，我们自己能不能写一个IOC的容器和实现依赖注入呢？要注意哪些问题呢？本章节我们重点关注两个问题。
- 手写一个简单的IOC容器并实现依赖注入
- 分析Spring是怎样解决循环依赖的问题
1、加载配置文件
先来看配置文件，我们定义了两个Bean，User和Role。
<beans>
<bean id="user" class="ioc.entity.User">
<property name="id" value="u_1001"/>
<property name="name" value="吴蓓蓓"/>
<property name="age" value="15"/>
<property name="role" ref="role"></property>
</bean>
<bean id="role" class="ioc.entity.Role">
<property name="id" value="r_2001"/>
<property name="name" value="管理员"/>
</bean>
</beans>
扫描方式很简单，main方法指定了XML文件的路径。获取文件的输入流，转成Document对象解析即可，这点和Spring的做法是一致的。并把property属性简单化处理，放在一个List<Map<String，String>>中。
/***
* 遍历XML文件，解析bean标签
* @param location
* @throws Exception
*/
private void loadBeans(String location) throws Exception {
// 加载 xml 配置文件
InputStream inputStream = new FileInputStream(location);
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = factory.newDocumentBuilder();
Document doc = docBuilder.parse(inputStream);
Element root = doc.getDocumentElement();
NodeList nodes = root.getChildNodes();
for (int i = 0; i < nodes.getLength(); i++) {
BeanDefinition beanDefinition = new BeanDefinition();
Node node = nodes.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
String id = ele.getAttribute("id");
String beanName = ele.getAttribute("class");
beanDefinition.setId(id);
beanDefinition.setBeanName(beanName);
NodeList propertyNodes = ele.getElementsByTagName("property");
List<Map<String,String>> propertyList = new ArrayList<>();
Map<String,String> propertyMap;
for (int j = 0; j < propertyNodes.getLength(); j++) {
propertyMap = new HashMap<String, String>();
Node propertyNode = propertyNodes.item(j);
if (propertyNode instanceof Element) {
Element propertyElement = (Element) propertyNode;
String name = propertyElement.getAttribute("name");
String value = propertyElement.getAttribute("value");
propertyMap.put("propertyName", name);
if (value!=null && value.length()>0) {
propertyMap.put("propertyValue", value);
propertyMap.put("propertyType", "string");
}else{
String ref = propertyElement.getAttribute("ref");
propertyMap.put("propertyValue", ref);
propertyMap.put("propertyType", "ref");
}
}
propertyList.add(propertyMap);
}
beanDefinition.setPropertyList(propertyList);
beanNames.add(id);
beanClassMap.put(id, beanDefinition);
}
}
doLoadBeanDefinitions();
}
2、实例化
拿到beanName的集合，遍历进行实例化和依赖注入。
private void doLoadBeanDefinitions() throws Exception{
for(String beanName:beanNames){
BeanDefinition beanDefinition = beanClassMap.get(beanName);
DI(beanDefinition);
}
}
private void DI(BeanDefinition beanDefinition) throws Exception{
Class<?> beanClass = createBean(beanDefinition.getBeanName());
Object bean = beanClass.newInstance();
List<Map<String,String>> propertyList = beanDefinition.getPropertyList();
for (int i = 0; i < propertyList.size(); i++) {
Map<String,String> property = propertyList.get(i);
String propName = property.get("propertyName");
String propValue = property.get("propertyValue");
String propType = property.get("propertyType");
Field declaredField = bean.getClass().getDeclaredField(propName);
declaredField.setAccessible(true);
if ("string".equals(propType)) {
declaredField.set(bean, propValue);
}else{
Object beanInstance = beanMap.get(propValue);
if (beanInstance!=null) {
declaredField.set(bean, beanInstance);
}else{
BeanDefinition bd = beanClassMap.get(propValue);
DI(bd);
declaredField.set(bean,beanMap.get(propValue) );
}
}
}
beanMap.put(beanDefinition.getId(), bean);
}
private Class<?> createBean(String className){
Class<?> beanClass = null;
try {
beanClass = Class.forName(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return beanClass;
}
3、测试
进行main函数，看看测试结果。
public static void main(String[] args) throws Exception {
String path = "D:\\Workspaces\\Netty\\src\\ioc\\ioc_1.xml";
new IOC_1(path);
Iterator<Entry<String, Object>> item = beanMap.entrySet().iterator();
while(item.hasNext()){
Entry<String, Object> next = item.next();
if (next.getValue() instanceof User) {
User user = (User) next.getValue();
System.out.println("userId:"+user.getId());
System.out.println("userName:"+user.getName());
System.out.println("userRoleName:"+user.getRole().getName());
}else{
Role role = (Role) next.getValue();
System.out.println("roleId:"+role.getId());
System.out.println("roleName:"+role.getName());
}
System.out.println("-----------------");
}
}
输出结果如下
roleId:r_2001
roleName:管理员
-----------------
userId:u_1001
userName:吴蓓蓓
userRoleName:管理员
-----------------
从结果来看，这两个Bean的实例化和依赖注入是没问题的，完成了我们的本章节提出的第一个小目标。
4、循环依赖
如果我们把配置文件改一下，让User和Role形成循环依赖呢？我们的程序还能正常吗？
<beans>
<bean id="user" class="ioc.entity.User">
<property name="id" value="u_1001"/>
<property name="name" value="吴蓓蓓"/>
<property name="age" value="15"/>
<property name="role" ref="role"></property>
</bean>
<bean id="role" class="ioc.entity.Role">
<property name="id" value="r_2001"/>
<property name="name" value="管理员"/>
<property name="user" ref="user"></property>
</bean>
</beans>
哈哈，不敢运行。就上面的代码而言，它肯定会死循环。User依赖Role，注入的时候发现还没有Role的实例，就先去实例化Role；实例化Role的时候，又发现依赖了User，再去实例化User...好了，下面我们看下Spring是怎么解决这事的。
分析Spring之前，我们先来了解几个缓存的定义
| 名称 | 作用 |
|---|---|
| singletonObjects | 用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用 |
| earlySingletonObjects | 存放原始的 bean 对象（尚未填充属性），用于解决循环依赖 |
| singletonFactories | 存放 bean 工厂对象，用于解决循环依赖 |
| singletonsCurrentlyInCreation | 当前正在创建的bean的名称 |
看到这几个缓存，我们可以大概理出一个思路。
1、实例化Bean的时候，先从singletonObjects查找缓存，
如果命中就可以直接返回，未命中的话先把Bean放入singletonsCurrentlyInCreation，说明自己正在创建中。
2、具体开始实例化。完成后，把beanName和对应的bean工厂放入singletonFactories。
3、依赖注入，当有循环依赖的时候，重复第1个步骤。
还是从singletonObjects查找缓存，虽然还是未命中，但是发现bean正在创建中了。
然后从singletonFactories中获取bean的工厂对象，拿到该Bean的对象。然后把这个Bean提前曝光，放入earlySingletonObjects。
4、注入完成，循环依赖问题解决。
来看个流程图，再整理下思路。
Spring IOC循环依赖
基于上面的思路，把上面我们自己实现的代码重新改造一下。全部代码在GitHub:手写简单IOC容器，大家可以拿下来运行一下看看。
- 1、还是先遍历所有的beanName
/**
* 遍历XML中配置的bean，进行实例化和IOC
* @throws Exception
*/
private void doLoadBeanDefinitions() throws Exception{
for(String beanName:beanNames){
BeanDefinition beanDefinition = beanClassMap.get(beanName);
doGetBean(beanDefinition);
}
}
- 2、 获取Bean实例
private Object doGetBean(BeanDefinition beanDefinition) throws Exception{
Object bean = null;
String beanName = beanDefinition.getId();
Object sharedInstance = getSingleton(beanName,true);
if (sharedInstance !=null) {
bean = sharedInstance;
}else{
Object singletonObject = getSingleton(beanDefinition);
bean = singletonObject;
}
return bean;
}
- 3、下面来看两个getSingleton方法。第一个主要是为了判断是否正在创建中，如果是就从工厂里先拿到一个Bean返回；第二个是Bean实际创建过程。
/**
* 先从缓存中获取，如果未命中并且没有在创建中，返回NULL
* 如果Bean正在创建中，从工厂中先拿到Bean返回(还未填充属性)
* @param beanName
* @param allowEarlyReference
* @return
*/
private Object getSingleton(String beanName,boolean allowEarlyReference){
Object beanObject = singletonObjects.get(beanName);
if (beanObject == null && singletonsCurrentlyInCreation.contains(beanName)) {
beanObject = earlySingletonObjects.get(beanName);
if (beanObject ==null && allowEarlyReference) {
Object singletonFactory = singletonFactories.get(beanName);
if (singletonFactory != null) {
beanObject = singletonFactory;
earlySingletonObjects.put(beanName, beanObject);
singletonFactories.remove(beanName);
}
}
}
return beanObject;
}
/**
* 先从缓存获取Bean，如果未命中，直接创建，并把创建完且注入完成的Bean放入缓存
* @param beanDefinition
* @return
* @throws Exception
*/
private Object getSingleton(BeanDefinition beanDefinition) throws Exception{
String beanName = beanDefinition.getId();
Object singletonObject = singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = createBean(beanDefinition);
singletonObjects.put(beanName,singletonObject);
singletonFactories.remove(beanName);
earlySingletonObjects.remove(beanName);
}
return singletonObject;
}
- 4、Bean的实际创建，重点是创建之前把之前放入singletonsCurrentlyInCreation，创建之后把自己的实例放入bean工厂，singletonFactories。
/**
* 实际创建Bean的过程
* 先把自己放入singletonsCurrentlyInCreation，说明正在创建中
* 把创建好的实例放入工厂。singletonFactories
* @param beanDefinition
* @return
* @throws Exception
*/
private Object createBean(BeanDefinition beanDefinition) throws Exception{
String beanName = beanDefinition.getId();
singletonsCurrentlyInCreation.add(beanName);
Object bean = beanDefinition.getBeanClass().newInstance();
if (!singletonObjects.containsKey(beanName)) {
singletonFactories.put(beanName, bean);
earlySingletonObjects.remove(beanName);
}
populateBean(bean, beanDefinition.getPropertyList());
return bean;
}
- 5、注入属性，属性值的类型如果是ref引用类型，就再循环调用doGetBean。同一个Bean在第二次调用的时候，就会拿到工厂里的Bean对象并返回，完成注入。
public void populateBean(Object bean,List<Map<String,String>> pvs) throws Exception{
for (int i = 0; i < pvs.size(); i++) {
Map<String,String> property = pvs.get(i);
String propName = property.get("propertyName");
String propValue = property.get("propertyValue");
String propType = property.get("propertyType");
Field declaredField = bean.getClass().getDeclaredField(propName);
declaredField.setAccessible(true);
if ("string".equals(propType)) {
declaredField.set(bean, propValue);
}else{
String beanName = propValue;
Object beanObject = singletonObjects.get(beanName);
if (beanObject!=null) {
declaredField.set(bean,beanObject);
}else{
Object refBean = doGetBean(beanClassMap.get(beanName));
declaredField.set(bean, refBean);
}
}
}
}
5、总结
关于循环依赖，Spring源码里处理的时候非常的绕，还有很多内部类糅杂在一块，刚开始看的我简直怀疑人生。最好先弄明白那几个缓存的含义，再去理解这个流程。
关于Spring源码这一块就不贴了，太分散而且太多，有兴趣的小伙伴可以自行翻阅。
下面推荐一篇博客，也是写的是循坏依赖这一块内容。
田小波：循环依赖的解决办法
