学步园

抽象工厂加反射详细运行流程：

代码实例：

建立一个配置文件beans-config.xml。注：分为两部分一部分是创建bll层标签和一个创建Dal层的标签，这样就可以分开创建Bll和Dal层，是Bll层和Dal层单独成为一个系列的产品，在编程过程中，Bll层和Dal层是必要的两个产品。其实我们也可以合到一块，根据id的不同来区别标签，但是在这我们不那样做。

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<dao-class>
		<service id="com.bjpowernode.drp.basedata.manager.ItemManager" class="com.bjpowernode.drp.basedata.manager.ItemManagerImpl"></service>
	</dao-class>
	<service-class>
		<dao  id="com.bjpowernode.drp.basedata.dao.ItemDao" class="com.bjpowernode.drp.basedata.dao.ItemDao4OracleImpl"></dao>
	</service-class>	
</beans>

创建一个BeanFactory。注：在这我就不用抽象，可以用抽象，其实工厂多的时候就可以用抽象工厂来创建公共的部分，因为我在这个工厂里直接就将创建两系列的产品写到一块了。

import java.util.HashMap;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import com.bjpowernode.drp.basedata.dao.ItemDao;
import com.bjpowernode.drp.basedata.manager.ItemManager;
/**
 * 抽象工厂主要创建两个主要系列的产品
 * 1.Manager系列
 * 2.Dao系列产品
 *功能：
 */
public class BeanFactory {
	//系统缺省配置文件名称
	private String beansConfigFile = "beans-config.xml";
	private Document doc;
	//保存Service相关对象
	private Map serviceMap = new HashMap();
	//保存dao相关对象
	private Map daoMap = new HashMap();
	private static  BeanFactory instance=new BeanFactory();
	private BeanFactory(){
		try {
			doc = new SAXReader().read(Thread.currentThread().getContextClassLoader().getResourceAsStream(beansConfigFile));
		} catch (DocumentException e) {
			e.printStackTrace();
			throw new RuntimeException();
		}
	}
	public static BeanFactory getInstance(){
		return instance;
	}
	
	/**
	 * 
	 *功能：根据产品编号取得Service系列产品
	 * @param beanId
	 * @return
	 */
	public  synchronized Object getServiceObject(Class c){
		//如果存在相关对象实例，返回
		if (serviceMap.containsKey(c.getName())) {
			return serviceMap.get(c.getName());
		}
		Element beanElt = (Element)doc.selectSingleNode("//service[@id=\"" + c.getName() + "\"]");
		//System.out.print(beanElt);
		String className = beanElt.attributeValue("class");
		Object service = null;
		try {
			service = Class.forName(className).newInstance();
			
			//将创建好多的对象放到Map中
			serviceMap.put(c.getName(), service);
		} catch (Exception e) {
			throw new RuntimeException();
		}
		return service;
	}
	/**
	 * 
	 *功能：根据产品编号取得Service系列产品
	 * @param beanId
	 * @return
	 */
	public synchronized Object getDaoObject(Class c){
		//如果存在相关对象实例，返回
		if (daoMap.containsKey(c.getName())) {
			return daoMap.get(c.getName());
		}
		Element beanElt = (Element)doc.selectSingleNode("//dao[@id=\"" + c.getName() + "\"]");
		String className = beanElt.attributeValue("class");
		Object dao = null;
		try {
			dao = Class.forName(className).newInstance();
			
			//将创建好多的对象放到Map中
			daoMap.put(c.getName(), dao);
		} catch (Exception e) {
			throw new RuntimeException();
		}
		return dao;
	}

创建一个InitServlet。注：这样就可以确保我的工厂在一开始的时候创建，并将工厂设置成一个全局容器参数；ItemItemManager.class就是

com.bjpowernode.drp.basedata.manager.ItemManager的路径，这是类的属性之一

/**
 *功能：初始化工厂
 */
public class InitServlet extends HttpServlet {
	@Override
	public void init() throws ServletException {
		BeanFactory beanFactory =BeanFactory.getInstance();
		this.getServletContext().setAttribute("beanFactory", beanFactory);		
	}
}

创建一个SearchItemServlet。注：用于创建Bll的产品，当你拿到工厂的时候你就可以根据ItemManager的路径，进行反射找到具体的实现哪个类，在直接调用方法就行了。

protected void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
          BeanFactory beanFactory=(BeanFactory)this.getServletContext().getAttribute("beanFactory");
	  itemManager=(ItemManager)beanFactory.getServiceObject(ItemManager.class);
}

在ItemManagerImpl中初始化的时候就创建出你要实现的Dao接口；ItemDao.class就是com.bjpowernode.drp.basedata.dao.ItemDao的路径通过配置文件致命要实现的类，这是类的属性之一；调用接口方法。

public class ItemManagerImpl implements ItemManager {

	ItemDao itemDao=null;	

	public ItemManagerImpl() {
		itemDao=(ItemDao)BeanFactory.getInstance().getDaoObject(ItemDao.class);
        }

}

具体的ItemManagerImpl和ItemDao4OracleImpl的方法实现在这不做详细的书写，写的就是抽象工厂加反射这个模式的框架原理。以上就是具体的实现过程，就是和我们写的方法调用就一样了，没什么区别。

通过这个模式促进我们们对抽象工厂的理解，模式的应用无处不在，用好设计模式是一个长期的过程，这都是模式中的经典范例，设计模式体现了面向对象的应用，反应了软件的扩展性和灵活性，虽然说应用设计模式也是有缺点的，但是面向对象的思想让我们更加亲睐于设计模式的使用，使我们的编程更加富有乐趣。