设计模式——工厂模式

设计模式——工厂模式

工厂模式核心是封装对象的创建接口，将new对象的操作封装起来，方便创建使用、管理对象。

工厂模式的分类

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

工厂模式适用于：

1. 在编码时不能预见需要创建哪种类的实例。
2. 系统不应依赖于产品类实例如何被创建、组合和表达的细节

简单工厂模式

简单工厂模式又称为静态工厂方法模式。简单工厂模式是由一个工厂类来控制产品类对象的创建，模式构成比较简单，适用于简单稳定、扩展少的模块。它由三部分角色类构成：

• 简单工厂类：它是本模块的核心，用于创建对应的产品对象，包含一定的逻辑处理。
• 抽象产品类：它一般是具体产品继承的父类或者实现的接口，一般由接口或者抽象类来实现，它定义了产品的特点。
• 具体产品类：具体需要创建的产品类对象的实例。

它们之间关系的UML图如下：

simpleFactory.png

具体的演示实例：
首先我们创建抽象产品了Ball，并定义了两个具体的产品BasketBall和FootBall。

/**
 * 定义一个球的实体
 * @author Iflytek_dsw
 *
 */
abstract class Ball {
    /**
     * 定义球的特性，都能玩
     */
    public abstract void play();
}

class Basketball extends Ball{
    private String name = "";
    
    public Basketball(String name){
        this.name = name;
    }

    @Override
    public void play() {
        System.out.println("拍打：" + name);
    }
    
}

class Football extends Ball{
    private String name = "";
    public Football(String name){
        this.name = name;
    }

    @Override
    public void play() {
        System.out.println("踢：" + name);
    }
}

上面中创建了抽象产品类Ball，并定义方法play。同时每个具体产品类进行实现对应的方法。有了产品类，在定义一个简单工厂类：

/**
 * 工厂类，用于封装创建对象的操作，对外进行封装，不被外部调用。
 * 封装具体产品的创建对象。
 * @author Iflytek_dsw
 *
 */
public class BallFactory {
    enum BallType{
        BasketBall,
        FootBall
    }
    
    public static Ball createBall(BallType ballType){
        switch(ballType){
            case BasketBall:
                return new Basketball("篮球");
            case FootBall:
                return new Football("足球");
            default:
                return null;
        }
    }
}

这样，在简单工厂类中，我们封装了创建对象的静态方法。然后在客户端进行调用：

public class SimpleFactoryClient {

    /**
     * 通过简单工厂模式，我们可以根据我们的需求进行产品类的创建，直接进行使用，避免了客户端对产品的生产。
     * 弊端是：如果我们新增一个品种，修改比较多。
     * @param args
     */
    public static void main(String[] args) {
        //指定创建的类型
        Ball basketBall = BallFactory.createBall(BallType.BasketBall);
        basketBall.play();
        
        Ball footBall = BallFactory.createBall(BallType.FootBall);
        footBall.play();
    }
}

简单工厂的优点/缺点：

• 优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
• 缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则，当新增一个产品类是，需要改动工厂类，产品多，工厂类逻辑就过于复杂。

工厂方法模式

工厂方法模式，又称为多态性工厂模式，主要是利用面向对象的继承多态实现。在工厂方法模式中，核心的工厂类提取成为一个抽象工厂类，由对应产品的子类工厂负责创建对应的产品类对象。抽象工厂类只负责定义子类工厂需要实现的接口，不涉及具体产品类实例化的细节。工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

工厂方法模式由四个角色类组成：

• 抽象工厂类：定义工厂类的方法，用来创建产品类
• 具体工厂类：用于创建对应的产品对象
• 抽象产品类：定义产品了公共的属性、方法
• 具体产品类：实现对应产品类的属性、方法

它们之间的UML关系图如下：

FactoryMethod.png

实现例子：

定义产品类对象：

/**
 * 定义一个球的实体
 * @author Iflytek_dsw
 *
 */
abstract class Ball {
    /**
     * 定义球的特性，都能玩
     */
    public abstract void play();
}

class Basketball extends Ball{
    private String name = "";
    
    public Basketball(String name){
        this.name = name;
    }

    @Override
    public void play() {
        System.out.println("拍打：" + name);
    }
    
}

class Football extends Ball{
    private String name = "";
    public Football(String name){
        this.name = name;
    }

    @Override
    public void play() {
        System.out.println("踢：" + name);
    }
}

定义工厂类：

/**
 * 定义抽象工厂类，来定义所有工厂应该具备的职责，通性。
 * @author Iflytek_dsw
 *
 */
abstract class BallFacoty {
     public abstract Ball createBall();
}

class BasketballFactory extends BallFacoty{

    @Override
    public Ball createBall() {
        return new Basketball("篮球");
    }
}

class FootballFactory extends BallFacoty{

    @Override
    public Ball createBall() {
        return new Football("足球");
    }

}

定义客户端：

public class MethodFactoryClient {

    /**
     * 工厂方法模式，根据需要，直接创建对象。方便扩展。无用改变Factory类代码，只需要新增。
     * @param args
     */
    public static void main(String[] args) {
        BasketballFactory basketballFactory = new BasketballFactory();
        Ball basketBall = basketballFactory.createBall();
        basketBall.play();
        
        FootballFactory footballFactory = new FootballFactory();
        Ball footBall = footballFactory.createBall();
        footBall.play();
    }
}

工厂方法的优点/缺点：

优点：
子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。-- 加一层间接性，增加了灵活性
屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。
多态性：客户代码可以做到与特定应用无关，适用于任何实体类。
缺点：
需要Creator和相应的子类作为factory method的载体，如果应用模型确实需要creator和子类存在，则很好；否则的话，需要增加一个类层次，有点冗余。

抽象工厂模式

产品族： 位于不同产品等级结构中，功能相关联的产品组成的家族。抽象工厂模式是针对产品族进行使用，抽象工厂类的用途就是提供一个接口，创建多个产品族中的对象。比如，我们上面的例子中，篮球和足球就是产品层次结构。而篮球中又可以有大的和小的篮球种类，足球中也有大的和小的的足球种类，这里打篮球和大足球就属于产品族。
而且使用抽象工厂模式还要满足一下条件：

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

来看看抽象工厂模式的各个角色：

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

AbstractFactory.png

来看具体的实例：

新建抽象产品类

abstract class Product {
    public abstract void play();
}


abstract class ProductA extends Product{
    public abstract void play();
}

abstract class ProductB extends Product{
    public abstract void play();
}

class ProductABig extends ProductA{

    @Override
    public void play() {
        System.out.print("ProductABig");
    }
}

class ProductASmall extends ProductA{
    @Override
    public void play() {
        System.out.print("ProductASmall");
    }
}

class ProductBBig extends ProductB{

    @Override
    public void play() {
        System.out.print("ProductBBig");
    }
}

class ProductBSmall extends ProductB{
    @Override
    public void play() {
        System.out.print("ProductBSmall");
    }
}

抽象工厂类

abstract class Factory {
    abstract ProductA createProductA();
    abstract ProductB createProductB();
}

class FactoryBig extends Factory{

    @Override
    ProductA createProductA() {
        return new ProductABig();
    }

    @Override
    ProductB createProductB() {
        return new ProductBBig();
    }
}

class FactorySmall extends Factory{

    @Override
    ProductA createProductA() {
        return new ProductASmall();
    }

    @Override
    ProductB createProductB() {
        return new ProductBSmall();
    }
}

客户端

public static void main(String[] args) {
    Factory factoryBig = new FactoryBig();
    Product productABig = factoryBig.createProductA();
    Product productBBig = factoryBig.createProductB();
    productABig.play();
    productBBig.play();
}

从抽象工厂特点来看，就是在工厂中不仅仅只生产一种对象，而是可以创建多种产品对象。
优点：
抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

缺点：
产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

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

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

首先来看看这两者的定义区别：

• 工厂模式：定义一个用于创建对象的借口，让子类决定实例化哪一个类
• 抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的。
再来看看工厂方法模式与抽象工厂模式对比：

工厂方法模式	抽象工厂模式
针对的是一个产品等级结构	针对的是面向多个产品等级结构
一个抽象产品类，可以派生出多个具体产品类	多个抽象产品类，每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类	个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类只能创建一个具体产品类的实例	每个具体工厂类可以创建多个具体产品类的实例

总结

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。所以要多思考工厂模式的特点，设计模式这东西就是要多思考，理解，变换。