Java中dom4j读取配置文件实现抽象工厂+反射

开发 后端
在Donet中实现反射的主要原理是:将差异配置在config配置文件里面,并利用接口,通过在U的bin路径下面找到具体实现的名字来使程序运行。

在Java中也可以同Donet一样,将差异配置在配置文件里面。另外,我们采用下面的方式实现,将会更加便捷。

逻辑描述:

现在我们想在B层和D层加上接口层,并使用工厂。而我们可以将创建B和创建D看作是两个系列,然后就可以使用抽象工厂进行创建了。

配置文件:beans-config.xml。service-class与dao-class分别对应两个系列的产品。子菜单中id对应接口的命名空间,class对应实现类的命名空间。

  1. [html] view plaincopyprint? 
  2.  
  3.     <?xml version="1.0" encoding="UTF-8"?>   
  4.     <beans>   
  5.          <service-class>   
  6.             <service id="com.xxjstgb.drp.basedata.manager.ItemManager" class="com.xxjstgb.drp.basedata.manager.ItemManagerImpl" />   
  7.             <service id="com.xxjstgb.drp.flowcard.manager.FlowCardManager" class="com.xxjstgb.drp.flowcard.manager.impl.FlowCardManagerImpl" />   
  8.          </service-class>   
  9.          <dao-class>   
  10.             <dao id="com.xxjstgb.drp.basedata.dao.ItemDao" class="com.xxjstgb.drp.basedata.dao.ItemDao4OracleImpl" />   
  11.             <dao id="com.xxjstgb.drp.flowcard.dao.FlowCardDao" class="com.xxjstgb.drp.flowcard.dao.impl.FlowCardDaoImpl" />   
  12.          </dao-class>   
  13.     </beans>   

抽象工厂:BeanFactory。通过读取配置文件,取得相关对象,并将相关创建好的对象保存在Map中。

  1. [java] view plaincopyprint? 
  2.  
  3.     package com.xxjstgb.drp.util;   
  4.        
  5.     import java.util.HashMap;   
  6.     import java.util.Map;   
  7.        
  8.     //dom4j   
  9.     import org.dom4j.Document;   
  10.     import org.dom4j.DocumentException;   
  11.     import org.dom4j.Element;   
  12.     import org.dom4j.io.SAXReader;   
  13.        
  14.     import com.xxjstgb.drp.basedata.dao.ItemDao;   
  15.     import com.xxjstgb.drp.basedata.manager.ItemManager;   
  16.     import com.xxjstgb.drp.flowcard.dao.FlowCardDao;   
  17.     import com.xxjstgb.drp.flowcard.manager.FlowCardManager;   
  18.        
  19.     /**  
  20.      * 抽象工厂,主要创建两个系列的产品  
  21.      * 1、Manager系列  
  22.      * 2、Dao系列产品  
  23.      * @author liuzhengquan  
  24.      *  
  25.      */   
  26.     public class BeanFactory {   
  27.            
  28.         private static BeanFactory instance=new BeanFactory();   
  29.            
  30.         //系统缺省配置文件名称   
  31.         private final String beansConfigFile="beans-config.xml";   
  32.            
  33.         //保存Dao相关对象   
  34.         private Document doc;   
  35.            
  36.         /*  
  37.          * key=配置文件中的id值  
  38.          * value=对应了该Id的对象  
  39.          */   
  40.         private Map serviceMap = new HashMap();//保存Service相关对象   
  41.         private Map daoMap = new HashMap();//保存Dao相关对象   
  42.            
  43.            
  44.         private BeanFactory(){   
  45.             try {   
  46.                 doc=new SAXReader().read(Thread.currentThread().getContextClassLoader().getResourceAsStream(beansConfigFile));   
  47.             } catch (DocumentException e) {   
  48.                 e.printStackTrace();   
  49.                 throw new RuntimeException();   
  50.             }   
  51.         }   
  52.            
  53.         public static BeanFactory getInstance(){   
  54.             return instance;   
  55.         }   
  56.            
  57.         /**  
  58.          * 根据产品编号取得Service系列产品  
  59.          * @param serviceId  
  60.          * @return  
  61.          */   
  62.         public synchronized Object getServiceObject(Class c){   
  63.             //如果存在相关对象实例,返回   
  64.             if(serviceMap.containsKey(c.getName())){   
  65.                 return serviceMap.get(c.getName());   
  66.             }   
  67.             Element beanElt=(Element)doc.selectSingleNode("//service[@id=\""+ c.getName() + "\"]");   
  68.             String className=beanElt.attributeValue("class");   
  69.             Object service=null;   
  70.                
  71.             try {   
  72.                 service=Class.forName(className).newInstance();   
  73.                    
  74.                 //将创建好的对象放到Map中   
  75.                 serviceMap.put(c.getName(), service);   
  76.             } catch (Exception e) {   
  77.                 throw new RuntimeException();   
  78.             }   
  79.             return service;   
  80.         }   
  81.            
  82.         /**  
  83.          * 根据产品编号取得Dao系列产品  
  84.          * @param daoId  
  85.          * @return  
  86.          */   
  87.         public synchronized Object getDaoObject(Class c){   
  88.             //如果存在相关对象实例,返回   
  89.             if(daoMap.containsKey(c.getName())){   
  90.                 return daoMap.get(c.getName());   
  91.             }   
  92.             Element beanElt=(Element)doc.selectSingleNode("//dao[@id=\""+c.getName()+"\"]");   
  93.             String className=beanElt.attributeValue("class");   
  94.             Object dao=null;   
  95.                
  96.             try {   
  97.                 dao=Class.forName(className).newInstance();   
  98.                    
  99.                 //将创建好的对象放到Map中   
  100.                 daoMap.put(c.getName(), dao);   
  101.             } catch (Exception e) {   
  102.                 throw new RuntimeException();   
  103.             }   
  104.             return dao;   
  105.         }   
  106.            
  107.            
  108.         /**  
  109.          * 测试  
  110.          * @param args  
  111.          */   
  112.         public static void main(String[] args){   
  113.             ItemManager itemManager=(ItemManager)BeanFactory.getInstance().getServiceObject(ItemManager.class);   
  114.             System.out.println("itemManager"+itemManager);   
  115.                
  116.             ItemDao itemDao=(ItemDao)BeanFactory.getInstance().getDaoObject(ItemDao.class);   
  117.             System.out.println("itemDao:"+itemDao);   
  118.                
  119.             FlowCardManager flowCardManager=(FlowCardManager)BeanFactory.getInstance().getServiceObject(FlowCardManager.class);   
  120.             //FlowCardManager flowCardManager=new FlowCardManagerImpl();   
  121.             System.out.println(flowCardManager);   
  122.                
  123.             FlowCardDao flowCardDao=(FlowCardDao)BeanFactory.getInstance().getDaoObject(FlowCardDao.class);   
  124.             //FlowCardDao flowCardDao=new FlowCardDaoImpl();   
  125.             System.out.println("flowCardDao:"+flowCardDao);   
  126.         }   
  127.            
  128.     }   

运行结果:

总结:

通过抽象工厂+反射的实现,调用层就可以只认识接口,而无须与具体实现打交道,实现了解耦合。同时,由于配置文件里面是接口和实现的命名空间,我们就可以用相应接口的.class属性,点出命名空间,将配置文件的id和class都以键值对的形式配置在Map中,实现反射。

原文链接:http://blog.csdn.net/liu765023051/article/details/8986629

责任编辑:陈四芳 来源: csdn博客
相关推荐

2011-04-13 09:30:28

dom4j

2013-03-04 10:40:34

三层架构架构设计

2009-06-23 14:17:00

Dom4j

2009-04-02 17:37:38

dom4jXMLJava

2009-02-01 14:07:01

J2EEXMLXML配置文件

2012-05-30 10:03:57

dom4jXML乱码

2011-08-29 16:48:50

Lua配置文件C++

2023-08-07 16:14:32

propertiesSpring框架

2009-08-13 09:16:57

C#读取配置文件

2009-08-13 09:58:55

C#读取配置文件

2010-08-03 09:20:33

Flex读取XML配置

2024-03-06 13:19:19

工厂模式Python函数

2011-06-14 16:07:13

Qt QSettings类

2013-07-30 11:30:42

Windows PhoWindows Pho

2013-06-08 13:29:27

Android开发DOM读取XMLXML解析

2019-11-22 10:00:53

ICC配置文件Windows 10

2014-12-31 14:09:23

xml解析

2022-11-21 10:49:29

Nacos配置加密

2011-08-09 15:44:11

XCode 4Plist文件

2009-07-10 10:37:11

WINAPI
点赞
收藏

51CTO技术栈公众号