创建型模式—抽象工厂模式

抽象工厂（Abstract Factory）模式意图：为创建一组相关或相互依赖对象提供了一个接口，而且无需指定它们的具体类。

抽象工厂可以向客户提供一个接口，是客户可以在不必指定产品具体类型的情况下，创建多个产品家族中的产品对象，它强调的“系列对象”的变化。

在抽象工厂模式中，产品的创建由ConcreteFactory来完成，从结构图中可以看出，抽象工厂模式的ConcreteFactory不是负责一种具体Product的创建，而是负责一个Product族的创建。

◊ 隔离了具体类的生成，客户不需要知道怎样生成每一个具体Product，什么时间生成的。它将客户与具体的类分离，依赖于抽象类，耦合性低。

◊ 一个产品族中的多个对象设计成一起工作，它能保证客户端始终只使用一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说是非常实用的一种设计模式。

◊ 有利于更换产品系列，由于客户端只依赖于抽象类，更换产品系列时，只需要更改一下具体工厂名就可以。

◊ 难以支持新种类的产品，这是因为抽象工厂接口确定了可以被创建的产品集合，支持新种类的产品就需要扩展该工厂接口，这将引起抽象工厂类及其所有子类的改变。

结构图

支付接口使用抽象工厂模式结构图

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    /// <summary>
    /// 定义支付接口
    /// </summary>
    public interface IPay
    {
        bool Excute();
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    /// <summary>
    /// 支付具体实现
    /// </summary>
    public class Alipay : IPay
    {
        public bool Excute()
        {
            //执行支付宝付款操作
            return true;
        }
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    /// <summary>
    /// 支付具体实现
    /// </summary>
    public class Wechat : IPay
    {
        public bool Excute()
        {
            //执行微信付款操作;
            return true;
        }
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    /// <summary>
    /// 支付之后处理接口
    /// </summary>
    public interface IPayAfter
    {
        bool Excute();
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    public class AlipayPayAfter : IPayAfter
    {
        public bool Excute()
        {
            //支付宝支付成功后处理
            return true;
        }
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    public class WechatPayAfter : IPayAfter
    {
        public bool Excute()
        {
            //微信支付成功后处理
            return true;
        }
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    /// <summary>
    /// 抽象工厂方法抽象类
    /// </summary>
    public abstract class AbstractFactory
    {
        public abstract IPay CreatePay();

        public abstract IPayAfter PayAfter();
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    /// <summary>
    /// 抽象工厂方法实现
    /// </summary>
    public class AlipayFactory : AbstractFactory
    {
        public override IPay CreatePay()
        {
            return new Alipay();
        }

        public override IPayAfter PayAfter()
        {
            return new AlipayPayAfter();
        }
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    /// <summary>
    /// 抽象工厂方法实现
    /// </summary>
    public class WechatFactory : AbstractFactory
    {
        public override IPay CreatePay()
        {
            return new Wechat();
        }

        public override IPayAfter PayAfter()
        {
            return new WechatPayAfter();
        }
    }
}

namespace Libraries.Test.DesignPattern.AbstractFactory
{
    public class Client
    {
        public void Excute()
        {
            //微信付款
            AbstractFactory wechatFactory = new WechatFactory();
            IPay wechatPay = wechatFactory.CreatePay();
            bool result = wechatPay.Excute();
            //支付成功处理
            IPayAfter wechatPayAfter = wechatFactory.PayAfter();
            result = wechatPayAfter.Excute();

            //支付宝付款
            AbstractFactory alipayFactory = new AlipayFactory();
            IPay alipayPay = alipayFactory.CreatePay();
            result = alipayPay.Excute();
            //支付成功处理
            IPayAfter alipayPayAfter = alipayFactory.PayAfter();
            result = alipayPayAfter.Excute();
        }
    }
}

抽象工厂模式与工厂方法模式区别：

◊ 工厂方法模式只有一个抽象产品类，而抽象工厂模式可以有多个抽象产品类。

◊ 工厂方法模式针对一个产品等级结构，可以派生出多个具体产品类；抽象工厂模式针对面向多个产品等级结构，每个抽象产品类可以派生出多个具体产品类。