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()通过传入不同的参数,创建不同的工厂类。

实际的流程如下:

  1. 客户端程序调用  ClassFactory.GetFactory(string factoryName) 方法,传入工厂名称。
  2. 在GetFactory() 方法中一个ClassFactoryConfiguration对象,这个对象封装了获取app.Config中信息的方法。
  3. ClassFactoryConfiguration 根据 factoryName参数在app.Config中寻找与工厂名称匹配的节点,找到后,返回该工厂的类型信息。
  4. 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

感谢阅读,希望这篇文章可以为你带来帮助!