前言
上一節我們分析了Spring的例項化和IOC過程。在熟悉了Spring的處理流程後，我們自己能不能寫一個IOC的容器和實現依賴注入呢？要注意哪些問題呢？本章節我們重點關注兩個問題。
- 手寫一個簡單的IOC容器並實現依賴注入
- 分析Spring是怎樣解決迴圈依賴的問題
一、載入配置檔案
先來看配置檔案，我們定義了兩個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();
}
複製程式碼二、例項化
拿到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;
}
複製程式碼三、測試
進行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的例項化和依賴注入是沒問題的，完成了我們的本章節提出的第一個小目標。
四、迴圈依賴
如果我們把配置檔案改一下，讓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、注入完成，迴圈依賴問題解決。
複製程式碼來看個流程圖，再整理下思路。
基於上面的思路，把上面我們自己實現的程式碼重新改造一下。全部程式碼在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
下面來看兩個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);
}
}
}
}
複製程式碼五、總結
關於迴圈依賴，Spring原始碼裡處理的時候非常的繞，還有很多內部類糅雜在一塊，剛開始看的我簡直懷疑人生。最好先弄明白那幾個快取的含義，再去理解這個流程。 關於Spring原始碼這一塊就不貼了，太分散而且太多，有興趣的小夥伴可以自行翻閱。