为什么使用抽象工厂+反射：

      抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂编程：是完全依靠接口编程，不需要具体的实现类。

      抽象工厂与OCP原则

     增加新的产品族时，需要增加具体工厂类,符合OCP原则。

     增加新产品时，需要修改具体工厂类和增加产品类，不符合OCP原则

     抽象工厂加反射：将抽象工厂提供的一系列接口，通过读取配置文件，进行实例反射，根据实例化要求去实例化类。

 配置文件XML文件：

     优点：解决了增加新产品不支持OCP的原则，直接在配置文件中指定实例化的类，也就是任意的产品。：

     当你改变底层配置时，不需要改变和重新编译代码，只需将xml中更改就可以了。以把经常变更的地反写入到xml中去，完全依靠配置文件

     缺点：

            1. 无法自动校验，需要人工查找

            2.  读取和解析xml配置要消耗一定时间，导致应用启动慢，不便于测试和维护

            3. 当系统很大时，大量的xml文件难以管理

            4. 运行中保存xml配置需要消耗额外的内存

实例应用：       

       下面我以用一个工厂创建，通过读取配置文件来生成B层和D层，这样界面就不用New（新建）BLL层的具体实现类而是直接调用B层的接口方法，B就不用New（新建）DAL层的实现类直接调用BLL的接口方法。这样摆脱了以前new的时候还得与实现类打交道。

        抽象工厂加反射示例图

       抽象工厂加反射（一） _反射

 

注：我们通过工厂加配置文件，创建了B接口和D接口

 

 

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

      抽象工厂加反射（一） _反射_02

代码实例：
 

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

 

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans>  
  3.     <dao-class>  
  4.         <service id="com.bjpowernode.drp.basedata.manager.ItemManager" class="com.bjpowernode.drp.basedata.manager.ItemManagerImpl"></service>  
  5.     </dao-class>  
  6.     <service-class>  
  7.         <dao  id="com.bjpowernode.drp.basedata.dao.ItemDao" class="com.bjpowernode.drp.basedata.dao.ItemDao4OracleImpl"></dao>  
  8.     </service-class>    
  9. </beans>  

 


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

 

 

[java] view plaincopyprint?
  1. import java.util.HashMap;  
  2. import java.util.Map;  
  3. import org.dom4j.Document;  
  4. import org.dom4j.DocumentException;  
  5. import org.dom4j.Element;  
  6. import org.dom4j.io.SAXReader;  
  7. import com.bjpowernode.drp.basedata.dao.ItemDao;  
  8. import com.bjpowernode.drp.basedata.manager.ItemManager;  
  9. /** 
  10.  * 抽象工厂主要创建两个主要系列的产品 
  11.  * 1.Manager系列 
  12.  * 2.Dao系列产品 
  13.  *功能： 
  14.  */  
  15. public class BeanFactory {  
  16.     //系统缺省配置文件名称   
  17.     private String beansConfigFile = "beans-config.xml";  
  18.     private Document doc;  
  19.     //保存Service相关对象   
  20.     private Map serviceMap = new HashMap();  
  21.     //保存dao相关对象   
  22.     private Map daoMap = new HashMap();  
  23.     private static  BeanFactory instance=new BeanFactory();  
  24.     private BeanFactory(){  
  25.         try {  
  26.             doc = new SAXReader().read(Thread.currentThread().getContextClassLoader().getResourceAsStream(beansConfigFile));  
  27.         } catch (DocumentException e) {  
  28.             e.printStackTrace();  
  29.             throw new RuntimeException();  
  30.         }  
  31.     }  
  32.     public static BeanFactory getInstance(){  
  33.         return instance;  
  34.     }  
  35.       
  36.     /** 
  37.      *  
  38.      *功能：根据产品编号取得Service系列产品 
  39.      * @param beanId 
  40.      * @return 
  41.      */  
  42.     public  synchronized Object getServiceObject(Class c){  
  43.         //如果存在相关对象实例，返回   
  44.         if (serviceMap.containsKey(c.getName())) {  
  45.             return serviceMap.get(c.getName());  
  46.         }  
  47.         Element beanElt = (Element)doc.selectSingleNode("//service[@id=\"" + c.getName() + "\"]");  
  48.         //System.out.print(beanElt);   
  49.         String className = beanElt.attributeValue("class");  
  50.         Object service = null;  
  51.         try {  
  52.             service = Class.forName(className).newInstance();  
  53.               
  54.             //将创建好多的对象放到Map中   
  55.             serviceMap.put(c.getName(), service);  
  56.         } catch (Exception e) {  
  57.             throw new RuntimeException();  
  58.         }  
  59.         return service;  
  60.     }  
  61.     /** 
  62.      *  
  63.      *功能：根据产品编号取得Service系列产品 
  64.      * @param beanId 
  65.      * @return 
  66.      */  
  67.     public synchronized Object getDaoObject(Class c){  
  68.         //如果存在相关对象实例，返回   
  69.         if (daoMap.containsKey(c.getName())) {  
  70.             return daoMap.get(c.getName());  
  71.         }  
  72.         Element beanElt = (Element)doc.selectSingleNode("//dao[@id=\"" + c.getName() + "\"]");  
  73.         String className = beanElt.attributeValue("class");  
  74.         Object dao = null;  
  75.         try {  
  76.             dao = Class.forName(className).newInstance();  
  77.               
  78.             //将创建好多的对象放到Map中   
  79.             daoMap.put(c.getName(), dao);  
  80.         } catch (Exception e) {  
  81.             throw new RuntimeException();  
  82.         }  
  83.         return dao;  
  84.     }  

 

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

[html] view plaincopyprint?
  1. com.bjpowernode.drp.basedata.manager.ItemManager的路径，这是类的属性之一  

 

 

 

[java] view plaincopyprint?
  1. /** 
  2.  *功能：初始化工厂 
  3.  */  
  4. public class InitServlet extends HttpServlet {  
  5.     @Override  
  6.     public void init() throws ServletException {  
  7.         BeanFactory beanFactory =BeanFactory.getInstance();  
  8.         this.getServletContext().setAttribute("beanFactory", beanFactory);        
  9.     }  
  10. }  

 


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

 

 

[java] view plaincopyprint?
  1. protected void doGet(HttpServletRequest request, HttpServletResponse response)  
  2.             throws ServletException, IOException {  
  3.           BeanFactory beanFactory=(BeanFactory)this.getServletContext().getAttribute("beanFactory");  
  4. <SPAN style="WHITE-SPACE: pre"> </SPAN>  itemManager=(ItemManager)beanFactory.getServiceObject(ItemManager.class);  
  5. }  

 

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

 

 

[java] view plaincopyprint?
  1. public class ItemManagerImpl implements ItemManager {  
  2.   
  3.     ItemDao itemDao=null;     
  4.   
  5.     public ItemManagerImpl() {  
  6.         itemDao=(ItemDao)BeanFactory.getInstance().getDaoObject(ItemDao.class);  
  7.         }  
  8.   
  9. }  

 

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

 

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