个人GOF23之工厂模式

个人GOF23之工厂模式

写在最前面

做为一个电气工程师，研究等离子体方向，最近在自学设计模式，此为整理博客。设计模式能够分为三大类，分别是建立型设计模式、行为型设计模式以及结构型设计模式。

工厂模式是建立型的设计模式的一种。
先看工厂方法模式，并不那么能“顾名思义”，诚然，我能够揣测是用工厂来创造对象，可是这不免会跟IoC等概念混淆，而且若是按较为官方的定义：Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses. 工厂方法模式是定义接口，而让子类来决定实例化哪一个类；工厂方法让类的实例化延迟到其子类。那按这个指导思想，工厂方法好像没有那么多条条框框了，试实现之。

心法：
万事万物皆对象，万事万物皆产品！

工厂方法模式

再也不new了！让工厂去new吧！使用工厂生产同一类产品！

• 定义产品接口

  public interface Product{
      void operation();
  }

• 产品实现类

  public class ProductA implements Product{
      private String name;
      private int size;
      
      @Override
      void operation(){
          System.out.println("这是产品A");
      }
  }

public class ProductB implements Product{
    private String name;
    private int size;
    
    @Override
    void operation(){
        System.out.println("这是产品B");
    }
}

• 抽象工厂方法类

  public abstract class AbstractFactory{
      public abstract <T extends Product> T createProduct(Class<T> c);
  }

• 具体工厂实现类

  public class ConcreteFactory extends AbstractFactory{
      @Override
      public <T extends Product> T createProduct(Class c){
          Product product = null;
          try{
              product = (T) c.newInstance();
          } catch (Exception e){
              System.out.println("生产产品失败");
          }
          return (T)product;
      }
  }

• 调用方Client类

  public class Client{
      public static void main(String[] args){
          AbstractFactory factory = new ConcreteFactory();
          Product productA = factory.createProduct(ProductA.class);
          productA.operation();
          
          Product productB = factory.createProduct(ProductB.class);
          productB.operation();
      }
  }

工厂方法的变形：简单工厂或静态工厂模式

• 去掉抽象类AbstractFactory,在工厂类中提供一个静态方法返回产品

  public class SimpleFactory{
      public static <T extends Product> T createProduct(Class c){
          Product product = null;
          try {
              product = (T) c.newInstance();
          } catch (Exception e){
              System.out.println("生产产品失败");
              e.printStackTrace();
          }
          return (T) product;
      }
  }

• 修改Client类中的调用方式

  public class Client{
      public static void main(String[] args){
          Product productA = SimpleFactory.createProduct(ProductA.class);
          productA.operation();
          
          Product productB = SimpleFactory.createProduct(ProductB.class);
          productB.operation();
      }
  }

升级为多个工厂类

• 针对每一类产品提供一个工厂类来生产产品,uml图为：
  

• 抽象工厂方法类

  public abstract class AbstractFactory{
      public abstract Product createProduct();
  }

• ProductAFactory

  public class ProductAFactory extends AbstractFactory{
      @Override
      public Product createProduct(){
          return new ProductB();
      }
  }

• ProductBFactory

  public class ProductBFactory extends AbstractFactory{
      @Override
      public Product createProduct(){
          return new ProductB();
      }
  }

• 调用方Client

  public class Client{
      public static void main(String[] args){
          AbstractFactory factoryA = new ProductAFactory();
          AbstractFactory factoryB = new ProductBFactory();
          Product productA = factoryA.createProduct();
          Product productB = factoryB.createProduct();
          productA.operation();
          productB.operation();
      }
  }

抽象工厂

定义：Provide an interface for creating families of creating families of related or dependent objects without specifying their concrete classes.
uml图为
代码略

工厂模式与IoC的关系

http://stackoverflow.com/ques...

一些高分答案：

When using a factory your code is still actually responsible for creating objects. By DI you outsource that responsibility to another class or a framework, which is separate from your code.工厂模式中，代码中还要建立对象，可是DI中，建立对象的责任转交给了其余类或者框架，与代码已经解耦了。

I would suggest to keep the concepts plain and simple. Dependency Injection is more of a architectural pattern for loosely coupling software components. Factory pattern is just one way to separate the responsibility of creating objects of other classes to another entity. Factory pattern can be called as a tool to implement DI. Dependency injection can be implemented in many ways like DI using constructors, using mapping xml files etc. 认为DI更大程度上是一种将模块解耦的架构模式，而工厂模式能够看做一类实现了DI的工具，而DI能够经过多种方式实现。