讲解依赖注入的好文-目前唯一

Posted 2020-08-30

以前对于依赖注入概念很模糊，甚至已经用到了但是我却不知道它就是依赖注入。直到看到这篇文章。

如果看了之后还是很模糊，可以进入页终链接，找到博主上一篇文章的有趣小例子。

2.2 正式定义依赖注入

下面，用稍微正式一点的语言，定义依赖注入产生的背景缘由和依赖注入的含义。在读的过程中，读者可以结合上面的例子进行理解。

依赖注入产生的背景：

随着面向对象分析与设计的发展，一个良好的设计，核心原则之一就是将变化隔离，使得变化部分发生变化时，不变部分不受影响（这也是OCP的目的）。为了做到这一点，要利用面向对象中的多态性，使用多态性后，客户类不再直接依赖服务类，而是依赖于一个抽象的接口，这样，客户类就不能在内部直接实例化具体的服务类。但是，客户类在运作中又客观需要具体的服务类提供服务，因为接口是不能实例化去提供服务的。就产生了“客户类不准实例化具体服务类”和“客户类需要具体服务类”这样一对矛盾。为了解决这个矛盾，开发人员提出了一种模式：客户类（如上例中的Role）定义一个注入点（Public成员Weapon），用于服务类（实现IAttackStrategy的具体类，如WoodSword、IronSword和MagicSword，也包括以后加进来的所有实现IAttackStrategy的新类）的注入，而客户类的客户类（Program，即测试代码）负责根据情况，实例化服务类，注入到客户类中，从而解决了这个矛盾。

依赖注入的正式定义：

依赖注入（Dependency Injection），是这样一个过程：由于某客户类只依赖于服务类的一个接口，而不依赖于具体服务类，所以客户类只定义一个注入点。在程序运行过程中，客户类不直接实例化具体服务类实例，而是客户类的运行上下文环境或专门组件负责实例化服务类，然后将其注入到客户类中，保证客户类的正常运行。

3 依赖注入那些事儿

上面我们从需求背景的角度，讲述了依赖注入的来源和定义。但是，如果依赖注入仅仅就只有这么点东西，那也没有什么值得讨论的了。但是，上面讨论的仅仅是依赖注入的内涵，其外延还是非常广泛的，从依赖注入衍生出了很多相关的概念与技术，下面我们讨论一下依赖注入的“那些事儿”。

3.1 依赖注入的类别

依赖注入有很多种方法，上面看到的例子中，只是其中的一种，下面分别讨论不同的依赖注入类型。

3.1.1 Setter注入

第一种依赖注入的方式，就是Setter注入，上面的例子中，将武器注入Role就是Setter注入。正式点说：

Setter注入（Setter Injection）是指在客户类中，设置一个服务类接口类型的数据成员，并设置一个Set方法作为注入点，这个Set方法接受一个具体的服务类实例为参数，并将它赋给服务类接口类型的数据成员。

图3.1 Setter注入示意

上图展示了Setter注入的结构示意图，客户类ClientClass设置IServiceClass类型成员_serviceImpl，并设置Set_ServiceImpl方法作为注入点。Context会负责实例化一个具体的ServiceClass，然后注入到ClientClass里。

下面给出Setter注入的示例代码。

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace SetterInjection  
7. {  
8.     internal interface IServiceClass  
9.     {  
10.         String ServiceInfo();  
11.     }  
12. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace SetterInjection  
7. {  
8.     internal class ServiceClassA : IServiceClass  
9.     {  
10.         public String ServiceInfo()  
11.         {  
12.             return "我是ServceClassA";  
13.         }  
14.     }  
15. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace SetterInjection  
7. {  
8.     internal class ServiceClassB : IServiceClass  
9.     {  
10.         public String ServiceInfo()  
11.         {  
12.             return "我是ServceClassB";  
13.         }  
14.     }  
15. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace SetterInjection  
7. {  
8.     internal class ClientClass  
9.     {  
10.         private IServiceClass _serviceImpl;  
11.    
12.         public void Set_ServiceImpl(IServiceClass serviceImpl)  
13.         {  
14.             this._serviceImpl = serviceImpl;  
15.         }  
16.    
17.         public void ShowInfo()  
18.         {  
19.             Console.WriteLine(_serviceImpl.ServiceInfo());  
20.         }  
21.     }  
22. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace SetterInjection  
7. {  
8.     class Program  
9.     {  
10.         static void Main(string[] args)  
11.         {  
12.             IServiceClass serviceA = new ServiceClassA();  
13.             IServiceClass serviceB = new ServiceClassB();  
14.             ClientClass client = new ClientClass();  
15.    
16.             client.Set_ServiceImpl(serviceA);  
17.             client.ShowInfo();  
18.             client.Set_ServiceImpl(serviceB);  
19.             client.ShowInfo();  
20.         }  
21.     }  
22. }  

运行结果如下：

图3.2 Setter注入运行结果

3.1.2 构造注入

另外一种依赖注入方式，是通过客户类的构造函数，向客户类注入服务类实例。

构造注入（Constructor Injection）是指在客户类中，设置一个服务类接口类型的数据成员，并以构造函数为注入点，这个构造函数接受一个具体的服务类实例为参数，并将它赋给服务类接口类型的数据成员。

图3.3 构造注入示意

图3.3是构造注入的示意图，可以看出，与Setter注入很类似，只是注入点由Setter方法变成了构造方法。这里要注意，由于构造注入只能在实例化客户类时注入一次，所以一点注入，程序运行期间是没法改变一个客户类对象内的服务类实例的。

由于构造注入和Setter注入的IServiceClass，ServiceClassA和ServiceClassB是一样的，所以这里给出另外ClientClass类的示例代码。

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace ConstructorInjection  
7. {  
8.     internal class ClientClass  
9.     {  
10.         private IServiceClass _serviceImpl;  
11.    
12.         public ClientClass(IServiceClass serviceImpl)  
13.         {  
14.             this._serviceImpl = serviceImpl;  
15.         }  
16.    
17.         public void ShowInfo()  
18.         {  
19.             Console.WriteLine(_serviceImpl.ServiceInfo());  
20.         }  
21.     }  
22. }  

可以看到，唯一的变化就是构造函数取代了Set_ServiceImpl方法，成为了注入点。

3.1.3 依赖获取

上面提到的注入方式，都是客户类被动接受所依赖的服务类，这也符合“注入”这个词。不过还有一种方法，可以和依赖注入达到相同的目的，就是依赖获取。

依赖获取（Dependency Locate）是指在系统中提供一个获取点，客户类仍然依赖服务类的接口。当客户类需要服务类时，从获取点主动取得指定的服务类，具体的服务类类型由获取点的配置决定。

可以看到，这种方法变被动为主动，使得客户类在需要时主动获取服务类，而将多态性的实现封装到获取点里面。获取点可以有很多种实现，也许最容易想到的就是建立一个Simple Factory作为获取点，客户类传入一个指定字符串，以获取相应服务类实例。如果所依赖的服务类是一系列类，那么依赖获取一般利用Abstract Factory模式构建获取点，然后，将服务类多态性转移到工厂的多态性上，而工厂的类型依赖一个外部配置，如XML文件。

不过，不论使用Simple Factory还是Abstract Factory，都避免不了判断服务类类型或工厂类型，这样系统中总要有一个地方存在不符合OCP的if…else或switch…case结构，这种缺陷是Simple Factory和Abstract Factory以及依赖获取本身无法消除的，而在某些支持反射的语言中（如C#），通过将反射机制的引入彻底解决了这个问题（后面讨论）。

下面给一个具体的例子，现在我们假设有个程序，既可以使用Windows风格外观，又可以使用Mac风格外观，而内部业务是一样的。

图3.4 依赖获取示意

上图乍看有点复杂，不过如果读者熟悉Abstract Factory模式，应该能很容易看懂，这就是Abstract Factory在实际中的一个应用。这里的Factory Container作为获取点，是一个静态类，它的“Type构造函数”依据外部的XML配置文件，决定实例化哪个工厂。下面还是来看示例代码。由于不同组件的代码是相似的，这里只给出Button组件的示例代码，完整代码请参考文末附上的完整源程序。

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace DependencyLocate  
7. {  
8.     internal interface IButton  
9.     {  
10.         String ShowInfo();  
11.     }  
12. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace DependencyLocate  
7. {  
8.     internal sealed class WindowsButton : IButton  
9.     {  
10.         public String Description { get; private set; }  
11.    
12.         public WindowsButton()  
13.         {  
14.             this.Description = "Windows风格按钮";  
15.         }  
16.    
17.         public String ShowInfo()  
18.         {  
19.             return this.Description;  
20.         }  
21.     }  
22. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace DependencyLocate  
7. {  
8.     internal sealed class MacButton : IButton  
9.     {  
10.         public String Description { get; private set; }  
11.    
12.         public MacButton()  
13.         {  
14.             this.Description = " Mac风格按钮";  
15.         }  
16.    
17.         public String ShowInfo()  
18.         {  
19.             return this.Description;  
20.         }  
21.     }  
22. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace DependencyLocate  
7. {  
8.     internal interface IFactory  
9.     {  
10.         IWindow MakeWindow();  
11.    
12.         IButton MakeButton();  
13.    
14.         ITextBox MakeTextBox();  
15.     }  
16. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace DependencyLocate  
7. {  
8.     internal sealed class WindowsFactory : IFactory  
9.     {  
10.         public IWindow MakeWindow()  
11.         {  
12.             return new WindowsWindow();  
13.         }  
14.    
15.         public IButton MakeButton()  
16.         {  
17.             return new WindowsButton();  
18.         }  
19.    
20.         public ITextBox MakeTextBox()  
21.         {  
22.             return new WindowsTextBox();  
23.         }  
24.     }  
25. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace DependencyLocate  
7. {  
8.     internal sealed class MacFactory : IFactory  
9.     {  
10.         public IWindow MakeWindow()  
11.         {  
12.             return new MacWindow();  
13.         }  
14.    
15.         public IButton MakeButton()  
16.         {  
17.             return new MacButton();  
18.         }  
19.    
20.         public ITextBox MakeTextBox()  
21.         {  
22.             return new MacTextBox();  
23.         }  
24.     }  
25. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Xml;  
6.    
7. namespace DependencyLocate  
8. {  
9.     internal static class FactoryContainer  
10.     {  
11.         public static IFactory factory { get; private set; }  
12.    
13.         static FactoryContainer()  
14.         {  
15.             XmlDocument xmlDoc = new XmlDocument();  
16.             xmlDoc.Load("http://www.cnblogs.com/Config.xml");  
17.             XmlNode xmlNode = xmlDoc.ChildNodes[1].ChildNodes[0].ChildNodes[0];  
18.    
19.             if ("Windows" == xmlNode.Value)  
20.             {  
21.                 factory = new WindowsFactory();  
22.             }  
23.             else if ("Mac" == xmlNode.Value)  
24.             {  
25.                 factory = new MacFactory();  
26.             }  
27.             else  
28.             {  
29.                 throw new Exception("Factory Init Error");  
30.             }  
31.         }  
32.     }  
33. }  

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.    
6. namespace DependencyLocate  
7. {  
8.     class Program  
9.     {  
10.         static void Main(string[] args)  
11.         {  
12.             IFactory factory = FactoryContainer.factory;  
13.             IWindow window = factory.MakeWindow();  
14.             Console.WriteLine("创建 " + window.ShowInfo());  
15.             IButton button = factory.MakeButton();  
16.             Console.WriteLine("创建 " + button.ShowInfo());  
17.             ITextBox textBox = factory.MakeTextBox();  
18.             Console.WriteLine("创建 " + textBox.ShowInfo());  
19.    
20.             Console.ReadLine();  
21.         }  
22.     }  
23. }  

这里我们用XML作为配置文件。配置文件Config.xml如下：

[html] view plain copy

 

1. <?xml version="1.0" encoding="utf-8" ?>  
2. <config>  
3.     <factory>Mac</factory>  
4. </config>  

可以看到，这里我们将配置设置为Mac风格，编译运行上述代码，运行结果如下：

图3.5 配置Mac风格后的运行结果

现在，我们不动程序，仅仅将配置文件中的“Mac”改为Windows，运行后结果如下：

图3.6 配置为Windows风格后的运行结果

从运行结果看出，我们仅仅通过修改配置文件，就改变了整个程序的行为（我们甚至没有重新编译程序），这就是多态性的威力，也是依赖注入效果。

本节共讨论了三种基本的依赖注入类别，有关更多依赖注入类别和不同类别对比的知识，可以参考Martin Fowler的《Inversion of Control Containers and the Dependency Injection pattern》。

3.2 反射与依赖注入

回想上面Dependency Locate的例子，我们虽然使用了多态性和Abstract Factory，但对OCP贯彻的不够彻底。在理解这点前，朋友们一定要注意潜在扩展在哪里，潜在会出现扩展的地方是“新的组件系列”而不是“组件种类”，也就是说，这里我们假设组件就三种，不会增加新的组件，但可能出现新的外观系列，如需要加一套Ubuntu风格的组件，我们可以新增UbuntuWindow、UbuntuButton、UbuntuTextBox和UbuntuFactory，并分别实现相应接口，这是符合OCP的，因为这是扩展。但我们除了修改配置文件，还要无可避免的修改FactoryContainer，需要加一个分支条件，这个地方破坏了OCP。依赖注入本身是没有能力解决这个问题的，但如果语言支持反射机制（Reflection），则这个问题就迎刃而解。

我们想想，现在的难点是出在这里：对象最终还是要通过“new”来实例化，而“new”只能实例化当前已有的类，如果未来有新类添加进来，必须修改代码。如果，我们能有一种方法，不是通过“new”，而是通过类的名字来实例化对象，那么我们只要将类的名字作为配置项，就可以实现在不修改代码的情况下，加载未来才出现的类。所以，反射给了语言“预见未来”的能力，使得多态性和依赖注入的威力大增。

下面是引入反射机制后，对上面例子的改进：

图3.7 引入反射机制的Dependency Locate

可以看出，引入反射机制后，结构简单了很多，一个反射工厂代替了以前的一堆工厂，Factory Container也不需要了。而且以后有新组件系列加入时，反射工厂是不用改变的，只需改变配置文件就可以完成。下面给出反射工厂和配置文件的代码。

[csharp] view plain copy

 

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5. using System.Reflection;  
6. using System.Xml;  
7.    
8. namespace DependencyLocate  
9. {  
10.     internal static class ReflectionFactory  
11.     {  
12.         private static String _windowType;  
13.         private static String _buttonType;  
14.         private static String _textBoxType;  
15.    
16.         static ReflectionFactory()  
17.         {  
18.             XmlDocument xmlDoc = new XmlDocument();  
19.             xmlDoc.Load("http://www.cnblogs.com/Config.xml");  
20.             XmlNode xmlNode = xmlDoc.ChildNodes[1].ChildNodes[0];  
21.    
22.             _windowType = xmlNode.ChildNodes[0].Value;  
23.             _buttonType = xmlNode.ChildNodes[1].Value;  
24.             _textBoxType = xmlNode.ChildNodes[2].Value;  
25.         }  
26.    
27.         public static IWindow MakeWindow()  
28.         {  
29.             return Assembly.Load("DependencyLocate").CreateInstance("DependencyLocate." + _windowType) as IWindow;  
30.         }  
31.    
32.         public static IButton MakeButton()  
33.         {  
34.             return Assembly.Load("DependencyLocate").CreateInstance("DependencyLocate." + _buttonType) as IButton;  
35.         }  
36.    
37.         public static ITextBox MakeTextBox()  
38.         {  
39.             return Assembly.Load("DependencyLocate").CreateInstance("DependencyLocate." + _textBoxType) as ITextBox;  
40.         }  
41.     }  
42. }  

配置文件如下：

[html] view plain copy

 

1. <?xml version="1.0" encoding="utf-8" ?>  
2. <config>  
3.     <window>MacWindow</window>  
4.     <button>MacButton</button>  
5.     <textBox>MacTextBox</textBox>  
6. </config>  

反射不仅可以与Dependency Locate结合，也可以与Setter Injection与Construtor Injection结合。反射机制的引入，降低了依赖注入结构的复杂度，使得依赖注入彻底符合OCP，并为通用依赖注入框架（如spring.NET中的IoC部分、Unity等）的设计提供了可能性。

3.3 多态的活性与依赖注入

3.3.1 多态性的活性

这一节我们讨论多态的活性及其与依赖注入类型选择间密切的关系。

首先说明，“多态的活性”这个术语是我个人定义的，因为我没有找到既有的概念名词可以表达我的意思，所以就自己造了一个词。这里，某多态的活性是指被此多态隔离的变化所发生变化的频繁程度，频繁程度越高，则活性越强，反之亦然。

上文说过，多态性可以隔离变化，但是，不同的变化，发生的频率是不一样的，这就使得多态的活性有所差别，这种差别影响了依赖注入的类型选择。

举例来说，本文最开始提到的武器多态性，其活性非常高，因为在那个程序中，Role在一次运行中可能更换多次武器。而现在我们假设Role也实现了多态性，这是很可能的，因为在游戏中，不同类型的角色（如暗夜精 灵、牛头人、矮人等）很多属性和业务是想通的，所以很可能通过一个IRole或AbstractRole抽象类实现多态性，不过，Role在实例化后（一般在用户登录成功后），是不会变化的，很少有游戏允许同一个玩家在运行中变换Role类型，所以Role应该是一但实例化，就不会变化，但如果再实例化一个（如另一个玩家登录），则可能就变化了。最后，还有一种多态性是活性非常低的，如我们熟悉的数据访问层多态性，即使我们实现了SQL Server、Oracle和Access等多种数据库的访问层，并实现了依赖注入，但几乎遇不到程序运行着就改数据库或短期内数据库频繁变动的情况。

以上不同的多态性，不但特征不同，其目的一般也不同，总结如下：

高活多态性——指在客户类实例运行期间，服务类可能会改变的多态性。

中活多态性——指在客户类实例化后，服务类不会改变，但同一时间内存在的不同实例可能拥有不同类型的服务类。

低活多态性——指在客户类实例化后，服务类不会改变，且同一时间内所有客户类都拥有相同类型的服务类。

以上三种多态性，比较好的例子就是上文提到的武器多态性（高活）、角色多态性（中活）和数据访问层多态性（低活）。另外，我们说一种多态性是空间稳定的，如果同一客户类在同一时间内的所有实例都依赖相同类型的服务类，反之则叫做空间不稳定多态性。我们说一种多态性是时间稳定的，如果一个客户类在实例化后，所以来的服务类不能再次更改，反之则叫做时间不稳定多态性。显然，高活多态性时间和空间均不稳定；中活多态性是时间稳定的，但空间不稳定；低活多态性时间空间均稳定。

3.3.2 不同活性多态的依赖注入选择

一般来说，高活多态性适合使用Setter注入。因为Setter注入最灵活，也是唯一允许在同一客户类实例运行期间更改服务类的注入方式。并且这种注入一般由上下文环境通过Setter的参数指定服务类类型，方便灵活，适合频繁变化的高活多态性。

对于中活多态性，则适合使用Constructor注入。因为Constructor注入也是由上下文环境通过Construtor的参数指定服务类类型，但一点客户类实例化后，就不能进行再次注入，保证了其时间稳定性。

而对于低活多态性，则适合使用Dependency Locate并配合文件配置进行依赖注入，或Setter、Constructor配合配置文件注入，因为依赖源来自文件，如果要更改服务类，则需要更改配置文件，一则确保了低活多态性的时间和空间稳定性，二是更改配置文件的方式方便于大规模服务类替换。（因为低活多态性一旦改变行为，往往规模很大，如替换整个数据访问层，如果使用Setter和Construtor传参，程序中需要改变的地方不计其数）

本质上，这种选择是因为不同的依赖注入类型有着不同的稳定性，大家可以细细体会“活性”、“稳定性”和“依赖注入类型”之间密切的关系。

 

引自：http://blog.csdn.net/commandbaby/article/details/51578699