[设计模式]我的实用设计模式之四-Simple Factory,Factory Method和Abs-Mikel

Simple Factory

先从Simple Factory开始讲起，假设模拟一个电玩店的试玩系统，这个电玩店专卖出售PS3的游戏机和提供试玩服务，当一个用户想试玩的时候，需要选择一种游戏类型进行试玩，系统会选择生成其中一个游戏盘的对象：竞赛游戏（PS3RacingGameDisk），射击游戏 (PS3ShootingGameDisk)以及格斗游戏(PS3FightingGameDisk)，这些游戏盘子类都分别继承自同一个游戏盘抽象类 AbstractGameDisk。

图1

    public abstract class AbstractGameDisk
    {
        public string Name { get; set; }
        public abstract void Load();
    }
    public class PS3RacingGameDisk : AbstractGameDisk
    {
        public override void Load()
        {
            Console.WriteLine("Load PS3 racing game.");
        }
    }
    public class PS3ShootingGameDisk : AbstractGameDisk
    {
        public override void Load()
        {
            Console.WriteLine("Load PS3 shooting game.");
        }
    }
    public class PS3FightingGameDisk : AbstractGameDisk
    {
        public override void Load()
        {
            Console.WriteLine("Load PS3 fighting game.");
        }
    }
    public enum GameDiskType
    {
        RACING,
        SHOOTING,
        FIGHTING
    }
    public class PS3Player
    {
        public void PlayAGame(GameDiskType type)
        {
            //Get a console
            //Get a joystick
            //create a game disk
            AbstractGameDisk disk;
            switch (type)
            {
                case GameDiskType.RACING:
                    disk = new PS3RacingGameDisk();
                    break;
                case GameDiskType.SHOOTING:
                    disk = new PS3ShootingGameDisk();
                    break;
                case GameDiskType.FIGHTING:
                    disk = new PS3FightingGameDisk();
                    break;
                default:
                    disk = null;
                    break;
            }
            //insert disk to console
            //load game
            //play and enjoy it
        }
    }

代码1

从上述代码看，如果我们需要增加新的游戏盘，例如角色扮演游戏（RolePlayGameDisk），那么生成游戏盘部分（见注释create a game disk处)需要增加case分支，这里的对具体游戏盘对象实例化存在着变化的需求。根据设计原则 "封装变化（Encapsulate what varies）" 对这一对象实例化的需求进行封装。引入一个新的类来封装和处理对象生成的需求，这个类叫做PS3DiskFacotry。

    public class PS3Player
    {
        public void PlayAGame(GameDiskType type)
        {
            //Get a console
            //Get a joystick
            //create a game disk
            AbstractGameDisk disk = PS3DiskFactory.CreateGameDisk(type);

            //insert disk to console
            //load game
            //play and enjoy it
        }
    }
    public sealed class PS3DiskFactory
    {
        public static AbstractGameDisk CreateGameDisk(GameDiskType type)
        {
            switch (type)
            {
                case GameDiskType.RACING:
                    return new PS3RacingGameDisk();
                case GameDiskType.SHOOTING:
                    return new PS3ShootingGameDisk();
                case GameDiskType.FIGHTING:
                    return new PS3FightingGameDisk();
                default:
                    return null;
            }
        }
    }

代码2
从上面的代码看PS3DiskFactory专门负责游戏盘（AbstractGameDisk的具体子类）的实例化过程，当有新的游戏盘增加时，也就是实例化过程的需求发生变化时，全部变化会单独发生在PS3DiskFactory里面，也就是可变化的需求被封装到一个类里面了，这就是Simple Factory的实现。

图2
由于对实例化需求的变化的封装，从图可见PS3DiskManager和具体的游戏盘类（PS3RacingGameDisk，PS3ShootingGameDisk和PS3FightingGameDisk等）彻底的解耦，PS3DiskManager只是依赖于他们共同的抽象类AbstractGameDisk和工厂类PS3DiskFactory。Simple Factory的作用就是用来封装“对象实例化可变化的需求”。

Factory Method

随着这个电玩店的发展，店里开始支持Wii游戏机销售和试玩，原先的系统需要更新符合这一新需求。参考Simple Factory的实现，我们可以很快速的实现Wii的需求。

    public class WiiPlayer
    {
        public void PlayAGame(GameDiskType type)
        {
            //Get a console
            //Get a joystick
            //create a game disk
            AbstractGameDisk disk = WiiDiskFactory.CreateGameDisk(type);

            //insert disk to console
            //load game
            //play and enjoy it
        }
    }
    public sealed class WiiDiskFactory
    {
        public static AbstractGameDisk CreateGameDisk(GameDiskType type)
        {
            switch (type)
            {
                case GameDiskType.RACING:
                    return new WiiRacingGameDisk();
                case GameDiskType.SHOOTING:
                    return new WiiShootingGameDisk();
                case GameDiskType.FIGHTING:
                    return new WiiFightingGameDisk();
                default:
                    return null;
            }
        }
    }

public class WiiRacingGameDisk : AbstractGameDisk
    {
        public override void Load()
        {
            Console.WriteLine("Load Wii racing game.");
        }
    }
    public class WiiShootingGameDisk : AbstractGameDisk
    {
        public override void Load()
        {
            Console.WriteLine("Load Wii shooting game.");
        }
    }
    public class WiiFightingGameDisk : AbstractGameDisk
    {
        public override void Load()
        {
            Console.WriteLine("Load Wii fighting game.");
        }
    }

代码3

图3
第一眼看是不是很容易实现了新的需求？Copy & Paste，稍稍修改一下就完了。可是有没有发现两个Player类除了对GameDisk的实例化以外，其他的一模一样。我们引进第二个设计原则 "面向抽象编程，而不是面向具体编程（Depend on Abstractions, not on Concretions）" ,增加对各个具体Player的抽象类AbstractPlayer.Client面向的是Player的抽象类而不是具体的Player。

    public abstract class AbstractPlayer
    {
        public void PlayAGame(GameDiskType type)
        {
            //Get a console
            //Get a joystick
            //create a game disk
            AbstractGameDisk disk = CreateGameDisk(type);
            //insert disk to console
            //load game
            //play and enjoy it
        }
        protected abstract AbstractGameDisk CreateGameDisk(GameDiskType type);
    }
    public class PS3Player : AbstractPlayer
    {
        protected override AbstractGameDisk CreateGameDisk(GameDiskType type)
        {
            return PS3DiskFactory.CreateGameDisk(type);
        }
    }
    public class WiiPlayer : AbstractPlayer
    {
        protected override AbstractGameDisk CreateGameDisk(GameDiskType type)
        {
            return WiiDiskFactory.CreateGameDisk(type);
        }
    }

代码4

图4
引入对具体各个Players的抽象类AbstractPlayer后，在程序中可以声明AbstractPlayer的引用，而具体的Player对象的实例化过程留给具体的Player类（PS3Player或者WiiPlayer）来实现。AbstractPlayer声明 CreateGameDisk方法负责实例化AbstractGameDisk的子类对象，具体的Player类负责实例化具体的 AbstractGameDisk的子类。这个Method（CreateGameDisk）的行为就是一个Factory,所以称为Factory Method。下面是一个典型的Factory Method的UML图。

图5
从图5和图4可以看，AbstractPlayer就是一个Creator，而PS3Player和WiiPlayer是一个 ConcreteCreator，CreateGameDisk（）就是FactoryMethod（），AbstractPlayer只是定义实例化方法，但是不知道具体如何实例化对象，实例化那个具体的对象，这些都是由PS3Player和WiiPlayer负责的。在上述的实现，PS3Player 和WiiPlayer是借助于Simple Factory来实例化对象。

Factory Method是一个推迟实例化的过程，在抽象类（Creator）定义实例化的行为（FactoryMethod），然后由具体的子类（ConcreteCreator）决定具体实例化的对象。其实在OO中，抽象类负责定义行为（在C#中为Method或者Property），子类负责实现行为，运行时动态调用不同行为称为多态（polymorphism）。但是构造函数不能实现多态，Factory Method就是解决对象实例化的多态问题。Factory Method的别名也叫Virtual Constructor，为什么这样叫了，因为在C++里面实现多态都要定义Virtual Function(虚函数)，但是Constructor是不能定义为virtual的，Factory Method恰恰解决这个问题，所以也就Virtual Constructor了。

Abstract Factory

上面讲述的Simple Factory和Factory Method解决了游戏盘（GameDisk）的对象的实例化过程，如果在Player中其他使用到的引用（例如游戏主机GameConsole和手柄 Joystick）都需要实现实例化不同的对象。那么就不仅仅需要CreateGameDisk（），而且需要CreateGameConsole（）和 CreateJoystick（）来实例化具体的对象。抽象类AbstractPlayer组合这些Factory Methods，实现如下。

    public abstract class AbstractPlayer
    {
        public abstract AbstractGameDisk CreateGameDisk(GameDiskType type);
        public abstract AbstractGameConsole CreateGameConsole();
        public abstract AbstractJoystick CreateJoystick();
    }
    public class PS3Player : AbstractPlayer
    {
        public override AbstractGameDisk CreateGameDisk(GameDiskType type)
        {
            return PS3DiskFactory.CreateGameDisk(type);
        }
        public override AbstractGameConsole CreateGameConsole()
        {
            return new PS3Console();
        }
        public override AbstractJoystick CreateJoystick()
        {
            return new PS3Joystick();
        }
    }
    public class WiiPlayer : AbstractPlayer
    {
        public override AbstractGameDisk CreateGameDisk(GameDiskType type)
        {
            return WiiDiskFactory.CreateGameDisk(type);
        }
        public override AbstractGameConsole CreateGameConsole()
        {
            return new WiiConsole();
        }
        public override AbstractJoystick CreateJoystick()
        {
            return new WiiJoystick();
        }
    }
    public abstract class AbstractGameDisk
    {
        public string Name { get; set; }
        public abstract void Load();
    }
    public abstract class AbstractGameConsole
    {
        public void InsertGameDisk(AbstractGameDisk disk) { }
        public void PluginJoystick(AbstractJoystick joystick) { }
    }
    public abstract class AbstractJoystick
    {
    }
    public class PS3Console : AbstractGameConsole
    {
    }
    public class PS3Joystick : AbstractJoystick
    {
    }
    public class WiiConsole : AbstractGameConsole
    {
    }
    public class WiiJoystick : AbstractJoystick
    {
    }

代码5
AbstractPlayer不再负责PlayAGame的功能，只是声明了一系列产品的实例化的Methods。AbstractPlayer还是Factory Method。我们需要实现PlayAGame的功能，基于设计原则"组合优于继承（Favor Object composition over inheritance）"，我们定义一个新的类（Player），然后把工厂类（AbstractPlayer）作为一个引用组合到这一个类里面，这就是Abstract Factory模式的实现。

    public enum GameDevice
    {
        PS3,
        WII
    }
    public class Player
    {
        private AbstractPlayer playerFactory;
        public Player(GameDevice device)
        {
            switch (device)
            {
                case GameDevice.PS3:
                    playerFactory = new PS3Player();
                    break;
                case GameDevice.WII:
                    playerFactory = new WiiPlayer();
                    break;
            }
        }
        public void PlayAGame(GameDiskType type)
        {
            //Get a console
            AbstractGameConsole console = CreateGameConsole();
            //Get a joystick
            AbstractJoystick joystick = CreateJoystick();
            console.PluginJoystick(joystick);
            //create a game disk
            AbstractGameDisk disk = CreateGameDisk(type);
            //insert disk to console
            console.InsertGameDisk(disk);
            //load game
            //play and enjoy it
        }
        private AbstractGameDisk CreateGameDisk(GameDiskType type)
        {
            return playerFactory.CreateGameDisk(type);
        }

        private AbstractGameConsole CreateGameConsole()
        {
            return playerFactory.CreateGameConsole();
        }
        private AbstractJoystick CreateJoystick()
        {
            return playerFactory.CreateJoystick();
        }
    }

代码6

图6

以下为一个经典Abtract Factory的实现，用于对比参考

图7

Player（Client）完全不知道GameConsole，Joystick和GameDisk到底如何实例化的，这些都又具体工厂（PS3Player或者WiiPlayer）来负责一系列相关联的产品（也就是对象）的实例化，这一系列相关联的产品称为产品族（product family）。Player根据GameDevice借助AbstractPlayer实例化产品族，产品族下的所有产品具体协同工作，而Player 只是依赖于产品组的产品的抽象类而不是具体类，也就是说，产品族的替换不会影响Player类的PlayAGame()。这一特性适合可替换产品族的设计，例如不同桌面主题的设计和不同数据库访问组件的设计，ADO.net的数据库访问层就是基于Abstract Factory模式设计的。

Player的构造函数中选择具体工厂也是用了条件选择（switch），这里可以通过Simple Factory来对具体工厂的实例化。

Abstract Factory有几个特点：
1.每次产生一系列相关联的产品，例如 WiiGameConsole,WiiJoystick和WiiRacingGameDisk等等，他们之间是协调工作，例如CreateGame有 InsertGameDisk方法，表示WiiGameConsole和WiiRacingGameDisk协调工作。
2.不同产品族直接的产品不可以相互替换，例如PS3Joystick不能用于WiiGameConsole。
3. 使用Abstract Factory一般在产品族相当固定的情景下，例如XBox游戏机也是有GameConsole,Joystick和GameDisk，那么实现 XBoxPlayer等产品族就可以支持XBox游戏机，但是如果需要更改产品族的产品，例如某新型游戏机不使用GameDisk而是使用 HardDisk来Load游戏的话，那么现有的设计就不能支持这一新型游戏机。

这些我对Simple Factory,Factory Method和Abstract Factory的想法，欢迎指教。

Jake's Blog in 博客园 — 精简开发无线生活

[设计模式]我的实用设计模式之四-Simple Factory,Factory Method和Abs

Simple Factory

Factory Method

Abstract Factory

相关推荐

热门标签

分类

链接表

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏