实现后期装配的通用框架

一、应用策略模式提升层的通用性
1、意图
将算法封装，使系统可以更换或扩展算法，策略模式的关键是所有子类的目标一致。
2、结构
策略模式的结构如下。
利用反射实现通用框架
目标：
构造一个 Bean 容器框架，可以动态装入和构造对象，装入类可以使用配置文件，这里
利用了反射技术。
问题：
如何动态构造对象，集中管理对象。
解决方案：
策略模式，XML 文档读入，反射的应用。
我们现在要处理的架构如下：
Bean.xml 文档的结构如下。
<beans>
<description>说明</description>
<bean id="标记" class="类名">
<property name="属性名">
<value>内容</value>
</property>
………..
</bean>
</beans>
应用程序上下文接口：ApplicationContext.java
只有一个方法，也就是由用户提供的 id 提供 Bean 的实例。
package springdemo;
public interface ApplicationContext{
public Object getBean(String id) throws Exception;
}
上下文实现类：FileSystemXmlApplicationContext.java
package springdemo;
import java.util.*;
import javax.xml.parsers.*;
import org.w3c.dom.*;
import java.io.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.*;
public class FileSystemXmlApplicationContext
implements ApplicationContext{
//用一个哈西表保留从 XML 读来的数据
private Hashtable hs=new Hashtable();
public FileSystemXmlApplicationContext(String fileName){
try{
readXml(fileName);
}
catch(Exception e){
e.printStackTrace();
}
}
//私有的读 XML 方法。
private void readXml(String fileName) throws Exception{
//读 XML 把数据放入哈西表
hs=Configuration.Attribute(fileName,"bean","property");
}
public Object getBean(String id) throws Exception{
//由 id 取出内部的哈西表对象
Hashtable hsb=(Hashtable)hs.get(id);
//利用反射动态构造对象
Object obj =Class.forName(hsb.get("class").toString()).newInstance();
java.util.Enumeration hsNames1 =hsb.keys();
//利用反射写入属性的值
while (hsNames1.hasMoreElements()) {
//写入利用 Set 方法
String ka=(String)hsNames1.nextElement();
if (! ka.equals("class")){
//写入属性值为字符串
String m1="String";
Class[] a1={m1.getClass()};
//拼接方法的名字
String sa1=ka.substring(0,1).toUpperCase();
sa1="set"+sa1+ka.substring(1);
//动态调用方法
java.lang.reflect.Method fm=obj.getClass().getMethod(sa1,a1);
Object[] a2={hsb.get(ka)};
//通过 set 方法写入属性
fm.invoke(obj,a2);
}
}
return obj;
}
}
//这是一个专门用于读配置文件的类
class Configuration{
public static Hashtable Attribute(String configname,
String mostlyelem,
String childmostlyelem) throws Exception{
Hashtable hs=new Hashtable();
//建立文档，需要一个工厂
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc=builder.parse(configname);
//建立所有元素的列表
Element root = doc.getDocumentElement();
//把所有的主要标记都找出来放到节点列表中
NodeList elemList = root.getElementsByTagName(mostlyelem);
for (int i=0; i < elemList.getLength(); i++){
//获取这个节点的属性集合
NamedNodeMap ac = elemList.item(i).getAttributes();
//构造一个表，记录属性和类的名字
Hashtable hs1=new Hashtable();
hs1.put("class",ac.getNamedItem("class").getNodeValue());
//获取二级标记子节点
Element node=(Element)elemList.item(i);
//获取第二级节点的集合
NodeList elemList1 =node.getElementsByTagName(childmostlyelem);
for (int j=0; j < elemList1.getLength(); j++){
//获取这个节点的属性集合
NamedNodeMap ac1 = elemList1.item(j).getAttributes();
String key=ac1.getNamedItem("name").getNodeValue();
NodeList
node1=((Element)elemList1.item(j)).getElementsByTagName("value");
String value=node1.item(0).getFirstChild().getNodeValue();
hs1.put(key,value);
}
hs.put(ac.getNamedItem("id").getNodeValue(),hs1);
}
return hs;
}
}
做一个程序实验一下。
首先做一个关于交通工具的接口：Vehicle.java
package springdemo;
public interface Vehicle {
public String execute(String str);
public String getMessage();
public void setMessage(String str);
}
做一个实现类：Car.java
package springdemo;
public class Car implements Vehicle {
private String message="";
private String x;
public String getMessage(){
return message;
}
public void setMessage(String str){
message = str;
}
public String execute(String str){
return getMessage() + str+"汽车在公路上开";
}
}
Bean.xml 文档。
<beans>
<description>Spring Quick Start</description>
<bean id="Car" class="springdemo.Car">
<property name="message">
<value>hello!</value>
</property>
</bean>
</beans>
测试：Test.java
public class Test{
public static void main (String[] args) throws Exception{
springdemo.ApplicationContext m=
new springdemo.FileSystemXmlApplicationContext("d://Bean.xml");
//实现类，使用标记 Car
springdemo.Vehicle s1=(springdemo.Vehicle)m.getBean("Car");
System.out.println(s1.execute("我的"));
}
}
基于接口编程将使系统具备很好的扩充性。
再做一个类：Train.java
package springdemo;
public class Train implements Vehicle {
private String message="";
public String getMessage(){
return message;
}
public void setMessage(String str){
message = str;
}
public String execute(String str) {
return getMessage() + str+"火车在铁路上走";
}
}
Bean.xml 改动如下。
<beans>
<description>Spring Quick Start</description>
<bean id="Car" class="springdemo.Car">
<property name="message">
<value>hello!</value>
</property>
</bean>
<bean id="Train" class="springdemo.Train">
<property name="message">
<value>haha!</value>
</property>
</bean>
</beans>
改动一下 Test.java
public class Test{
public static void main (String[] args) throws Exception{
springdemo.ApplicationContext m=
new springdemo.FileSystemXmlApplicationContext("d://Bean.xml");
//实现类，使用标记 Car
springdemo.Vehicle s1=(springdemo.Vehicle)m.getBean("Car");
System.out.println(s1.execute("我的"));
springdemo.Vehicle s2=(springdemo.Vehicle)m.getBean("Train");
System.out.println(s2.execute("你的"));
}
}
我们发现，在加入新的类的时候，使用方法几乎不变。通过上面的讨论，我们当对框架实现
技术有了一个基本的理解。