Spring原始碼分析（三）手寫簡單的IOC容器和解決迴圈依賴問題

清幽之地發表於2019-02-26
Spring原始碼

前言

上一節我們分析了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、注入完成，迴圈依賴問題解決。
複製程式碼

來看個流程圖，再整理下思路。

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

下面來看兩個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原始碼這一塊就不貼了，太分散而且太多，有興趣的小夥伴可以自行翻閱。

相關文章