java设计模式之工厂模式

点击上方“JAVA乐园”，选择“置顶公众号”

有内涵有价值的文章第一时间送达！

1、简单工厂模式

一个栗子： 
我喜欢吃面条，抽象一个面条基类，(接口也能够)，这是产品的抽象类。

public abstract class INoodles {      //描述每种面条啥样的   
    public abstract void desc(); }

先来一份兰州拉面（具体的产品类）：

public class LzNoodles extends INoodles {    @Override    
    public void desc() {        System.out.println("兰州拉面 上海的好贵 家里才5 6块钱一碗");    } }

程序员加班必备也要吃泡面（具体的产品类）：

public class PaoNoodles extends INoodles {    @Override    
    public void desc() {        System.out.println("泡面好吃 可不要贪杯");    } }

还有我最爱吃的家乡的干扣面（具体的产品类）：

public class GankouNoodles extends INoodles {    @Override    
    public void desc() {        System.out.println("仍是家里的干扣面好吃 6块一碗");    } }

准备工做作完了，咱们来到一家“简单面馆”（简单工厂类），菜单以下：

public class SimpleNoodlesFactory {    
    public static final int TYPE_LZ = 1;//兰州拉面
    public static final int TYPE_PM = 2;//泡面
    public static final int TYPE_GK = 3;//干扣面

    public static INoodles createNoodles(int type) {        switch (type) {            
       case TYPE_LZ:                
          return new LzNoodles();            
       case TYPE_PM:                
          return new PaoNoodles();            
      case TYPE_GK:            
      default:                
          return new GankouNoodles();        }    } }

简单面馆就提供三种面条（产品），你说你要啥，他就给你啥。这里我点了一份干扣面:

// 简单工厂模式 INoodles noodles = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_GK); noodles.desc();

输出：

仍是家里的干扣面好吃 6块一碗

特色

1 它是一个具体的类，非接口 抽象类。有一个重要的create()方法，利用if或者 switch建立产品并返回。

2 create()方法一般是静态的，因此也称之为静态工厂。

缺点

1 扩展性差（我想增长一种面条，除了新增一个面条产品类，还须要修改工厂类方法）

2 不一样的产品须要不一样额外参数的时候 不支持。

 2、工厂方法模式

1.模式描述

提供一个用于建立对象的接口(工厂接口)，让其实现类(工厂实现类)决定实例化哪个类(产品类)，而且由该实现类建立对应类的实例。

2.模式做用

能够必定程度上解耦，消费者和产品实现类隔离开，只依赖产品接口(抽象产品)，产品实现类如何改动与消费者彻底无关。

能够必定程度增长扩展性，若增长一个产品实现，只须要实现产品接口，修改工厂建立产品的方法，消费者能够无感知（若消费者不关心具体产品是什么的状况）。
能够必定程度增长代码的封装性、可读性。清楚的代码结构，对于消费者来讲不多的代码量就能够完成不少工做。
等等。//TODO
另外，抽象工厂才是实际意义的工厂模式，工厂方法只是抽象工厂的一个比较常见的状况。

3.适用场景

消费者不关心它所要建立对象的类(产品类)的时候。

消费者知道它所要建立对象的类(产品类)，但不关心如何建立的时候。

等等。//TODO

例如：hibernate里经过sessionFactory建立session、经过代理方式生成ws客户端时，经过工厂构建报文中格式化数据的对象。

4.模式要素

提供一个产品类的接口。产品类均要实现这个接口(也能够是abstract类，即抽象产品)。
提供一个工厂类的接口。工厂类均要实现这个接口(即抽象工厂)。
由工厂实现类建立产品类的实例。工厂实现类应有一个方法，用来实例化产品类。

5.类图

6.模式实例代码

工厂：

package com.demoFound.factoryMethod.factory;    import com.demoFound.factoryMethod.message.IMyMessage;    /** * 工厂方法模式_工厂接口 *   * @author popkidorc *   */  
public interface IMyMessageFactory {        public IMyMessage createMessage(String messageType);   }  

package com.demoFound.factoryMethod.factory;  import java.util.HashMap;  
import java.util.Map;  import com.demoFound.factoryMethod.message.IMyMessage; 
import com.demoFound.factoryMethod.message.MyMessageEmail; import com.demoFound.factoryMethod.message.MyMessageOaTodo; import com.demoFound.factoryMethod.message.MyMessageSms;    /** * 工厂方法模式_工厂实现 * @author popkidorc *   */  
public class MyMessageFactory implements IMyMessageFactory {        @Override      public IMyMessage createMessage(String messageType) {          // 这里的方式是：消费者知道本身想要什么产品；若生产何种产品彻底由工厂决定，则这里不该该传入控制生产的参数。          IMyMessage myMessage;          Map<String, Object> messageParam = new HashMap<String, Object>();          // 根据某些条件去选择究竟建立哪个具体的实现对象，条件能够传入的，也能够从其它途径获取。          // sms  
        if ("SMS".equals(messageType)) {              myMessage = new MyMessageSms();              messageParam.put("PHONENUM", "123456789");          } else  
        // OA待办  
        if ("OA".equals(messageType)) {              myMessage = new MyMessageOaTodo();              messageParam.put("OAUSERNAME", "testUser");          } else  
        // email  
        if ("EMAIL".equals(messageType)) {              myMessage = new MyMessageEmail();              messageParam.put("EMAIL", "test@test.com");          } else  
        // 默认生产email这个产品          {              myMessage = new MyMessageEmail();              messageParam.put("EMAIL", "test@test.com");          }          myMessage.setMessageParam(messageParam);          return myMessage;      }   } 

产品：

package com.demoFound.factoryMethod.message;    import java.util.Map;    /** * 工厂方法模式_产品接口 *   * @author popkidorc *   */  
public interface IMyMessage {        public Map<String, Object> getMessageParam();        public void setMessageParam(Map<String, Object> messageParam);        public void sendMesage() throws Exception;// 发送通知/消息    }  

package com.demoFound.factoryMethod.message;    import java.util.Map;    /** * 工厂方法模式_虚拟产品类 *   * @author popkidorc *   */  
public abstract class MyAbstractMessage implements IMyMessage {        private Map<String, Object> messageParam;// 这里能够理解为生产产品所须要的原材料库。最好是个自定义的对象，这里为了避免引发误解使用Map。        @Override      public Map<String, Object> getMessageParam() {          return messageParam;      }        @Override      public void setMessageParam(Map<String, Object> messageParam) {          this.messageParam = messageParam;      }   }  

package com.demoFound.factoryMethod.message;    /** * 工厂方法模式_email产品 *   * @author popkidorc *   */  
public class MyMessageEmail extends MyAbstractMessage {        @Override      public void sendMesage() throws Exception {          // TODO Auto-generated method stub  
        if (null == getMessageParam() || null == getMessageParam().get("EMAIL")                  || "".equals(getMessageParam().get("EMAIL"))) {              throw new Exception("发送短信,须要传入EMAIL参数");// 为了简单起见异常也不自定义了  
        }// 另外邮件内容，以及其余各类协议参数等等都要处理            System.out.println("我是邮件，发送通知给" + getMessageParam().get("EMAIL"));      }     }  

package com.demoFound.factoryMethod.message;    /** * 工厂方法模式_oa待办产品 *   * @author popkidorc *   */  
public class MyMessageOaTodo extends MyAbstractMessage {        @Override      public void sendMesage() throws Exception {          // TODO Auto-generated method stub  
        if (null == getMessageParam()                  || null == getMessageParam().get("OAUSERNAME")                  || "".equals(getMessageParam().get("OAUSERNAME"))) {              throw new Exception("发送OA待办,须要传入OAUSERNAME参数");// 为了简单起见异常也不自定义了  
        }// 这里的参数需求就比较多了不一一处理了            System.out                  .println("我是OA待办，发送通知给" + getMessageParam().get("OAUSERNAME"));      }     }  

package com.demoFound.factoryMethod.message;    /** * 工厂方法模式_sms产品 *   * @author popkidorc *   */  
public class MyMessageSms extends MyAbstractMessage {        @Override      public void sendMesage() throws Exception {          // TODO Auto-generated method stub  
        if (null == getMessageParam()                  || null == getMessageParam().get("PHONENUM")                  || "".equals(getMessageParam().get("PHONENUM"))) {              throw new Exception("发送短信,须要传入PHONENUM参数");// 为了简单起见异常也不自定义了  
        }// 另外短信信息，以及其余各类协议参数等等都要处理            System.out.println("我是短信，发送通知给" + getMessageParam().get("PHONENUM"));      }     } 

消费者：

package com.demoFound.factoryMethod;  import com.demoFound.factoryMethod.factory.IMyMessageFactory; import com.demoFound.factoryMethod.factory.MyMessageFactory; import com.demoFound.factoryMethod.message.IMyMessage;    /** * 工厂方法模式_消费者类 *   * @author popkidorc *   */  
public class MyFactoryMethodMain {        public static void main(String[] args) {          IMyMessageFactory myMessageFactory = new MyMessageFactory();          IMyMessage myMessage;          // 对于这个消费者来讲，不用知道如何生产message这个产品，耦合度下降  
        try {              // 先来一个短信通知  
            myMessage = myMessageFactory.createMessage("SMS");              myMessage.sendMesage();                // 来一个oa待办  
            myMessage = myMessageFactory.createMessage("OA");              myMessage.sendMesage();                // 来一个邮件通知  
            myMessage = myMessageFactory.createMessage("EMAIL");              myMessage.sendMesage();          } catch (Exception e) {              e.printStackTrace();          }      }   }  

3、抽象工厂模式

定义：为建立一组相关或相互依赖的对象提供一个接口，并且无需指定他们的具体类。

类型：建立类模式

类图：

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

        抽象工厂模式是工厂方法模式的升级版本，他用来建立一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，一般一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的全部产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不一样的接口或抽象类。

        在抽象工厂模式中，有一个产品族的概念：所谓的产品族，是指位于不一样产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品就组成一个产品族；而工厂方法提供的一系列产品称为一个等级结构。咱们依然拿生产汽车的例子来讲明他们之间的区别。

        在上面的类图中，两厢车和三厢车称为两个不一样的等级结构；而2.0排量车和2.4排量车则称为两个不一样的产品族。再具体一点，2.0排量两厢车和2.4排量两厢车属于同一个等级结构，2.0排量三厢车和2.4排量三厢车属于另外一个等级结构；而2.0排量两厢车和2.0排量三厢车属于同一个产品族，2.4排量两厢车和2.4排量三厢车属于另外一个产品族。

        明白了等级结构和产品族的概念，就理解工厂方法模式和抽象工厂模式的区别了，若是工厂的产品所有属于同一个等级结构，则属于工厂方法模式；若是工厂的产品来自多个等级结构，则属于抽象工厂模式。在本例中，若是一个工厂模式提供2.0排量两厢车和2.4排量两厢车，那么他属于工厂方法模式；若是一个工厂模式是提供2.4排量两厢车和2.4排量三厢车两个产品，那么这个工厂模式就是抽象工厂模式，由于他提供的产品是分属两个不一样的等级结构。固然，若是一个工厂提供所有四种车型的产品，由于产品分属两个等级结构，他固然也属于抽象工厂模式了。

抽象工厂模式代码

interface IProduct1 {      public void show();   }  interface IProduct2 {      public void show();   }  
class Product1 implements IProduct1 {      public void show() {          System.out.println("这是1型产品");      }   }  

class Product2 implements IProduct2 {      public void show() {          System.out.println("这是2型产品");      }   }    interface IFactory {      public IProduct1 createProduct1();      public IProduct2 createProduct2();   }  class Factory implements IFactory{      public IProduct1 createProduct1() {          return new Product1();      }      public IProduct2 createProduct2() {          return new Product2();      }   }    public class Client {      public static void main(String[] args){          IFactory factory = new Factory();          factory.createProduct1().show();          factory.createProduct2().show();      }   } 

抽象工厂模式的优势

        抽象工厂模式除了具备工厂方法模式的优势外，最主要的优势就是能够在类的内部对产品族进行约束。所谓的产品族，通常或多或少的都存在必定的关联，抽象工厂模式就能够在类内部对产品族的关联关系进行定义和描述，而没必要专门引入一个新的类来进行管理。

抽象工厂模式的缺点

       产品族的扩展将是一件十分费力的事情，假如产品族中须要增长一个新的产品，则几乎全部的工厂类都须要进行修改。因此使用抽象工厂模式时，对产品等级结构的划分是很是重要的。

 

适用场景

       当须要建立的对象是一系列相互关联或相互依赖的产品族时，即可以使用抽象工厂模式。说的更明白一点，就是一个继承体系中，若是存在着多个等级结构（即存在着多个抽象类），而且分属各个等级结构中的实现类之间存在着必定的关联或者约束，就可使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行建立，则更合适一点。

 

总结

       不管是简单工厂模式，工厂方法模式，仍是抽象工厂模式，他们都属于工厂模式，在形式和特色上也是极为类似的，他们的最终目的都是为了解耦。在使用时，咱们没必要去在乎这个模式到底工厂方法模式仍是抽象工厂模式，由于他们之间的演变经常是使人琢磨不透的。常常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，因为类中的产品构成了不一样等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减小一个方法使的提供的产品再也不构成产品族以后，它就演变成了工厂方法模式。

       因此，在使用工厂模式时，只须要关心下降耦合度的目的是否达到了。 

class Engine {      public void getStyle(){          System.out.println("这是汽车的发动机");      }   }  class Underpan {      public void getStyle(){          System.out.println("这是汽车的底盘");      }   }  class Wheel {      public void getStyle(){          System.out.println("这是汽车的轮胎");      }   }  public class Client {      public static void main(String[] args) {          Engine engine = new Engine();          Underpan underpan = new Underpan();          Wheel wheel = new Wheel();          ICar car = new Car(underpan, wheel, engine);          car.show();      }   } 

看到这里了，不关注一下么

JAVA乐园

一码不扫，何扫天下

推荐阅读

• SVN多版本库环境的搭建
  

• 利用Sharding-Jdbc实现分表
  

• 各类技术视频
  

更多精彩文章，请点击下方：阅读原文

本文分享自微信公众号 - JAVA乐园（happyhuangjinjin88）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。