依赖倒置、控制反转和依赖注入(一)

前端之家收集整理的这篇文章主要介绍了依赖倒置、控制反转和依赖注入(一)前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

概述

在进行WPF开发时,我遇到了Unity Container、IoC、Dependency Injection等。当时我陷入到困惑的思考总,为什么要使用这些。当后来我逐渐的了解这些技术的优点后,我开始意识到了我们实际上是需要他们的。

本文,我来解释DI和IoC的需求和使用情况,本文分为5个部分。

1. 依赖倒置原则

2. 控制反转和控制反转容器(IoC Container)

3. 自定义控制反转容器(IoC Container)

4. 自定义支持生命周期的控制反转容器(IoC Container)

5. 利用Microsoft Unity的依赖注入(Dependency Injection)

前提条件

最好是最如下内容有所了解

开闭原则(Open/closed principle)

接口分离原则

依赖倒置原则(DIP)

DIP是SOLID原则中的一个,他们由Robert Martin于1992年提出。

S – Single responsibility principle(单一职责原则)

O – Open/closed principle(开闭原则)

L – Liskov substitution principle(里氏代换原则)

I – Interface segregation principle(接口分离原则)

D – Dependency inversion principle(依赖倒置原则)

C. Robert Matrin的依赖倒置原则内容如下:

a). 高层次的模块不应该依赖低层次的模块,他们都应该依赖于抽象。

b). 抽象不应该依赖于具体,具体应该依赖于抽象。

DIP指的就是要依赖于抽象,不要依赖于具体。简单的说就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现模块间的耦合。


图 1

如图1所示,“Copy”程序(高层次的模块)会调用“Read Keyboard”和“Write Printer”。因此“Copy”依赖“Read Keyboard”和“Write Printer”,并且存在紧耦合。

    public class Copy
    {
        publicvoidDoWork()
        {
            ReadKeyboardreader =new ReadKeyboard();
            WritePrinterwriter =new WritePrinter();
 
            string data= reader.ReadFromKeyboard();
            writer.WriteToPrinter(data);
        }
    }

上述代码看起来还不错,但是当我们需要追加更多的Reader或者Writer对象时,在上述代码结构下,我们需要修改“copy”程序,增加创建新Reader或Writer对象,并且要追加条件判断语句,来选择用哪个Reader或Writer来执行操作。但是这么做的话,违背了面向对象的开闭原则。

例如,我们扩展“Copy”程序,如图2,此时我们的“copy”程序可以从扫描器读数据并能够将数据写入到磁盘。


图 2

在这种情况下,我们需要调整我们的“copy”程序

    public class Copy
    {
        publicvoidDoWork()
        {
            string data=string.Empty;
            switch(readerType)
            {
                case"keyboard":
                    ReadKeyboardreader = newReadKeyboard();
                    data =reader.ReadFromKeyboard();
                    break;
                case"scanner":
                    ReadScannerreader2 = newReadScanner();
                    data =reader2.ReadFromScanner();
                    break;
            }
            switch(writerType)
            {
                case"printer":
                    WritePrinterwriter = newWritePrinter();
                   writer.WriteToPrinter(data);
                    break;
                case"flashdisk":
                    WriteFlashDiskwriter2 = newWriteFlashDisk();
                    writer2.WriteToFlashDisk(data);
                    break;
            }
        }
 
        privatestringreaderType;
        privatestringwriterType;
    }
根据上面的场景,如果需要继续追加新的Reader和Writer,我们就需要修正copy程序,因此copy严重的依赖具体的Reader和Writer对象。

为了解决上述问题,我们可以调整我们的“copy”程序,使其依赖抽象的接口而不是具体的实现。下图解释了依赖倒置。


图 3


图 4

在图3、4中,“Copy”程序依赖两个抽象的接口IReader和IWriter,这样低级别的组件就被抽象成了接口。

如下例子,在上述的图中,可以看出,类“ReadKeyboard”派生自接口IReader,类“WritePrinter”派生自接口IWriter,因此“Copy”程序调用IReader和IWriter就执行具体的操作了。因此如果我们想要追加更多的底层组件,例如“Scanner”和“FlashDisk”,我们可以创建派生自“IReader”和“IWriter”的新类即可。

    public interface IReader
    {
        stringRead();
    }
 
    public interface IWriter
    {
        voidWrite(string data);
    }
 
    public class ReadKeyboard :IReader
    {
        publicstringRead()
        {
            // code to read from keyboardand return as string
            returnstring.Empty;
        }
    }
 
    public class ReadScanner :IReader
    {
        publicstringRead()
        {
            // code to read from scannerand return as string
            returnstring.Empty;
        }
    }
 
    public class WritePrinter :IWriter
    {
        publicvoidWrite(string data)
        {
            // code to write to theprinter
        }
    }
 
    public class WriteFlashDisk :IWriter
    {
        publicvoidWrite(string data)
        {
            // code to write to the flashdisk
        }
    }
 
    public class Copy
    {
        privatestring_readerType;
        privatestring_writerType;
 
        public Copy(stringreaderType,string writerType)
        {
            _readerType = readerType;
            _writerType = writerType;
        }
 
        publicvoidDoWork()
        {
            IReaderreader =null;
            IWriterwriter =null;
            string data;
            switch(readerType)
            {
                case"keyboard":
                    reader = new ReadKeyboard();
                    break;
                case"scanner":
                    reader = new ReadScanner();
                    break;
            }
 
            switch(writerType)
            {
                case"printer":
                    writer = new WritePrinter();
                    break;
                case"flashdisk":
                    writer = new WriteFlashDisk();
                    break;
            }
 
            data = reader.Read();
            writer.Write(data);
        }
    }

在这种情况下,虽然具体的读写操作已经被抽象出来的,但是仍然存在高层模块依赖底层模块的现象,因为我们在高层模块中明确的实例化了具体的底层类对象。因此这种情况下,当追加新的类时,代码中的swith、case处仍然需要不断的维护。因此上述的修改方案并未完全的满足DIP原则。

为了彻底的移除依赖,我们需要在高层组件外面来创建依赖对象,并且依赖对象中存在某种机制能够传递到依赖模块中。

现在新的问题来了,如何实现依赖反转(Dependency Inversion)

其中一个方法是控制反转(Inversion ofControl, IoC),相当于如下代码

    public class Copy
    {       
        publicvoidDoWork()
        {
            IReaderreader = serviceLocator.GetReader();
            IWriterwriter = serviceLocator.GetWriter();
            string data= reader.Read();
            writer.Write(data);
        }
    }
上述代码替代了实例化Reader和Writer对象的代码,上述代码已经将创建Reader和Writer对象的处理转移到servicelocator中。从而使得“copy”程序不必因为底层组件的增减而修改了。

依赖注入(DependencyInjection)是实现控制反转的一种机制,在下一部分我会介绍什么是控制反转(Inversionof Control, IoC)及利用不同的机制实现依赖倒置原则(其中依赖注入是其中的一种办法)。

小结

本文介绍了依赖倒置原则,及其在真实的使用场景。在后面的文章中我会介绍控制反转(Inversionof Control,IoC)和依赖注入(DependencyInjection,DI)。

原文地址

http://www.codeproject.com/Articles/465173/Dependency-Inversion-Principle-IoC-Container-Depen

原文链接:https://www.f2er.com/javaschema/285519.html

猜你在找的设计模式相关文章