2. 程式人生 > >自己動手寫spring

自己動手寫spring

阿新 • • 發佈：2019-02-08
Java程式碼 複製程式碼
  1. publicstaticvoid main(String[] args) {   
  2.         ApplicationContext context = new FileSystemXmlApplicationContext(   
  3. "applicationContext.xml");   
  4.         Animal animal = (Animal) context.getBean("animal");   
  5.         animal.say();   
  6.     }  
public static void main(String[] args) {
		ApplicationContext context = new FileSystemXmlApplicationContext(
				"applicationContext.xml");
		Animal animal = (Animal) context.getBean("animal");
		animal.say();
	}


這段程式碼你一定很熟悉吧，不過還是讓我們分析一下它吧，首先是applicationContext.xml

Java程式碼 複製程式碼
  1. <bean id="animal"class="phz.springframework.test.Cat">   
  2.         <property name="name" value="kitty" />   
  3.     </bean>  
<bean id="animal" class="phz.springframework.test.Cat">
		<property name="name" value="kitty" />
	</bean>


他有一個類phz.springframework.test.Cat

Java程式碼 複製程式碼
  1. publicclass Cat implements Animal {   
  2. private String name;   
  3. publicvoid say() {   
  4.         System.out.println("I am " + name + "!");   
  5.     }   
  6. publicvoid setName(String name) {   
  7. this.name = name;   
  8.     }   
  9. }  
public class Cat implements Animal {
	private String name;
	public void say() {
		System.out.println("I am " + name + "!");
	}
	public void setName(String name) {
		this.name = name;
	}
}


實現了phz.springframework.test.Animal介面

Java程式碼 複製程式碼
  1. publicinterface Animal {   
  2. publicvoid say();   
  3. }  
public interface Animal {
	public void say();
}


很明顯上面的程式碼輸出I am kitty!

那麼到底Spring是如何做到的呢？
接下來就讓我們自己寫個Spring 來看看Spring 到底是怎麼執行的吧！

首先，我們定義一個Bean類，這個類用來存放一個Bean擁有的屬性

Java程式碼 複製程式碼
  1. /* Bean Id */
  2. private String id;   
  3. /* Bean Class */
  4. private String type;   
  5. /* Bean Property */
  6. private Map<String, Object> properties = new HashMap<String, Object>();  
/* Bean Id */
	private String id;
	/* Bean Class */
	private String type;
	/* Bean Property */
	private Map<String, Object> properties = new HashMap<String, Object>();


一個Bean包括id,type,和Properties。

接下來Spring 就開始載入我們的配置檔案了，將我們配置的資訊儲存在一個HashMap中，HashMap的key就是Bean 的 Id ，HasMap 的value是這個Bean，只有這樣我們才能通過context.getBean("animal")這個方法獲得Animal這個類。我們都知道Spirng可以注入基本型別，而且可以注入像List，Map這樣的型別，接下來就讓我們以Map為例看看Spring是怎麼儲存的吧

Map配置可以像下面的

Java程式碼 複製程式碼
  1. <bean id="test"class="Test">   
  2.         <property name="testMap">   
  3.             <map>   
  4.                 <entry key="a">   
  5.                     <value>1</value>   
  6.                 </entry>   
  7.                 <entry key="b">   
  8.                     <value>2</value>   
  9.                 </entry>   
  10.             </map>   
  11.         </property>   
  12.     </bean>  
<bean id="test" class="Test">
		<property name="testMap">
			<map>
				<entry key="a">
					<value>1</value>
				</entry>
				<entry key="b">
					<value>2</value>
				</entry>
			</map>
		</property>
	</bean>


Spring是怎樣儲存上面的配置呢？，程式碼如下：

Java程式碼 複製程式碼
  1. if (beanProperty.element("map") != null) {   
  2.                     Map<String, Object> propertiesMap = new HashMap<String, Object>();   
  3.                     Element propertiesListMap = (Element) beanProperty   
  4.                             .elements().get(0);   
  5.                     Iterator<?> propertiesIterator = propertiesListMap   
  6.                             .elements().iterator();   
  7. while (propertiesIterator.hasNext()) {   
  8.                         Element vet = (Element) propertiesIterator.next();   
  9. if (vet.getName().equals("entry")) {   
  10.                             String key = vet.attributeValue("key");   
  11.                             Iterator<?> valuesIterator = vet.elements()   
  12.                                     .iterator();   
  13. while (valuesIterator.hasNext()) {   
  14.                                 Element value = (Element) valuesIterator.next();   
  15. if (value.getName().equals("value")) {   
  16.                                     propertiesMap.put(key, value.getText());   
  17.                                 }   
  18. if (value.getName().equals("ref")) {   
  19.                                     propertiesMap.put(key, new String[] { value   
  20.                                             .attributeValue("bean") });   
  21.                                 }   
  22.                             }   
  23.                         }   
  24.                     }   
  25.                     bean.getProperties().put(name, propertiesMap);   
  26.                 }  
if (beanProperty.element("map") != null) {
					Map<String, Object> propertiesMap = new HashMap<String, Object>();
					Element propertiesListMap = (Element) beanProperty
							.elements().get(0);
					Iterator<?> propertiesIterator = propertiesListMap
							.elements().iterator();
					while (propertiesIterator.hasNext()) {
						Element vet = (Element) propertiesIterator.next();
						if (vet.getName().equals("entry")) {
							String key = vet.attributeValue("key");
							Iterator<?> valuesIterator = vet.elements()
									.iterator();
							while (valuesIterator.hasNext()) {
								Element value = (Element) valuesIterator.next();
								if (value.getName().equals("value")) {
									propertiesMap.put(key, value.getText());
								}
								if (value.getName().equals("ref")) {
									propertiesMap.put(key, new String[] { value
											.attributeValue("bean") });
								}
							}
						}
					}
					bean.getProperties().put(name, propertiesMap);
				}



接下來就進入最核心部分了，讓我們看看Spring 到底是怎麼依賴注入的吧，其實依賴注入的思想也很簡單，它是通過反射機制實現的，在例項化一個類時，它通過反射呼叫類中set方法將事先儲存在HashMap中的類屬性注入到類中。讓我們看看具體它是怎麼做的吧。
首先例項化一個類，像這樣

Java程式碼 複製程式碼
  1. publicstatic Object newInstance(String className) {   
  2.         Class<?> cls = null;   
  3.         Object obj = null;   
  4. try {   
  5.             cls = Class.forName(className);   
  6.             obj = cls.newInstance();   
  7.         } catch (ClassNotFoundException e) {   
  8. thrownew RuntimeException(e);   
  9.         } catch (InstantiationException e) {   
  10. thrownew RuntimeException(e);   
  11.         } catch (IllegalAccessException e) {   
  12. thrownew RuntimeException(e);   
  13.         }   
  14. return obj;   
  15.     }  
public static Object newInstance(String className) {
		Class<?> cls = null;
		Object obj = null;
		try {
			cls = Class.forName(className);
			obj = cls.newInstance();
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		} catch (InstantiationException e) {
			throw new RuntimeException(e);
		} catch (IllegalAccessException e) {
			throw new RuntimeException(e);
		}
		return obj;
	}


接著它將這個類的依賴注入進去，像這樣

Java程式碼 複製程式碼
  1. publicstaticvoid setProperty(Object obj, String name, String value) {   
  2.         Class<? extends Object> clazz = obj.getClass();   
  3. try {   
  4.             String methodName = returnSetMthodName(name);   
  5.             Method[] ms = clazz.getMethods();   
  6. for (Method m : ms) {   
  7. if (m.getName().equals(methodName)) {   
  8. if (m.getParameterTypes().length == 1) {   
  9.                         Class<?> clazzParameterType = m.getParameterTypes()[0];   
  10.                         setFieldValue(clazzParameterType.getName(), value, m,   
  11.                                 obj);   
  12. break;   
  13.                     }   
  14.                 }   
  15.             }   
  16.         } catch (SecurityException e) {   
  17. thrownew RuntimeException(e);   
  18.         } catch (IllegalArgumentException e) {   
  19. thrownew RuntimeException(e);   
  20.         } catch (IllegalAccessException e) {   
  21. thrownew RuntimeException(e);   
  22.         } catch (InvocationTargetException e) {   
  23. thrownew RuntimeException(e);   
  24.         }   
  25. }  
public static void setProperty(Object obj, String name, String value) {
		Class<? extends Object> clazz = obj.getClass();
		try {
			String methodName = returnSetMthodName(name);
			Method[] ms = clazz.getMethods();
			for (Method m : ms) {
				if (m.getName().equals(methodName)) {
					if (m.getParameterTypes().length == 1) {
						Class<?> clazzParameterType = m.getParameterTypes()[0];
						setFieldValue(clazzParameterType.getName(), value, m,
								obj);
						break;
					}
				}
			}
		} catch (SecurityException e) {
			throw new RuntimeException(e);
		} catch (IllegalArgumentException e) {
			throw new RuntimeException(e);
		} catch (IllegalAccessException e) {
			throw new RuntimeException(e);
		} catch (InvocationTargetException e) {
			throw new RuntimeException(e);
		}
}


最後它將這個類的例項返回給我們，我們就可以用了。我們還是以Map為例看看它是怎麼做的，我寫的程式碼裡面是建立一個HashMap並把該HashMap注入到需要注入的類中，像這樣，

Java程式碼 複製程式碼
  1. if (value instanceof Map) {   
  2.                 Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()   
  3.                         .iterator();   
  4.                 Map<String, Object> map = new HashMap<String, Object>();   
  5. while (entryIterator.hasNext()) {   
  6.                     Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();   
  7. if (entryMap.getValue() instanceof String[]) {   
  8.                         map.put((String) entryMap.getKey(),   
  9.                                 getBean(((String[]) entryMap.getValue())[0]));   
  10.                     }   
  11.                 }   
  12.                 BeanProcesser.setProperty(obj, property, map);   
  13.             }  
if (value instanceof Map) {
				Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()
						.iterator();
				Map<String, Object> map = new HashMap<String, Object>();
				while (entryIterator.hasNext()) {
					Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();
					if (entryMap.getValue() instanceof String[]) {
						map.put((String) entryMap.getKey(),
								getBean(((String[]) entryMap.getValue())[0]));
					}
				}
				BeanProcesser.setProperty(obj, property, map);
			}


好了，這樣我們就可以用Spring 給我們建立的類了，是不是也不是很難啊？當然Spring能做到的遠不止這些，這個示例程式僅僅提供了Spring最核心的依賴注入功能中的一部分。
本文參考了大量文章無法一一感謝，在這一起感謝，如果侵犯了你的版權深表歉意，很希望對大家有幫助！

附件中包含該山寨Spring的原始碼，核心只有五個類，還有一個測試程式，phz.springframework.test.AnimalSayApp，可以直接執行。

相關推薦

自己動手寫spring

Java程式碼 publicstaticvoid main(String[] args) {            ApplicationContext context = new FileSystemXmlApplicationContext(    "applic

自己動手寫Spring框架--IOC、MVC

　　對於一名Java開發人員，我相信沒有人不知道 Spring 框架，而且也能夠輕鬆就說出 Spring 的特性-- IOC、MVC、AOP、ORM（batis）。 　　看那麼多 Spring 原始碼分析，不如自己動手寫 個輕量的 Spring 框架。 　　下面我想簡單介紹一下我寫的輕

自己動手寫個spring IOC容器

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

自己動手寫一個自動登錄腳本gg

簡單 只需要 自己 不同 enum -s class rep 使用 1.下載一個sshpass工具 2.安裝sshpass，安裝到tools文件夾 3.把tools文件夾的路徑加入到/etc/bashrc vim /etc/bashrc

自己動手寫javaEE框架-為jqgrid換換皮膚然後加到我的框架裏

就會 cts 客戶 換膚 解析json 狀態 src demo 導航 軟件151 蘇垚 　今天讓我倒騰半天的居然不是寫我的javaEE框架，而是更換jqgrid的皮膚。我是相當的討厭jqgrid的默認皮膚，它總讓我想起一直想學而都沒學過的EXTJS，看多了那種淡藍色

自己動手寫CPU之第九階段（2）——載入存儲指令說明2（lwl、lwr）

上傳 open 送書 運算 ada 讀者 str ast base 將陸續上傳新書《自己動手寫CPU》。今天是第38篇，我盡量每周四篇，可是近期已經非常久沒有實現這個目標了。一直都有事，不好意思哈。 開展曬書評送書活動，在q=%E4%BA%9A%E9%A9%A

自己動手實踐 spring retry 重試框架

null for llb ati dba 行為 turn .com min 前序 馬上過年了，預祝大家，新年快樂，少寫bug 什麽是spring retry？ spring retry是從spring batch獨立出來的一個能功能，主要實現了重試和熔斷。 什麽時候用？ 遠

自己動手寫Java String類

實現string ins cas 沒有 min 操作方法 str2 override 英文 很早想造個輪子了，聽說不想造輪子的程序員不是好程序員，用慣了Apache的眾多開源項目，卻沒看過開源一句代碼。最近看了幾篇賣焦慮的文章之後，突然變得慌張起來，於是在百忙之中難得一點閑

自己動手寫一個單鏈表

兩個指針 isl linklist nextn mob 內部 數組 nds pty 文章有不當之處，歡迎指正，如果喜歡微信閱讀，你也可以關註我的微信公眾號：好好學java，獲取優質學習資源。 一、概述 單向鏈表（單鏈表）是鏈表的一種，其特點是鏈表的鏈接方向是單向的，對鏈表

【原創】自己動手寫一個服務網關

exception 負責 lis world 前置 create ble ddr load 引言 什麽是網關？為什麽需要使用網關？ 如圖所示，在不使用網關的情況下，我們的服務是直接暴露給服務調用方。當調用方增多，勢必需要添加定制化訪問權限、校驗等邏輯。當添加API網關後，

自己動手寫SSO（單點登錄）

getattr apach tpc style inter -m commons getwriter servle SSO在我們的應用中非常常見，例如我們在OA系統登錄了，我們就可以直接進入采購系統，不需要再登錄了，這樣使我們非常方便。

《自己動手寫爬蟲》筆記

《自己動手寫爬蟲》這本書總體介紹了整個網路爬蟲由淺入深的知識體系，將爬蟲中每個部分分割開來具體的細講，非常適合新手來入門，由於之前只知道使用爬蟲框架，所以一遇到一些錯誤或者想調整一些爬架內容就無從下手，所以還是將一些基礎知識弄明白之後再去使用框架就會得心應手了。書中關於當前的分散式爬蟲的

Java併發程式設計：自己動手寫一把可重入鎖

關於執行緒安全的例子，我前面的文章Java併發程式設計：執行緒安全和ThreadLocal裡面提到了,簡而言之就是多個執行緒在同時訪問和修改公共資源的時候，由於不同執行緒搶佔CPU問題而導致的結果不確定性，就是在併發程式設計中經常要考慮的執行緒安全問題。前面的做法是使用同步語句synch

自己動手寫StringBuilder類

繼上一篇自己動手寫Java String類之後，今晚10點鐘下班，感覺稍早，於是手癢癢就想自己動手來寫StringBulder，畢竟程式設計師啥都講究自己動手才能豐衣足食嘛！StringBuilder與String類的區別是String的變數內容是放在final char[]裡面的，而S

自己動手寫CPU Chapter3

3.1教學版OpenMIPS處理器藍圖 OpenMIPS設計目標    ​ 3.2三級流水線示意圖 ​     但是會有問題,假如的話時間不一致的時候如下，解決取值時間過長的措施是引入快取Cache，處理器從快取讀入資料只需要一個週

自己動手寫一個小型的TCP/IP協議

TCP/IP協議大家都知道，但真正理解的人不多，不如動手寫一個小型的看看。 我知道看書很枯燥，看不懂，還打擊大家的信心，不是我們的腦袋不如人，是我們的方法錯了。 一切的技術都從應用中發展而來，所以要從下往上走，先動手完成一個任務吧。 需要準備的前提知識 linux驅動程式知識

《自己動手寫java虛擬機器》學習筆記（六）-----解析class檔案（java）

專案地址：https://github.com/gongxianshengjiadexiaohuihui 註釋都寫的很清楚，有一些概念問題，請參考go版本的實現 目錄結構 首先是位元組轉換工具，因為java和go的類庫不同，另外需注意class檔案是大端儲存方式（高位元組放低地址，

《自己動手寫java虛擬機器》學習筆記（五）-----解析class檔案（go）

         專案地址：https://github.com/gongxianshengjiadexiaohuihui   上一節，我們已經通過路徑找到了指定的class檔案，這一節，我們開始解析class檔案，我們知道class檔

《自己動手寫java虛擬機器》學習筆記（四）-----搜尋class檔案（java）

  專案地址：https://github.com/gongxianshengjiadexiaohuihui 首先是定義一個抽象類，把四種路徑的格式抽象出來 Entry.java package classpath; import java.io.IOException;

《自己動手寫java虛擬機器》學習筆記（三）-----搜尋class檔案（go）

    專案地址：https://github.com/gongxianshengjiadexiaohuihui 我們都知道，.java檔案編譯後會形成.class檔案，然後class檔案會被載入到虛擬機器中，被我們使用，那麼虛擬機器如何從那裡尋找這些class檔案呢，jav