SAF 中抽象工厂的实现
本文是《Developing Application Frameworks in .NET》的读书笔记。SAF 是书中的一个范例框架，意为 Simple Application Framework(简单应用程序框架)。这篇文章主要向大家说明了SAF中抽象工厂模式的实现方式。
设计思想概述
抽象工厂是很常用的一种创建型模式，它的主要作用在于向程序员屏蔽了创建对象的复杂细节，在获取对象时，只需要在工厂类上调用 GetXXX()，或者 CreateXXX()，便可以得到一个类型实例，而不是通常所使用的new XXX()这种方式。关于抽象工厂更详细的内容可以参考 奇幻RPG(人物构建与Abstract Factory模式) 这篇文章。SAF 的抽象工厂也是基于GOF的这个基本模型，但是做了下面两个改进：
利用反射，根据字符串动态创建工厂
我们获得工厂类时，通常还是通过AbstractFactory factory = new ConcreteFactory()这种方式获得。这样如果我们想更换一个工厂实体类时，比如说，将上面的ConcreteFactory换成 AnotherFactory，我们需要修改代码为 AbstractFactory factory = new AnotherFactory()，这样免不了需要再次重新进行编译。
在SAF中，使用了自定义Config配置节点，将 工厂名称 和 它的类型信息(所在的程序集、命名空间、类型名称)全部保存在了App.Config文件中，并创建相应的ClassFactoryConfiguration 类型用于获取App.Config中的节点信息。然后创建ClassFactory类型，并在其中添加静态方法GetFactory(string name)，其中name代表了工厂名称(必须与App.Config中保存的名称匹配)。然后，在客户端调用这个方法来创建工厂。通过这种方式，我们只需要在Config中保存所有的工厂类信息，然后就可以为GetFactory()通过传入不同的参数，创建不同的工厂类。
实际的流程如下：
-
客户端程序调用 ClassFactory.GetFactory(string factoryName) 方法，传入工厂名称。
-
在GetFactory() 方法中一个ClassFactoryConfiguration对象，这个对象封装了获取app.Config中信息的方法。
-
ClassFactoryConfiguration 根据 factoryName参数在app.Config中寻找与工厂名称匹配的节点，找到后，返回该工厂的类型信息。
-
GetFactory()方法根据类型信息，使用反射创建类型实例，然后返回该实例。
使用Remoting创建远程工厂
SAF中的另一个改进是引入了Remoting，关于Remoting的详细内容，可以参考 .Net中的Remoting 这篇文章。有的时候，我们需要使用Remoting获取位于远程服务器中的对象，这时往往需要写一些注册Channel、转换对象类型的代码。SAF的抽象工厂将这些细节也屏蔽了起来，只要将获取远程对象的地址写在配置文件中，比如http://localhost:8989/ClassFactory，剩下的步骤与使用本地对象别无二致，极大的简化了操作。
接下来我们看一下代码实现。
代码实现
抽象工厂类的实现
首先是创建抽象工厂类的体系，新建一个解决方案ClassFactory，再其下建立一个类库项目 Factory，它包含了下面一些类，以构成一个基本的抽象工厂模式，作为范例：
namespace Factory {
/* 工厂基类
* **************************************************/
public abstract class ProductFactory : MarshalByRefObject{
public abstract Product GetCheapProduct();
public abstract Product GetExpensiveProduct();
}
// 工厂实体类 (一般产品)
public class ConcreteProductFactory : ProductFactory {
public override Product GetCheapProduct() {
return new CheapProduct();
}
public override Product GetExpensiveProduct() {
return new ExpensiveProduct();
}
}
// 工厂实体类 (新产品)
public class ConcreteNewProductFactory : ProductFactory {
public override Product GetCheapProduct() {
return new NewCheapProduct();
}
public override Product GetExpensiveProduct() {
return new NewExpensiveProduct();
}
}
// 工厂实体类 (远程产品) 使用Remoting
public class ConcreteRemoteProductFactory : ProductFactory {
public override Product GetCheapProduct() {
return new RemoteCheapProduct();
}
public override Product GetExpensiveProduct() {
return new RemoteExpensiveProduct();
}
}
/* 产品基类 MashalByRefObject
* **************************************************/
public abstract class Product : MarshalByRefObject {
public abstract string Name { get; }
public abstract int GetPrice();
public abstract string GetColor();
}
// 一般产品实体类 ( 由 ConcreteProductFactory 创建 )
public class CheapProduct : Product {
private const int cost = 10;
private const string color = "red";
private const string name = "Cheap Product";
public override int GetPrice() {
return cost * 2;
}
public override string GetColor() {
return color;
}
public override string Name {
get {
return name;
}
}
}
// 一般产品实体类 ( 由 ConcreteProductFactor 创建 )
public class ExpensiveProduct : Product { /* 实现略 */ }
// 新产品实体类 ( 由 ConcreteNewProductFactory 创建 )
public class NewCheapProduct : Product { /* 实现略 */ }
// 新产品实体类 ( 由 ConcreteNewProductFactory 创建 )
public class NewExpensiveProduct : Product { /* 实现略 */ }
// 远程产品实体类 ( 由 ConcreteRemoteProductFactory 创建 )
public class RemoteCheapProduct : Product { /* 实现略 */ }
// 远程产品实体类 ( 由 ConcreteRemoteProductFactory 创建 )
public class RemoteExpensiveProduct : Product { /* 实现略 */ }
}
这里需要注意的是 ProductFactory和 Product 抽象类均继承自 MarshalByRefObject 基类，这是因为这两个类的子类实现有一部分位于客户端、还有一部分位于服务器端，为了能从服务器端向客户端进行封送(Marshal)，它们必须声明为继承自MarshalByRefObject。
我们注意到上面这段程序的两个 远程产品实体类(RemoteCheapProduct和RemoteExpensiveProduct) 应该是仅存在于服务器端的，等下我们会细说这里。现在我们编译上面的代码，会在Bin目录下生成Factory.dll文件。
服务器端的实现
服务器端的实现很简单，仅仅是开启Remoting服务，供客户端进行调用就可以了。在上面已经说明，服务器端仅需要提供两个远程产品实体类(RemoteCheapProduct 和 RemoteExpensiveProduct)，所以只需要提供一个 ConcreteRemoteProductFactory 工厂类型就可以了。现在我们再创建一个解决方案，名为FactoryServer，在其下添加一个Console控制台项目RemoteServer，接下来，我们 把上一步生成的Factory.dll 文件复制到Bin目录下，然后引用它(不要引用项目)。
这里需要注意：因为Factory包含了远程所要提供的对象，所以我们需要引用它；而它也包含了客户端可以直接创建的对象，所以客户端也需要引用Factory.dll，但是我们不能将Factory服务器端所提供的内容交给客户端(如果可以的话，我们根本用不着Remoting)，所以我们在客户端引用Factory之前要屏蔽掉服务器端实现的内容。如果直接引用项目(服务器端、客户端同时引用了Factory项目)，一是没有起到服务端、客户端分离的作用，二是一旦我们屏蔽掉Factory项目中的内容，那么重新生成之后，服务器端也丧失了这些内容(所以我们在屏蔽部分内容之前将生成好的dll复制到FactoryServer的Bin目录下，然后引用之)。
服务器端通过配置的方式开启Remoting服务，app.Config中的配置如下：
<system.runtime.remoting>
<application>
<service>
<wellknown
mode="Singleton"
type="Factory.ConcreteRemoteProductFactory, Factory"
objectUri="ClassFactory" />
</service>
<channels>
<channel ref="http" port="8989"/>
</channels>
</application>
</system.runtime.remoting>
接着，编写Program代码，仅仅是根据配置开启服务而已：
public class Program {
static void Main(string[] args) {
// 根据 App.config.exe 中的配置开启远程服务
RemotingConfiguration.Configure("RemoteServer.exe.config", false);
Console.WriteLine("远程服务成功开启！");
Console.ReadLine();
}
}
客户端的实现
我们在上面 抽象工厂类 的实现中，已经创建了一个解决方案ClassFactory，以及其下的Factory项目。我们将ClassFactory解决方案整体视为客户端，此时，客户端不应包含服务端的代码实现(RemoteCheapProduct类 和 RemoteExpensiveProduct类)，所以我们将它删除或者注释掉。另外，由于Config中保存的类型信息是工厂类型的信息，比如ConcreteRemoteProductFactory类型的信息，所以当我们通过反射创建远程工厂类型的实例时，客户端依然需要ConcreteRemoteProductFactory的类型信息，所以我们不能屏蔽掉ConcreteRemoteProductFactory，但是我们可以让它什么都不做(Empty Class)，现在修改ConcreteRemoteProductFactory 如下所示：
// 工厂实体类 (远程产品) 使用Remoting
public class ConcreteRemoteProductFactory : ProductFactory {
public override Product GetCheapProduct() {
throw new Exception("由服务器端实现");
}
public override Product GetExpensiveProduct() {
throw new Exception("由服务器端实现");
}
}
这个类仅仅是为了在客户端提供一个类型信息，以便能够通过反射创建类型，实际上只要访问的是服务器端，那么这里永远都不会抛出异常，因为这个类实际是在服务器端创建的。
现在修改app.config文件，记录我们所有的工厂类的 名称 及类型信息。名称可以任意起，在创建类型的时候调用的GetFactory(string name)方法的name参数要与这里匹配；类型信息必须为客户端拥有的工厂类类型，用于通过反射创建对象：
<configSections>
<section name="classFactory" type="ConfigManager.ClassFactorySectionHandler, ConfigManager" />
</configSections>
<classFactory>
<factory name="ProductFactory-A" type="Factory.ConcreteProductFactory, Factory" />
<factory name="ProductFactory-B" type="Factory.ConcreteNewProductFactory, Factory" />
<factory name="Remote-ProductFactory-C" location="http://localhost:8989/ClassFactory" type="Factory.ConcreteRemoteProductFactory, Factory" />
</classFactory>
注意到name属性为" Remote-ProductFactory-C "的节点，它拥有一个location属性，这个属性保存了获取它的远程地址，用于Remoting访问。
接下来，我们要创建对这个节点的处理程序，ClassFactorySectionHandler。在ClassFactory解决方案下再添加一个类库项目：ConfigManager，然后添加ClassFactorySectionHandler类，它用于处理节点(如不清楚，可以参考 .Net自定义应用程序配置)：
// 结点处理程序，在调用 ConfigurationManager.GetSection("sectionName") 自动调用这里
public class ClassFactorySectionHandler : IConfigurationSectionHandler {
public object Create(object parent, object configContext, XmlNode section) {
return new ClassFactoryConfiguration(section);
}
}
// 结点配置程序
public class ClassFactoryConfiguration {
private XmlNode node;
// 这里的 node 为 classFactory 结点
public ClassFactoryConfiguration(XmlNode section) {
this.node = section;
}
// 获取与name属性匹配的子结点的 type 属性
public string GetFactoryType(string name) {
// 获取子结点，使用 XPath 语法查找
XmlNode childNode = node.SelectSingleNode("factory[@name='" + name + "']");
if (childNode != null && childNode.Attributes["type"] != null)
return childNode.Attributes["type"].Value;
else
return null;
}
// 获取与name属性匹配的子结点的 location 属性
// location 属性指定远程对象的获取位置
public string GetFactoryLocation(string name) {
// 获取子结点，使用 XPath 语法查找
XmlNode childNode = node.SelectSingleNode("factory[@name='" + name + "']");
if (childNode != null && childNode.Attributes["location"] != null)
return childNode.Attributes["location"].Value;
else
return null;
}
}
我们只需要注意两个方法就可以了：GetFacotryType(string name)，获取工厂类的类型，用于通过反射创建类型；GetFactoryLocation(string name)，获取工厂类的地址，用于Remoting。
接下来我们在解决方案下再创建一个控制台项目，Main，它是我们的客户程序。在其下创建ClassFactory类，我们的所有客户端代码实际上通过这个类的静态方法GetFactory(string name)获取工厂类：
public class ClassFactory {
// 不允许使用 new 创建
private ClassFactory() {}
// 根据结点的name属性创建Factory对象
public static object GetFactory(string name) {
object factory = null;
// 获取配置对象
ClassFactoryConfiguration config =
(ClassFactoryConfiguration)ConfigurationManager.GetSection("classFactory");
// 获取Factory位置，用于Remoting远程对象
string location = config.GetFactoryLocation(name);
// 获取Factory类型
string type = config.GetFactoryType(name);
if(type == null) return null;
Type t = Type.GetType(type);
try {
if (location != null) {
factory = Activator.GetObject(t, location); // 创建远程对象
} else {
factory = Activator.CreateInstance(t); // 创建本地对象
}
}
catch {
throw new Exception("使用反射创建对象失败！");
}
return factory;
}
}
代码测试
现在我们对代码进行一下测试：
public class Program {
static void Main(string[] args) {
// 创建根据配置创建工厂类
ProductFactory pfA = (ProductFactory)ClassFactory.GetFactory("ProductFactory-A");
ProductFactory pfB = (ProductFactory)ClassFactory.GetFactory("ProductFactory-B");
ProductFactory pfC = (ProductFactory)ClassFactory.GetFactory("Remote-ProductFactory-C");
// 创建本地产品
Product p1 = pfA.GetCheapProduct();
Product p2 = pfA.GetExpensiveProduct();
Product p3 = pfB.GetCheapProduct();
Product p4 = pfB.GetExpensiveProduct();
// 创建远程产品
Product p5 = pfC.GetCheapProduct();
Product p6 = pfC.GetExpensiveProduct();
// 打印产品
PrintDescription(p1);
PrintDescription(p2);
PrintDescription(p3);
PrintDescription(p4);
// 打印远程产品
PrintDescription(p5);
PrintDescription(p6);
Console.WriteLine("Press enter to finish");
Console.ReadLine();
}
private static void PrintDescription(Product p) {
Console.WriteLine("{0}", p.Name);
Console.WriteLine("---------------------------");
Console.WriteLine("Color: {0}", p.GetColor());
Console.WriteLine("Price: {0} \n", p.GetPrice());
}
}
在运行之前，先运行服务端，然后再运行客户端，可以得到下面的输出结果：
Cheap Product
---------------------------
Color: red
Price: 20
Expensive Product
---------------------------
Color: red
Price: 100
// 略 ...
Press enter to finish
感谢阅读，希望这篇文章可以为你带来帮助！