设计模式之工厂模式

工厂模式的优点

• 使代码结构清晰，有效地封装变化。
  在编程中，产品类的实例化有时候是比较复杂和多变的，通过工厂模式，将产品的实例化封装起来，使得调用者根本无需关心产品的实例化过程，只需依赖对应的工厂即可得到自己想要的产品（对象）。

• 对调用者屏蔽具体的产品类。
  如果使用工厂模式，调用者只关心产品（对象）的接口就可以了，至于具体的实现，调用者根本无需关心。即使变更了具体的实现，对调用者来说没有任何影响。

• 降低耦合度。
  产品类的实例化通常来说是很复杂的，它需要依赖很多的类，而这些类对于调用者来说根本无需知道，如果使用了工厂方法，我们需要做的仅仅是实例化好产品类，然后交给调用者使用。对调用者来说，产品所依赖的类都是透明的。

简单工厂模式

1. 简单工厂模式又称静态工厂方法模式。它存在的目的很简单：定义一个用于创建对象的接口。

2. 先来看看它的组成：

• 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
• 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
• 具体产品角色：工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。

1. 抽象产品类或接口：

public interface Shape {
    void draw();
}  

1. 具体产品类
   每个具体的产品都要实现产品接口。

//圆形
public class CircleShape implements Shape {

    public CircleShape() {
        System.out.println(  "CircleShape: created");
    }

    @Override
    public void draw() {
        System.out.println(  "draw: CircleShape");
    }

}

//正方形
public class RectShape implements Shape {
    public RectShape() {
       System.out.println(  "RectShape: created");
    }

    @Override
    public void draw() {
       System.out.println(  "draw: RectShape");
    }

}

//三角形
public class TriangleShape implements Shape {

    public TriangleShape() {
        System.out.println(  "TriangleShape: created");
    }

    @Override
    public void draw() {
        System.out.println(  "draw: TriangleShape");
    }

}

1. 工厂类

public class ShapeFactory {
          public static final String TAG = "ShapeFactory";
          public static Shape getShape(String type) {
              Shape shape = null;
              if (type.equalsIgnoreCase("circle")) {
                  shape = new CircleShape();
              } else if (type.equalsIgnoreCase("rect")) {
                  shape = new RectShape();
              } else if (type.equalsIgnoreCase("triangle")) {
                  shape = new TriangleShape();
              }
              return shape;
          }
   }

在这个工厂类中通过传入不同的 type 可以 new 不同的形状，返回结果为 Shape 类型，这个就是简单工厂核心的地方了。

1. 给调用者使用

// 画圆形
Shape shape = ShapeFactory.getShape("circle");  //获得产品
 shape.draw(); //使用产品
 
// 画正方形
Shape shape= ShapeFactory.getShape("rect");
shape.draw(); 

这就是简单工厂模式（静态工厂模式）。

工厂方法模式

工厂方法模式是简单工厂的进一步深化， 在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。也就是说每个对象都有一个与之对应的工厂。

• 每一个工厂和对应产品的逻辑图

定义一个用于创建对象的接口，让子类决定将哪一个产品类实例化。工厂方法模式让一个类的实例化延迟到其子类。这个是关键的思想。

• 工厂方法实例

现在需要设计一个这样的图片加载类，它具有多个图片加载器，用来加载
jpg，png，gif 格式的图片，每个加载器都有一个 load（）方法，用于读取图片。下面我们完成这个图片加载类。

1. 首先完成图片加载器的设计，编写一个加载器的公共接口。

public interface Loader {
    void load();
}

Loader 里面只有一个 load（）方法，然后完成各个图片加载器的代码。

1. 各种图片加载器

• Jpg图片加载器

public class JpgLoader implements Loader {
    @Override
    public void load() {
        System.out.print("load jpg");
    }
}

• Png图片加载器

public class PngLoader implements Loader {
    @Override
    public void load() {
        System.out.print("load png");
    }
}

• Gif图片加载器

public class GifLoader implements Loader {
    @Override
    public void load() {
        System.out.print("load gif");
    }
}

1. 定义一个抽象的工厂接口LoaderFactory

public interface LoaderFactory {
    Loader getLoader();
}

getLoader（）方法返回我们的Loader 类对象。
接下来我们把上面定义好的每个图片加载器都提供一个工厂类，这些工厂类实现了LoaderFactory。

• Jpg加载器工厂

public class JpgLoaderFactory implements LoaderFactory {
    @Override
    public Loader getLoader() {
        return new JpgLoader();
    }
}

• Png加载器工厂

public class PngLoaderFactory implements LoaderFactory {
    @Override
    public Loader getLoader() {
        return new PngLoader();
    }
}

• Gif加载器工厂

public class GifLoaderFactory implements LoaderFactory {
    @Override
    public Loader getLoader() {
        return new GifLoader();
    }
}

在每个工厂类中我们都通过复写的getLoader（）方法返回各自的图片加载器对象。

1. 客户端使用

• 读取Jpg

LoaderFactory factory= new JpgLoaderFactory();
Loader  loader=factory.getLoader();
loader.load();

• 读取Png

LoaderFactory factory=new PngLoaderFactory();
Loader  loader=factory.getLoader();
loader.load();

• 读取Gif

LoaderFactory factory=new GifLoaderFactory();
Loader  loader=factory.getLoader();
loader.load();

工厂方法模式和简单工厂对比一下。最根本的区别在于：简单工厂只有一个统一的工厂类，而工厂方法是针对每个要创建的对象都会提供一个工厂类，这些工厂类都实现了一个工厂基类或者工厂接口。

适用场景：

• 客户端不需要知道它所创建的对象的类。例子中我们不知道每个图片加载器具体叫什么名，只知道创建它对应的工厂名就完成了创建过程。

• 客户端可以通过对应的工厂子类来指定创建对应的对象。

抽象工厂模式

抽象工厂模式是工厂方法的进一步灵活使用，在这个模式中的工厂类不单单可以创建一个对象，而是可以创建一组对象。这是比较灵活的。

定义：
　　提供一个创建一系列对象的接口，而无须指定它们具体的类。简单来说，就是每一个具体工厂都提供了多个工厂方法用于产生多种不同类型的对象。

• 抽象工厂和工厂方法一样可以划分为4大部分：

AbstractFactory（抽象工厂）：声明了一组用于创建对象的方法，注意是一组。
ConcreteFactory（具体工厂）**：它实现了在抽象工厂中声明的创建对象的方法，生成一组具体对象。
AbstractProduct（抽象产品）：它为每种对象声明接口，在其中声明了对象所具有的业务方法。
ConcreteProduct（具体产品）：它定义具体工厂生产的具体对象。

实例：
　　现在需要做一款跨部门使用的考核产品，需要兼容A，B两个部门，该考核产品针对每个部门都设计了一套操作控制器 OperationController 和评分控制器 JudgeController，下面通过抽象工厂方式完成这款产品的架构设计。

产品里边的各个部门的 OperationController 和 JudgeController 应该是我们最终生产的具体产品。所以新建两个抽象产品接口。

• 抽象操作控制器接口

public interface OperationController {
    void control();
}

• 抽象评分控制器接口

public interface JudgeController {
    void judge();
}

• 具体产品实现类

1. A部门的具体实现的2个产品类

public class APartOperationController implements OperationController {
    @Override
    public void control() {
        System.out.println("APartOperationController");
    }
}

public class APartJudgeController implements JudgeController {
    @Override
    public void judge() {
        System.out.println("APartJudgeController");
    }
}

1. B部门的具体实现的2个产品类

public class BPartOperationController implements OperationController {
    @Override
    public void control() {
        System.out.println("BPartOperationController");
    }
}

public class BPartJudgeController implements JudgeController {
    @Override
    public void judge() {
        System.out.println("BPartJudgeController");
    }
}

• 抽象工厂接口
  该工厂需要持有创建 OperationController 和 JudgeController （若干个产品对象）的方法。

public interface PartFactory {
    public OperationController createOperationController();
    public JudgeController createJudgeController();
}

• 具体工厂实现类

1. A部门工厂

public class APartFactory implements PartFactory {
    @Override
    public OperationController createOperationController() {
        return new APartOperationController();
    }

    @Override
    public JudgeController createJudgeController() {
        return new APartJudgeController();
    }
}

1. B部门工厂

public class BPartFactory implements PartFactory {
    @Override
    public OperationController createOperationController() {
        return new BPartOperationController();
    }

    @Override
    public JudgeController createJudgeController() {
        return new BPartJudgeController();
    }
}

小小的心得：

其实工厂相关的设计模式都是利用 Java 的多态和泛型的特性，不指定实例化哪个具体的子类，将具体要实例化的子类对象延后到各自对应的工厂中。

• 客户端调用

    PartFactory mFactory;
    JudgeController judgeController;
    OperationController operationController;

    //如果要使用A部门的功能，初始化 APart
    mFactory=new APartFactory();
    //如果要使用B部门的功能，初始化 BPart
    // mFactory=new BPartFactory();

    // 获取A部门的评分功能产品
    judgeController = mFactory.createJudgeController();
    // 获取A部门的操作功能产品
    operationController=mFactory.createOperationController();

    judgeController.judge();
    operationController.control();

总结

以上就是 3 种工厂方法，当你需要创建的对象纷繁复杂又依赖其他对象的时候，可以使用工厂方法模式将创建对象的方法封装起来，使对象的实例化流程对调用者透明。个人觉得，这种模式最常见的使用场景应该是SDK，封装好一系列的创建对象的方法给开发者调用。不过在 APP 工程也有见过。

参考资料

工厂模式——看这一篇就够了
23种设计模式（2）：工厂方法模式