上面我们从需求背景的角度，讲述了依赖注入的来源和定义。但是，如果依赖注入仅仅就只有这么点东西，那也没有什么值得讨论的了。但是，上面讨论的仅仅是依赖注入的内涵，其外延还是非常广泛的，从依赖注入衍生出了很多相关的概念与技术，下面我们讨论一下依赖注入的“那些事儿”。
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注入的示例代码。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SetterInjection
{
internal interface IServiceClass
{
String ServiceInfo();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SetterInjection
{
internal class ServiceClassA : IServiceClass
{
public String ServiceInfo()
{
return "我是ServceClassA";
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SetterInjection
{
internal class ServiceClassB : IServiceClass
{
public String ServiceInfo()
{
return "我是ServceClassB";
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SetterInjection
{
internal class ClientClass
{
private IServiceClass _serviceImpl;
public void Set_ServiceImpl(IServiceClass serviceImpl)
{
this._serviceImpl = serviceImpl;
}
public void ShowInfo()
{
Console.WriteLine(_serviceImpl.ServiceInfo());
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace SetterInjection
{
class Program
{
static void Main(string[] args)
{
IServiceClass serviceA = new ServiceClassA();
IServiceClass serviceB = new ServiceClassB();
ClientClass client = new ClientClass();
client.Set_ServiceImpl(serviceA);
client.ShowInfo();
client.Set_ServiceImpl(serviceB);
client.ShowInfo();
}
}
}
运行结果如下：
图3.2 Setter注入运行结果
3.1.2 构造注入
另外一种依赖注入方式，是通过客户类的构造函数，向客户类注入服务类实例。
构造注入（Constructor Injection）是指在客户类中，设置一个服务类接口类型的数据成员，并以构造函数为注入点，这个构造函数接受一个具体的服务类实例为参数，并将它赋给服务类接口类型的数据成员。
图3.3 构造注入示意
图3.3是构造注入的示意图，可以看出，与Setter注入很类似，只是注入点由Setter方法变成了构造方法。这里要注意，由于构造注入只能在实例化客户类时注入一次，所以一点注入，程序运行期间是没法改变一个客户类对象内的服务类实例的。
由于构造注入和Setter注入的IServiceClass，ServiceClassA和ServiceClassB是一样的，所以这里给出另外ClientClass类的示例代码。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConstructorInjection
{
internal class ClientClass
{
private IServiceClass _serviceImpl;
public ClientClass(IServiceClass serviceImpl)
{
this._serviceImpl = serviceImpl;
}
public void ShowInfo()
{
Console.WriteLine(_serviceImpl.ServiceInfo());
}
}
}
可以看到，唯一的变化就是构造函数取代了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组件的示例代码，完整代码请参考文末附上的完整源程序。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DependencyLocate
{
internal interface IButton
{
String ShowInfo();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DependencyLocate
{
internal sealed class WindowsButton : IButton
{
public String Description { get; private set; }
public WindowsButton()
{
this.Description = "Windows风格按钮";
}
public String ShowInfo()
{
return this.Description;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DependencyLocate
{
internal sealed class MacButton : IButton
{
public String Description { get; private set; }
public MacButton()
{
this.Description = " Mac风格按钮";
}
public String ShowInfo()
{
return this.Description;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DependencyLocate
{
internal interface IFactory
{
IWindow MakeWindow();
IButton MakeButton();
ITextBox MakeTextBox();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DependencyLocate
{
internal sealed class WindowsFactory : IFactory
{
public IWindow MakeWindow()
{
return new WindowsWindow();
}
public IButton MakeButton()
{
return new WindowsButton();
}
public ITextBox MakeTextBox()
{
return new WindowsTextBox();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DependencyLocate
{
internal sealed class MacFactory : IFactory
{
public IWindow MakeWindow()
{
return new MacWindow();
}
public IButton MakeButton()
{
return new MacButton();
}
public ITextBox MakeTextBox()
{
return new MacTextBox();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
namespace DependencyLocate
{
internal static class FactoryContainer
{
public static IFactory factory { get; private set; }
static FactoryContainer()
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load("http://www.cnblogs.com/Config.xml");
XmlNode xmlNode = xmlDoc.ChildNodes[1].ChildNodes[0].ChildNodes[0];
if ("Windows" == xmlNode.Value)
{
factory = new WindowsFactory();
}
else if ("Mac" == xmlNode.Value)
{
factory = new MacFactory();
}
else
{
throw new Exception("Factory Init Error");
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DependencyLocate
{
class Program
{
static void Main(string[] args)
{
IFactory factory = FactoryContainer.factory;
IWindow window = factory.MakeWindow();
Console.WriteLine("创建 " + window.ShowInfo());
IButton button = factory.MakeButton();
Console.WriteLine("创建 " + button.ShowInfo());
ITextBox textBox = factory.MakeTextBox();
Console.WriteLine("创建 " + textBox.ShowInfo());
Console.ReadLine();
}
}
}
这里我们用XML作为配置文件。配置文件Config.xml如下：
<?xml version="1.0" encoding="utf-8" ?>
<config>
<factory>Mac</factory>
</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也不需要了。而且以后有新组件系列加入时，反射工厂是不用改变的，只需改变配置文件就可以完成。下面给出反射工厂和配置文件的代码。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Xml;
namespace DependencyLocate
{
internal static class ReflectionFactory
{
private static String _windowType;
private static String _buttonType;
private static String _textBoxType;
static ReflectionFactory()
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load("http://www.cnblogs.com/Config.xml");
XmlNode xmlNode = xmlDoc.ChildNodes[1].ChildNodes[0];
_windowType = xmlNode.ChildNodes[0].Value;
_buttonType = xmlNode.ChildNodes[1].Value;
_textBoxType = xmlNode.ChildNodes[2].Value;
}
public static IWindow MakeWindow()
{
return Assembly.Load("DependencyLocate").CreateInstance("DependencyLocate." + _windowType) as IWindow;
}
public static IButton MakeButton()
{
return Assembly.Load("DependencyLocate").CreateInstance("DependencyLocate." + _buttonType) as IButton;
}
public static ITextBox MakeTextBox()
{
return Assembly.Load("DependencyLocate").CreateInstance("DependencyLocate." + _textBoxType) as ITextBox;
}
}
}
配置文件如下：
<?xml version="1.0" encoding="utf-8" ?>
<config>
<window>MacWindow</window>
<button>MacButton</button>
<textBox>MacTextBox</textBox>
</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传参，程序中需要改变的地方不计其数）
本质上，这种选择是因为不同的依赖注入类型有着不同的稳定性，大家可以细细体会“活性”、“稳定性”和“依赖注入类型”之间密切的关系。
本文基于署名-非商业性使用 3.0许可协议发布，欢迎转载，演绎，但是必须保留本文的署名张洋（包含链接），且不得用于商业目的。如您有任何疑问或者授权方面的协商，请与我联系。
1401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
