十三、工厂模式Factory(创建型模式)

一、引子

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

而当把这个暴发户的行为放到我们程序设计中来时,会发现这是一个普遍存在的现象。幸运的是,这种有病的现象在OO(面向对象)语言中可以避免了。下面就以Java语言为基础来引入我们本文的主题:工厂模式。

二、分类

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

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

1)简单工厂模式(Simple Factory)

2)工厂方法模式(Factory Method)

3)抽象工厂模式(Abstract Factory)

这三种模式从上到下逐步抽象,并且更具一般性。

三、工厂模式的使用情景:

1.客户类不关心使用那个具体类,值关系该接口所提供的功能。

2.创建过程比较复杂,例如需初始化其他关联的资源类,读取配置文件等。

3.接口有很多具体实现或抽象类有许多具体子类时候,你可能需要为客户代码写一大串if-else逻辑来决定运行时候使用那个具体实现或者具体子类。

4.不希望给客户暴露过多此类的内部结构,隐藏这些细节可以降低耦合度。

5.优化性能,比如缓存大对象或者初始化比较耗时的对象。

四、简单工厂

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单:定义一个用于创建对象的接口。

先来看看它的组成:

1) 工厂类角色:这是本模式的核心,含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。

2) 抽象产品角色:它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。

3) 具体产品角色:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

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

那么简单工厂模式怎么来使用呢?我们就以简单工厂模式来改造暴发户坐车的方式——现在暴发户只需要坐在车里对司机说句:“开车”就可以了。

抽象产品角色

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 ");

} }

工厂类角色

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();

。。。
}
}
}

程序中各个类的关系表达如下:

这便是简单工厂模式了。怎么样,使用起来很简单吧?那么它带来了什么好处呢?

首先,使用了简单工厂模式后,我们的程序不在“有病”,更加符合现实中的情况;而且客户端免除了直接创建产品对象的责任,而仅仅负责“消费”产品(正如暴发户所为)。

下面我们从开闭原则(对扩展开放;对修改封闭)上来分析下简单工厂模式。当暴发户增加了一辆车的时候,只要符合抽象产品制定的合同,那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说,它是符合开闭原则的;但是工厂部分好像不太理想,因为每增加一辆车,都要在工厂类中增加相应的业务逻辑或者判断逻辑,这显然是违背开闭原则的。可想而知对于新产品的加入,工厂类是很被动的。对于这样的工厂类(在我们的例子中是为司机师傅),我们称它为全能类或者上帝类。

我们举的例子是最简单的情况,而在实际应用中,很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品,所以这可能会把我们的上帝累坏了,也累坏了我们这些程序员:(

于是工厂方法模式作为救世主出现了。

五、工厂方法模式

工厂方法模式去掉了简单工厂模式中工厂方法的静态属性,使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

你应该大致猜出了工厂方法模式的结构,来看下它的组成:

1) 抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

2)具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3)抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

4)具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在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();
                     }
       ……
}

可以看出工厂方法的加入,使得对象的数量成倍增长。当产品种类非常多时,会出现大量的与之对应的工厂对象,这不是我们所希望的。因为如果不能避免这种情况,可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类:即对于产品树上类似的种类(一般是树的叶子中互为兄弟的)使用简单工厂模式来实现。

六、抽象工厂

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

图中的BmwCar和BenzCar就是两个产品树(产品层次结构);而如图所示的BenzSportsCar和BmwSportsCar就是一个产品族。他们都可以放到跑车家族中,因此功能有所关联。同理BmwBussinessCar和BenzSportsCar也是一个产品族。

回到抽象工厂模式的话题上。可以说,抽象工厂模式和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。

抽象工厂模式的用意为:给客户端提供一个接口,可以创建多个产品族中的产品对象

而且使用抽象工厂模式还要满足一下条件:

1)        系统中有多个产品族,而系统一次只可能消费其中一族产品。

2)        同属于同一个产品族的产品以其使用。

来看看抽象工厂模式的各个角色(和工厂方法的如出一辙):

1)        抽象工厂角色: 这是工厂方法模式的核心,它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

2)        具体工厂角色:它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。

3)        抽象产品角色:它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

4)        具体产品角色:具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

类图如下:

产品 Plant接口

public interface Plant { }//标志接口    

具体产品PlantA,PlantB

public class PlantA implements Plant {
public PlantA () {
  System.out.println("create PlantA !");
 }
public void doSomething() {
  System.out.println(" PlantA do something ...");
 }
}
public class PlantB implements Plant {
public PlantB () {
  System.out.println("create PlantB !");
 }      

public void doSomething() {
  System.out.println(" PlantB do something ...");
 }
}    

产品 Fruit接口

public interface Fruit { }      

具体产品FruitA,FruitB

public class FruitA implements Fruit {
public FruitA() {
  System.out.println("create FruitA !");
 }
public void doSomething() {
  System.out.println(" FruitA do something ...");
 }
}   
public class FruitB implements Fruit {
public FruitB() {
  System.out.println("create FruitB !");
 }
public void doSomething() {
  System.out.println(" FruitB do something ...");
 }
}      

抽象工厂

public interface AbstractFactory {
public Plant createPlant();
public Fruit createFruit();
}    

具体工厂方法

public class FactoryA implements AbstractFactory {
public Plant createPlant() {
return new PlantA();
 }
public Fruit createFruit() {
return new FruitA();
 }
}      
public class FactoryB implements AbstractFactory {
public Plant createPlant() {
return new PlantB();
 }
public Fruit createFruit() {
return new FruitB();
 }
}     

测试

public Client {
      public method1() {
             AbstractFactory instance = new FactoryA();
             instance.createPlant();
             instance. createFruit();
       }
}  

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

可以这么说,工厂方法模式是一种极端情况的抽象工厂模式,而抽象工厂模式可以看成是工厂方法模式的一种推广。

(1)、其实工厂方法模式是用来创建一个产品的等级结构的,而抽象工厂模式是用来创建多个产品的等级结构的。工厂方法创建一般只有一个方法,创建一种产品。抽象工厂一般有多个方法,创建一系列产品。

(2)、工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。

简而言之->

工厂方法模式:一个抽象产品类,可以派生出多个具体产品类。

一个抽象工厂类,可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式:多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类,可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

抽象工厂典型代表:Sping IOC容器(Bean工厂)

spring/spring.properties:
VehicleType=spring.Plane
public interface BeanFactory {
   Object getBean(String id);
}
class ClassPathXmlApplicationContext implements BeanFactory {
   Properties properties;
   public ClassPathXmlApplicationContext(String filename) {
      properties = new Properties();
      try {
       properties.load(Test.class.getClassLoader().getResourceAsStream(filename));
      } catch (IOException e) {
        e.printStackTrace();
      }
   }
   @Override
   public Object getBean(String id) {
      String className = properties.getProperty(id);
      try {
        return Class.forName(className).newInstance();
      } catch (Exception e) {
        e.printStackTrace();
        return null;
      }
   }
}
interface Moveable {
   void run();
}
class Car implements Moveable {
   public void run() {
      System.out.println("轿车走了");
   }
}
class Plane implements Moveable {
   @Override
   public void run() {
      System.out.println("飞机飞了");
   }
}
package spring;
public class Test {
   public static void main(String[] args) {
      BeanFactory factory = new ClassPathXmlApplicationContext("spring/spring.properties");
      Moveable m = (Moveable) factory.getBean("VehicleType");
      m.run();
   }
}

七、小结

工厂方法模式仿佛已经很完美的对对象的创建进行了包装,使得客户程序中仅仅处理抽象产品角色提供的接口。那我们是否一定要在代码中遍布工厂呢?大可不必。也许在下面情况下你可以考虑使用工厂方法模式:

1)        当客户程序不需要知道要使用对象的创建过程。

2)        客户程序使用的对象存在变动的可能,或者根本就不知道使用哪一个具体的对象。

简单工厂模式与工厂方法模式真正的避免了代码的改动了?没有。在简单工厂模式中,新产品的加入要修改工厂角色中的判断语句;而在工厂方法模式中,要么将判断逻辑留在抽象工厂角色中,要么在客户程序中将具体工厂角色写死(就象上面的例子一样)。而且产品对象创建条件的改变必然会引起工厂角色的修改。

时间: 2024-10-09 20:12:59

十三、工厂模式Factory(创建型模式)的相关文章

设计模式04: Factory Methord 工厂方法模式(创建型模式)

Factory Methord 工厂方法模式(创建型模式) 从耦合关系谈起耦合关系直接决定着软件面对变化时的行为 -模块与模块之间的紧耦合使得软件面对变化时,相关的模块都要随之变更 -模块与模块之间的松耦合使得软件面对变化时,一些模块更容易被替换或者更改,但其他模块保持不变 对代码的关注要在理解了设计模式之后,对于不同的代码但是解决的是同一类问题,他们就是同一种设计模式.解决了哪一类的问题就是哪一类的设计模式. 软件需求的变化是软件工程的一部分,是我们要解决的问题. 把模块分为主模块.次模块主模

设计模式05: Prototype 原型模式(创建型模式)

Prototype 原型模式(创建型模式) 依赖关系的倒置抽象不应该依赖于实现细节,细节应该依赖于抽象.对所有的设计模式都是这样的. -抽象A直接依赖于实现细节b -抽象A依赖于抽象B,实现细节b依赖于抽象B 动机(Motivation) 在软件工程中,经常面临着“某些结构复杂的对象”的创建工作:由于需求变化,这些对象经常面临着剧烈的变化,但是它们却拥有比较稳定一致的接口. 如何应对这种变化?如何向“客户程序(使用这些对象的程序)”隔离出这些“易变对象”,从而使得“依赖这些易变对象的客户程序”不

设计模式-04 建造者模式(创建型模式)

一 建造者模式 建造者模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象.这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式. 主要解决:在软件系统中,有时候面临着"一个复杂对象"的创建工作,其通常由各个部分的子对象用一定的算法构成:由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定. 关键代码 : 建造者:创建和提供实例,导演:管理建造出来的实例的依赖关系. 使用场景: 汽车有很多部件,车轮

大话设计之模式总结——创建型模式

设计模式程序员的的帮助是非常之大的,是编程的武器,是升职加薪的利器!对于 大多数人初学者,设计模式是个非常抽象的概念,在没有学习设计模式之前,认为代码无错便是优.但当你在程序员的这条路上越走越远时,你已经不知不觉得在实践设计模式了.设计模式向世人传达了一个信息:编程不仅仅是一门技术,更加是一门艺术! 设计模式可以分三个大类:创建型模式,结构性模式,行为型模式. 今天想给大家讲的是创建型模式,创建型模式隐藏了类的实例是如何被创建和放在一起的,整个系统关于这些对象所知道的是由抽象类所定义的接口.这样

设计模式03: Builder 生成器模式(创建型模式)

Builder生成器模式(创建型模式) Builder模式缘起假设创建游戏中的一个房屋House设施,该房屋的构建由几个部分组成,且各个部分富于变化.如果使用最直观的设计方法,每个房屋部分的变化,都将导致房屋构建的重新修正... 动机(Motivation)在软件系统中,有时候面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成:由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将他们组合在一起的算法却非常稳定.如何应对这种变化?如何提供一种“封装机制”来隔离

设计模式-05 原型模式(创建型模式)

一 原型模式 原型模式是用于创建重复的对象,同时又能保证性能. 原型模式用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象. 主要解决: 利用已有的一个原型对象,快速地生成和原型对象一样的实例 关键代码 : 实现克隆操作,在 JAVA 继承 Cloneable,重写 clone() 使用场景: 类初始化需要消化非常多的资源,这个资源包括数据.硬件资源等. 类图: 原型模式主要用于对象的复制,它的核心是就是类图中的原型类Prototype.Prototype类需要具备以下两个条件: 实现

设计模式读书笔记-单件模式(创建型模式)

让一个类只有一个对象,全局唯一 非多线程模式,实现方法: 方法1: 1 public class SingletonTest 2 { 3 public static readonly SingletonTest Instance = new SingletonTest(); 4 private SingletonTest() { } 5 } 方法2: 1 public class SingletonTest 2 { 3 public static readonly SingletonTest I

设计模式--工厂模式(创建型)

工厂模式属于创建型模式,分为三类,简单工厂模式.工厂方法模式.抽象工厂模式. 一.简单工厂模式 在工厂中做判断,根据产品类型从而创造相应的产品,当增加新产品时需要修改工厂类. 例如: enum CTYPE {COREA, COREB}; class SingleCore { public: virtual void Show() = 0; }; //单核A class SingleCoreA: public SingleCore { public: void Show() { cout<<&q

一起来学设计模式-----创建型模式之简单工厂

一直都特别想整体学习下设计模式,之前总觉得不是时候,觉得基础不够好怕吸收不了,或者体会不到设计模式带来的便利.就在上半年的KPI编写测试桩项目中,我就深刻的感受到设计模式带来的好处.一般测试人员写的代码不是很多,很多时候写代码也都是基于解决问题的逻辑来的,写的代码面向过程思路较多,因此代码的冗余度特别大.在编写一个大的测试工具时,就更应该考虑这方面的问题自己是否存在.刻不容缓的学习起了设计模式,整理就从创建型模式的工厂模式开始入手吧. 创建型模式,共三种:工厂方法模式.建造者模式.原型模式.其中

设计模式——创建型模式

简单的说我们可以把23种设计模式可以归为三大类,分别是创建型模式.结构型模式和行为型模式. 今天,首先看一下创建型模式.创建型设计模式包括5种:单例模式(Singleton).工厂方法模式(Factory Method).抽象工厂模式(Abstract Factory).建造者模式(Builder).原型模式(Prototype).  1.单例模式(Singleton)        1)简介 保证一个类仅有一个实例,并提供一个访问它的全局访问点. 单例模式是一种常用的软件设计模式.在它的核心结