這篇文章用一台「ATM 取款機」的情境,手刻出一段類似 Spring IoC(控制反轉)的容器程式。用 Spring 來做當然輕而易舉,但把這段程式吃透,能為日後學習 Spring 的 IoC 起到拋磚引玉的效果。
先寫一個最樸素的 applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="us" class="com.youngmaster.atm.UsRate">
<property name="rate">
<value>0.8</value>
</property>
</bean>
<bean id="js" class="com.youngmaster.atm.JSRate">
<property name="rate">
<value>60</value>
</property>
</bean>
<bean id="transfer" class="com.youngmaster.atm.TransferImp">
<property name="rate">
<ref bean="js"></ref>
</property>
</bean>
</beans>
先定義一個匯率介面 Rate.java:
package com.youngmaster.atm;
/**
* @author youngmaster
* @version myEclipse 6.6
*/
public interface Rate {
public double getRate();
}
UsRate.java:
package com.youngmaster.atm;
/**
* @author youngmaster
* @version myEclipse 6.6
*/
public class UsRate implements Rate {
private double rate;
public double getRate() {
return rate;
}
public void setRate(double rate) {
this.rate = rate;
}
}
JSRate.java:
package com.youngmaster.atm;
/**
* @author youngmaster
* @version myEclipse 6.6
*/
public class JSRate implements Rate {
private double rate;
public double getRate() {
return rate;
}
public void setRate(double rate) {
this.rate = rate;
}
}
Transfer.java:
package com.youngmaster.atm;
/**
* @author youngmaster
* @version myEclipse 6.6
*/
public interface Transfer {
public double getAcount(double amount);
}
TransferImp.java:
package com.youngmaster.atm;
/**
* @author youngmaster
* @version myEclipse 6.6
*/
public class TransferImp implements Transfer{
private Rate rate;
public double getAcount(double amount) {
return amount*rate.getRate();
}
public Rate getRate() {
return rate;
}
public void setRate(Rate rate) {
this.rate = rate;
}
}
真正的重點在 XMLBeanFactory.java——它讀取設定檔,透過反射與 JavaBean 內省(Introspection)建立物件並注入屬性:
package com.youngmaster.atm;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
/**
* @author youngmaster
* @version myEclipse 6.6
*/
public class XMLBeanFactory {
private String file;
public XMLBeanFactory(String file) {
this.file = file;
}
public Object getBean(String id) {
Object result = null;
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory
.newInstance();
try {
DocumentBuilder documentBuilder = documentBuilderFactory
.newDocumentBuilder();
Document document = documentBuilder.parse(file);
NodeList nodeList = document.getElementsByTagName("bean");
/** 遍歷 XML 中的 bean */
for (int i = 0; i < nodeList.getLength(); i++) {
Element beanElement = (Element) nodeList.item(i);
String beanid = beanElement.getAttribute("id");
/** 透過參數中的 id 取得相應的 bean */
if (id.equals(beanid)) {
/** 取得相應的類 */
String clazz = beanElement.getAttribute("class");
Class beanclazz = Class.forName(clazz);
result = beanclazz.newInstance();
/** 取得 bean 中的屬性 */
NodeList propertyList = beanElement
.getElementsByTagName("property");
/** 遍歷屬性 */
for (int j = 0; j < propertyList.getLength(); j++) {
Element propertyElement = (Element) propertyList
.item(j);
/** 取得屬性中的 name */
String propertyname = propertyElement
.getAttribute("name");
/** 內省——非常關鍵 */
PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
propertyname, beanclazz);
NodeList valuelist = propertyElement
.getElementsByTagName("value");
/** 取得 id 為 us 或 js 的 bean */
if (valuelist != null && valuelist.getLength() > 0) {
Element valueelement = (Element) valuelist.item(0);
String nodvalue = valueelement.getFirstChild()
.getNodeValue();
Method writemethod = propertyDescriptor
.getWriteMethod();
writemethod.invoke(result, Double
.parseDouble(nodvalue));
}
else {
/** 取得 id 為 transfer 的 bean */
NodeList reflist = propertyElement
.getElementsByTagName("ref");
Element refelement = (Element) reflist.item(0);
String beanid1 = refelement.getAttribute("bean");
/** 遞迴呼叫 */
Object tempobject = this.getBean(beanid1);
Method method1 = propertyDescriptor
.getWriteMethod();
method1.invoke(result, tempobject);
}
}
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IntrospectionException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return result;
}
}
AtmTest.java:
package com.youngmaster.atm;
/**
* @author youngmaster
* @version myEclipse 6.6
*/
public class AtmTest {
/**
* @param args
*/
public static void main(String[] args) {
XMLBeanFactory beanfactory = new XMLBeanFactory(
"applicationContext.xml");
Transfer transfer = (Transfer) beanfactory.getBean("transfer");
System.out.println("========================\n"+transfer.getAcount(100));
}
}
這是一段淺顯易懂的程式:容器讀進設定檔,依 id 找出對應的類別並建立實例,再透過內省把屬性值(無論是 <value> 或指向另一個 bean 的 <ref>)注入進去;遇到 <ref> 時更以遞迴方式解析被引用的 bean。換成 Spring 來做當然輕而易舉,但把這段程式吃透,正好能為理解 Spring 的 IoC 打下基礎。