SAF 中抽象工厂的实现

2024-08-29 23:48
文章标签 实现 抽象 工厂 saf

本文主要是介绍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

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


这篇关于SAF 中抽象工厂的实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1119200。

相关文章

Java实现检查多个时间段是否有重合

Java实现检查多个时间段是否有重合

《Java实现检查多个时间段是否有重合》这篇文章主要为大家详细介绍了如何使用Java实现检查多个时间段是否有重合,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录流程概述步骤详解China编程步骤1：定义时间段类步骤2：添加时间段步骤3：检查时间段是否有重合步骤4：输出结果示例代码结语作
阅读更多...
使用C++实现链表元素的反转

使用C++实现链表元素的反转

《使用C++实现链表元素的反转》反转链表是链表操作中一个经典的问题,也是面试中常见的考题,本文将从思路到实现一步步地讲解如何实现链表的反转,帮助初学者理解这一操作,我们将使用C++代码演示具体实现,同... 目录问题定义思路分析代码实现带头节点的链表代码讲解其他实现方式时间和空间复杂度分析总结问题定义给定
阅读更多...
Java覆盖第三方jar包中的某一个类的实现方法

Java覆盖第三方jar包中的某一个类的实现方法

《Java覆盖第三方jar包中的某一个类的实现方法》在我们日常的开发中,经常需要使用第三方的jar包,有时候我们会发现第三方的jar包中的某一个类有问题,或者我们需要定制化修改其中的逻辑,那么应该如何... 目录一、需求描述二、示例描述三、操作步骤四、验证结果五、实现原理一、需求描述需求描述如下：需要在
阅读更多...
如何使用Java实现请求deepseek

如何使用Java实现请求deepseek

《如何使用Java实现请求deepseek》这篇文章主要为大家详细介绍了如何使用Java实现请求deepseek功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1.deepseek的api创建2.Java实现请求deepseek2.1 pom文件2.2 json转化文件2.2
阅读更多...
python使用fastapi实现多语言国际化的操作指南

python使用fastapi实现多语言国际化的操作指南

《python使用fastapi实现多语言国际化的操作指南》本文介绍了使用Python和FastAPI实现多语言国际化的操作指南,包括多语言架构技术栈、翻译管理、前端本地化、语言切换机制以及常见陷阱和... 目录多语言国际化实现指南项目多语言架构技术栈目录结构翻译工作流1. 翻译数据存储2. 翻译生成脚本
阅读更多...
如何通过Python实现一个消息队列

如何通过Python实现一个消息队列

《如何通过Python实现一个消息队列》这篇文章主要为大家详细介绍了如何通过Python实现一个简单的消息队列,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录如何通过 python 实现消息队列如何把 http 请求放在队列中执行1. 使用 queue.Queue 和 reque
阅读更多...
Python如何实现PDF隐私信息检测

Python如何实现PDF隐私信息检测

《Python如何实现PDF隐私信息检测》随着越来越多的个人信息以电子形式存储和传输,确保这些信息的安全至关重要,本文将介绍如何使用Python检测PDF文件中的隐私信息,需要的可以参考下... 目录项目背景技术栈代码解析功能说明运行结php果在当今，数据隐私保护变得尤为重要。随着越来越多的个人信息以电子形
阅读更多...
使用 sql-research-assistant进行 SQL 数据库研究的实战指南(代码实现演示)

使用 sql-research-assistant进行 SQL 数据库研究的实战指南(代码实现演示)

《使用sql-research-assistant进行SQL数据库研究的实战指南(代码实现演示)》本文介绍了sql-research-assistant工具,该工具基于LangChain框架,集... 目录技术背景介绍核心原理解析代码实现演示安装和配置项目集成LangSmith 配置（可选）启动服务应用场景
阅读更多...
使用Python快速实现链接转word文档

使用Python快速实现链接转word文档

《使用Python快速实现链接转word文档》这篇文章主要为大家详细介绍了如何使用Python快速实现链接转word文档功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 演示代码展示from newspaper import Articlefrom docx import
阅读更多...
前端原生js实现拖拽排课效果实例

前端原生js实现拖拽排课效果实例

《前端原生js实现拖拽排课效果实例》：本文主要介绍如何实现一个简单的课程表拖拽功能,通过HTML、CSS和JavaScript的配合,我们实现了课程项的拖拽、放置和显示功能,文中通过实例代码介绍的... 目录1. 效果展示2. 效果分析2.1 关键点2.2 实现方法3. 代码实现3.1 html部分3.2
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2