【设计模式】工厂模式（静态工厂模式、工厂方法模式、抽象工厂模式）

时间 2019-11-06

原文原文链接

引子

话说十年前，有一个暴发户，他家有三辆汽车——Benz 奔驰、Bmw 宝马、Audi 奥迪，还雇了司机为他开车。不过，暴发户坐车时老是怪怪的： Benz 车后跟司机说“开奔驰车！上”，坐上 Bmw 后他说“开宝马车！”，坐上 Audi 说“开奥迪车！”。你必定说：这人有病！直接说开车不就好了？！html

而当把这个暴发户的行为放到咱们程序设计中来时，会发现这是一个广泛存在的现象。java

幸运的是，这种有病的现象在 OO（面向对象）语言中能够避免了。设计模式

下面就以 Java 语言为基础来引入咱们的主题：工厂模式。ide

工厂模式主要是为建立对象提供过渡接口，以便将建立对象的具体过程屏蔽隔离起来，达到提升灵活性的目的。spa

工厂模式在《Java 与模式》中分为三类：

简单工厂模式（Simple Factory）
工厂方法模式（Factory Method）
抽象工厂模式（Abstract Factory）

这三种模式从上到下逐步抽象，而且更具通常性。

GOF 在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，二者归为一类。

下面来看看这些工厂模式是怎么来“治病”的。

简单工厂模式

简单工厂模式又称静态工厂方法模式。

重命名上就能够看出这个模式必定很简单。它存在的目的很简单： 定义一个用于建立对象的接口 。

先来看看它的组成：

工厂类角色：这是本模式的核心，含有必定的商业逻辑和判断逻辑。在java中它每每由一个具体类实现。
抽象产品角色：它通常是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
具体产品角色：工厂类所建立的对象就是此角色的实例。在java中由一个具体类实现。用类图来清晰的表示下的它们之间的关系

那么简单工厂模式怎么来使用呢？设计

咱们就以简单工厂模式来改造暴发户坐车的方式——如今暴发户只须要坐在车里对司机说句：“开车”就能够了code

//抽象产品角色
public interface Car{
    public void drive();
}

//具体产品角色
public class Benz implements Car{
    public void drive() {
          System.out.println("Driving Benz ");
    }
}
public class Bmw implements Car{
    public void drive() {
          System.out.println("Driving Bmw ");
    }
}

//工厂类角色
public class Driver{
    //工厂方法.注意 返回类型为抽象产品角色
    public static Car driverCar(String s)throws Exception{
        //判断逻辑，返回具体的产品角色给 Client
         if(s.equalsIgnoreCase("Benz"))
               return new Benz();
         else if(s.equalsIgnoreCase("Bmw"))
               return new Bmw();
                ......
         else throw new Exception();
        。。。
    }
}

//欢迎暴发户出场......
public class Magnate{
    public static void main(String[] args){
       try{
           //告诉司机我今天坐奔驰
           Car car = Driver.driverCar("benz");
           //下命令：开车
           car.drive();
           。。。
        }
    }
}

View Code

　　将本程序空缺的其余信息填充完整后便可运行。htm

　　程序中各个类的关系表达以下：对象

　　这即是简单工厂模式了。blog

　　那么它带来了什么好处呢？

首先，使用了简单工厂模式后，咱们的程序不在“有病”，更加符合现实中的状况；
并且客户端免除了直接建立产品对象的责任，而仅仅负责“消费”产品（正如暴发户所为）

　　下面咱们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。

当暴发户增长了一辆车的时候，只要符合抽象产品制定的合同，那么只要通知工厂类知道就能够被客户使用了。因此对产品部分来讲，它是符合开闭原则的；
可是工厂部分好像不太理想，由于每增长一辆车，都要在工厂类中增长相应的业务逻辑或者判断逻辑，这显然是违背开闭原则的。
可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类（例子中是为司机师傅），咱们称它为全能类或者上帝类。

　　在实际应用中，极可能产品是一个多层次的树状结构。
　　因为简单工厂模式中只有一个工厂类来对应这些产品，因此这可能会把咱们的上帝累坏了，因而工厂方法模式做为救世主出现了。

工厂方法模式

　　工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它能够被子类继承。这样在简单工厂模式里集中在工厂方法上的压力能够由工厂方法模式里不一样的工厂子类来分担。
　　工厂方法模式的结构，来看下它的组成：

抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在 java 中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以建立对应的具体产品的对象。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在 java 中通常有抽象类或者接口来实现。
具体产品角色：具体工厂角色所建立的对象就是此角色的实例。在 java 中由具体的类来实现。

　　用类图来清晰的表示下的它们之间的关系：

　　工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。

　　正如上面所说，这样便分担了对象承受的压力；并且这样使得结构变得灵活起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就能够被客户使用，而没必要去修改任何已有的代码。能够看出工厂角色的结构也是符合开闭原则的！

　　来看看工厂方法模式各个角色之间是如何来协调的。
　　话说暴发户生意越作越大，本身的爱车也愈来愈多。这可苦了那位司机师傅了，什么车它都要记得，维护，都要通过他来使用！因而暴发户同情他说：看你跟我这么多年的份上，之后你不用这么辛苦了，我给你分配几我的手，你只管管好他们就好了！因而，工厂方法模式的管理出现了。

//抽象产品角色，具体产品角色与简单工厂模式相似，只是变得复杂了些，略。
//抽象工厂角色
public interface Driver{
    public Car driverCar();
}
public class BenzDriver implements Driver{
    public Car driverCar(){
          return new Benz();
    }
}
public class BmwDriver implements Driver{
    public Car driverCar() {
          return new Bmw();
    }
}
//应该和具体产品造成对应关系...

//有请暴发户先生
public class Magnate

{
    public static void main(String[] args)
    {
        try{
              Driver driver = new BenzDriver();
              Car car = driver.driverCar();
              car.drive();
        }
    ……
}

View Code

　　能够看出工厂方法的加入，使得对象的数量成倍增加。

　　当产品种类很是多时，会出现大量的与之对应的工厂对象，这不是咱们所但愿的。

　　由于若是不能避免这种状况，能够考虑使用简单工厂模式与工厂方法模式相结合的方式来减小工厂类：即对于产品树上相似的种类（通常是树的叶子中互为兄弟的）使用简单工厂模式来实现。

小结

　　工厂方法模式仿佛已经很完美的对对象的建立进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口。

　　那咱们是否必定要在代码中遍及工厂呢？大可没必要。也许在下面状况下你能够考虑使用工厂方法模式：

当客户程序不须要知道要使用对象的建立过程。
客户程序使用的对象存在变更的可能，或者根本就不知道使用哪个具体的对象。

　　简单工厂模式与工厂方法模式真正的避免了代码的改动了？没有。

在简单工厂模式中，新产品的加入要修改工厂角色中的判断语句；
而在工厂方法模式中，要么将判断逻辑留在抽象工厂角色中，要么在客户程序中将具体工厂角色写死。并且产品对象建立条件的改变必然会引发工厂角色的修改。面对这种状况，Java 的反射机制与配置文件的巧妙结合突破了限制——这在 Spring 中完美的体现了出来。

抽象工厂模式

　　先来认识下什么是产品族：位于不一样产品等级结构中，功能相关联的产品组成的家族。
　　仍是让咱们用一个例子来形象地说明一下吧。

　　图中的BmwCar和BenzCar就是两个产品树（产品层次结构）
　　而如图所示的；
　　BenzSportsCar和BmwSportsCar就是一个产品族。他们均可以放到跑车家族中，所以功能有所关联。

　　同理BmwBussinessCar和BenzSportsCar也是一个产品族。
　　回到抽象工厂模式的话题上。
　　能够说，抽象工厂模式和工厂方法模式的区别就在于须要建立对象的复杂程度上。并且抽象工厂模式是三个里面最为抽象、最具通常性的。

　　抽象工厂模式的用意为：给客户端提供一个接口，能够建立多个产品族中的产品对象

　　并且使用抽象工厂模式还要知足一下条件：

系统中有多个产品族，而系统一次只可能消费其中一族产品。
同属于同一个产品族的产品以其使用。

　　来看看抽象工厂模式的各个角色（和工厂方法的一模一样）：

抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以建立对应的具体产品的对象。在java中它由具体的类来实现。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中通常有抽象类或者接口来实现。
具体产品角色：具体工厂角色所建立的对象就是此角色的实例。在java中由具体的类来实现。

　　对应类图

　　关于抽象工厂模式的demo以前有发过：http://www.cnblogs.com/lcw/p/3540998.html

@成鹏致远

（blogs：lcw.cnblogs.com）

（email：wwwlllll@126.com）

（qq：552158509）