设计模式之抽象工厂

上一篇我们学习了简单工厂，知道简单工厂是创建不同类的地方，那么这些工厂是如何创建得呢？随着我们业务逻辑的增加，可能需要好多这种简单工厂，我们不可能每一个都去主动创建，虽然说这样也可以实现，但是却不优雅而且后期维护者分不清修改重点，导致牵一发而动全身。

接下来学习如何创建通过一种方式去创建简单工厂，那么即使需要很多工厂，也可以通过这种方式去创建，减少代码的耦合，使其内聚性更高。

抽象工厂与工厂方法都为了解决接口选择问题，但是实现上，抽象工厂是一个中心工厂，用于创建其它工厂的模式。

不同的实现服务(类/server)在部分方法上是不同的，因此需要做一个接口适配，这个适配类就相当于工厂中的工厂，用于创建把不同的服务抽象为统一的接口做相同的业务。

demo

业务：

假定现在目前有两个物流公司a,b，他们都有发货，取货的业务，同时公司a,b都可以自主的去进行各自不同种类的发货和取货，也就是说可以自定义。如果这有这两个公司那么很简单，我们可以使用简单工厂，新创建两个工厂就可以解决，但是如果是10个或者50个公司，那么我们创建工厂就有点不合适，这个时候就得使用抽象工厂。

抽象工厂

定义的抽象工厂都是抽象类，定义了发货，取货的抽象方法，返回的也是抽象类。

    /// <summary>
    /// 抽象工厂
    /// </summary>
    public abstract class abstractfactory
    {
        /// <summary>
        /// 发货
        /// </summary>
        /// <returns></returns>
        public abstract asendgood sendgood();

        /// <summary>
        /// 收货
        /// </summary>
        /// <returns></returns>
        public abstract agetgood getgood();
    }

    /// <summary>
    /// 取货 抽象类
    /// </summary>
    public abstract class agetgood
    {
        public abstract void getgood();
    }
    
    /// <summary>
    /// 发货 抽象类
    /// </summary>
    public abstract class asendgood
    {        
        public abstract  void sendgood();
    }

    /// <summary>
    /// 公司a抽象工厂
    /// </summary>
    public class companyaabstractfactory : abstractfactory
    {
        public override agetgood getgood()
        {
            return new companyagetgood();
        }

        public override asendgood sendgood()
        {
            return new companyasendgood();
        }
    }

    /// <summary>
    /// 公司b的抽象工厂
    /// </summary>
    public class companybabstractfactory : abstractfactory
    {
        public override agetgood getgood()
        {
            return new companybgetgood();
        }

        public override asendgood sendgood()
        {
            return new companybsendgood();
        }
    }

    public class companyagetgood : agetgood
    {
        public override void getgood()
        {
            console.writeline("公司a 取货");
        }
    }
    
    public class companyasendgood : asendgood
    {
        public override void sendgood()
        {
            console.writeline("公司a 发货");
        }
    }

    class companybgetgood : agetgood
    {
        public override void getgood()
        {
            console.writeline("公司b 取货");
        }
    }
    class companybsendgood : asendgood
    {
        public override void sendgood()
        {
            console.writeline("公司b 发货");
        }
    }    

定义完抽象工厂及各自的抽象类，接下来就是调用了。

        static void main(string[] args)
        {
            debug.writeline("利用抽象工厂来实现物流公司a,b各自的发货和取货");
            //公司a
            abstractfactory acompanyfactory = new companyaabstractfactory();
            agetgood getgood = acompanyfactory.getgood();
            getgood.getgood();

            asendgood sendgood = acompanyfactory.sendgood();
            sendgood.sendgood();
            //公司b
            abstractfactory bcompanyfactory = new companybabstractfactory();
            getgood = bcompanyfactory.getgood();
            getgood.getgood();

            sendgood = bcompanyfactory.sendgood();
            sendgood.sendgood();
            console.readkey();
        }

可以通过上面的图片看到运行后显示出了各自公司的取货和发货内容。其实对于各自物流公司来说，他们根本就不关心具体的取货和发货流程，只是给出动作，那么抽象工厂就会自动去找对应的实现来进行执行。

抽象工厂模式：提供一个创建产品的接口来负责创建相关或依赖的对象，而不具体明确指定具体类

抽象工厂的好处

• 将产品的创建转移到具体工厂的子类中，将对象的创建封装起来，减少客户端与具体产品类之间的依赖。
• 减低系统耦合度，有利于扩展和后期维护。

对于抽象工厂来说，理解起来还是很抽象的，只有自己动手敲一遍才能更好的熟悉和运用。但是要使用的话还是得找到具体符合它的业务场景才行，有时候不要为了设计而设计，合理运用即可。

小寄语

一个人的奋斗，像怀孕一样，日子久了，总会被看出来的。

人生短暂，我不想去追求自己看不见的，我只想抓住我能看的见的。

我是哉说，感谢您的阅读，如果对你有帮助，麻烦点赞，转发 谢谢。