• 依赖倒转原则


    1.定义

              依赖倒转原则(Dependence Inversion Principle ,DIP)定义为:高层模块不应该依赖低层模块,它们都应该依赖抽象。抽象不应该依赖细节,细节应该依赖于抽象。简单的就是说,要针对接口或者抽象类编程,而不是针对具体类编程,感觉和开闭原则等都极为相似。

    2.实例

              某系统提供一个数据转换模块,可以将来自不同数据源的数据转换成多种格式(为了简单实现效果,不做实际转换,只让结果简单打印,如可以转换来自数据库的数据(DatabaseSource),也可以转换来自文本文件的数据(TextSource),转换后的格式可以是XML文件(XMLTransformer),也可以是XLS文件(XLSTransformer)等。初始设计图如下:

              

    3.分析

              由于需求的变化,该系统可能需要增加新的数据源或者新的文件格式,每增加一个新的类型数据源或者新的文件格式,客户类MainClass就会修改源代码,违背了开闭原则。现在使用依赖倒转原则进行重构,结果如下图:

              

              本实例中,MainClass针对具体类编程,如果增加新类就必须修改MainClass中的源代码,因此可以对这些具体类进行抽象化,使得MainClass针对抽象类编程,而将具体的类放在配置文件中,重构后添加了AbstractSource和AbstractTransformer,在这个过程中使用了里氏代换原则,依赖倒转原则必须以里氏代换原则为基础,当需要增加新的转换源或者文件时就只需要添加新的类和修改xml配置文件即可。

    4.实现

              4.1XMLHelper,这个类在前面也出现过,主要作用就是读取xml文件中具体类名,这里不再过多叙述。    

    package DependenceInversion;
    import java.io.IOException;
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import org.w3c.dom.Document;
    import org.w3c.dom.NodeList;
    import org.xml.sax.SAXException;
    public class XMLHepler {
    
        /*
         * 从xml文件读取类名
         * 
         * */
        public XMLHepler() {
             
        }
        public String  getSourceTransferClassName()
        {
            
            DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
            DocumentBuilder builder=null;
            try {
                builder=factory.newDocumentBuilder();
            }catch(ParserConfigurationException e)
            {
                e.printStackTrace();
            }
            Document document=null;
            try {
                document=builder.parse("DIP.xml");//从xml文件读取类名
            }catch(SAXException e)
            {
                e.printStackTrace();
            }catch(IOException e)
            {
                e.printStackTrace();
            }
            NodeList nList1=document.getElementsByTagName("sourceName");
            NodeList nList2=document.getElementsByTagName("transformerName");
             
            String reString=  nList1.item(0).getFirstChild().getNodeValue()+" "+ nList2.item(0).getFirstChild().getNodeValue();
            return reString;
        }
    }

              4.2AbstractSource类     

    package DependenceInversion;
    public abstract class AbstractSource {
    
        public AbstractSource() { 
        } 
        public abstract String getData();//此处为了方便 并不去实现数据转换 只是为了体现效果
    
    }

              4.3AbstractTransformer类 

    package DependenceInversion;
    public abstract class AbstractTransformer {
    
        public AbstractTransformer() {
            // TODO Auto-generated constructor stub
        }
        public abstract void transformerData(AbstractSource source);
        
    }

              4.4DatabaseSource类     

    package DependenceInversion;
    public class DatabaseSource extends AbstractSource{
        public DatabaseSource() {         
        }
         @Override
        public  String getData()
        {
              return "DatabaseSource";
        }
    }

              4.5TextSource类   

    package DependenceInversion;
    public class TextSource extends AbstractSource{
        public TextSource() {
             
        }
        @Override
        public String getData()
        {
            return "TextSource";
        }
    }

              4.6XLSTransformer类   

    package DependenceInversion;
    public class XLSTransformer extends AbstractTransformer {
        public XLSTransformer() {         
        }
        @Override
            public   void transformerData(AbstractSource source) 
            {
                System.out.println("XLSTransformer转换了->"+source.getData());
            }
    }

              4.7XMLTransformer类   

    package DependenceInversion;
    public class XMLTransformer extends AbstractTransformer{
        public XMLTransformer() {     
        }
        @Override
        public   void transformerData(AbstractSource source)
        {
            System.out.println("XMLTransformer转换了->"+source.getData());
        }
    }

              4.8MainClass类      

    package DependenceInversion;
    public class MainClass {
        private AbstractSource source=null;
        private AbstractTransformer transformer=null;
        private XMLHepler hepler=null;
        public MainClass() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
             hepler=new XMLHepler();
             String classNames=hepler.getSourceTransferClassName();
             String[]res= classNames.split(" ");//从返回的类名中分别找到sourceName和transformerName
              source=(AbstractSource)Class.forName(res[0]).newInstance() ;
             transformer=(AbstractTransformer)Class.forName(res[1]).newInstance();
             transformer.transformerData(source);
        }
    
        public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
             
           new MainClass();
        }
    
    }

              4.9运行效果

               

                

          注:参考书籍是清华大学出版社《设计模式》,由刘伟主编,代码中存在的不足还请多多指教。
  • 相关阅读:
    第二个Sprint
    第一个Sprint
    “尸体解剖” 报告
    软工水平自我评价表
    小学四则运算APP 第一个冲刺阶段 第五天
    小学四则运算APP 第一个冲刺阶段 第四天
    小学四则运算APP 第一个冲刺阶段 第三天
    小学四则运算APP 第一阶段冲刺 第二天-补
    小学四则运算APP 第一个冲刺 第二天
    小学四则运算APP 第一个冲刺阶段 第一天
  • 原文地址:https://www.cnblogs.com/Juice-Dreamer/p/9866613.html
Copyright © 2020-2023  润新知