设计模式之创建型——工厂模式（3种）

→23种设计模式大纲

定义

将创建对象这一复杂的过程交由工厂控制，通过工厂来统一获取对象。

分类

1）简单工厂

简单工厂（静态工厂）并不属于GOF中23种设计模式之一，但在实际开发中也用的相对较多。

UML类图

根据UML类图可以看出，工厂模块根据用户传入的参数来实例化对应的产品，产品具有抽象的接口。

抽象产品接口和产品类

public interface Product {
    void function();
}

class ProductA implements Product {

    @Override
    public void function() {
        System.out.println("调用 A 产品的功能");
    }
}
class ProductB implements Product {

    @Override
    public void function() {
        System.out.println("调用 B 产品的功能");
    }
}

工厂类

public class SimpleFactory {
    
    public static Product createProduct(String productName){
        if(productName.equals("A")){
            return new ProductA();
        }

        if(productName.equals("B")){
            return new ProductB();
        }

        throw  new RuntimeException("无相关产品");
    }
}

调用测试

public class Client {
    public static void main(String[] args) {
        Product a = SimpleFactory.createProduct("A");
        Product b = SimpleFactory.createProduct("B");
        a.function();
        b.function();
    }
}

总结

• 调用方不用关心产品内部如何构建，只需要调用工厂提供的方法，传入对应产品名即可获取对象
• 传参时可以使用枚举的方式来匹配

问题

• 新增产品时，需要在工厂内增加 IF 逻辑，不符合开闭原则
• 产品创建时全放在一个工厂内，该工厂承担职责过重，一旦出错，所有的产品都会受到影响

2）工厂方法

UML类图

• 比起简单工厂，工厂方法进一步抽象了 “工厂” 这一角色。
• 具体实例化的工厂都实现抽象工厂接口。
• 一个实例化工厂负责创建一个产品，一一对应。

产品类

public interface Product {
    void function();
}

class ProductA implements Product {

    @Override
    public void function() {
        System.out.println("调用 A 产品的功能");
    }
}

class ProductB implements Product {

    @Override
    public void function() {
        System.out.println("调用 B 产品的功能");
    }
}

工厂类

public interface AbstractFactory {

    public Product createProduct();
}
//工厂A负责创建产品A
class FactoryA implements  AbstractFactory{

    @Override
    public Product createProduct() {
        return new ProductA();
    }
}
//工厂B负责创建产品B
class FactoryB implements  AbstractFactory{

    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

优点：

新增产品后，不需要像简单工厂一样再重新修改原因逻辑。新增一个新的工厂专门去负责创建新的产品即可。

缺点：

如果产品数量过多，那么就会产生很多的工厂类，工厂类太多自然也是个问题。

3）抽象工厂

新概念→产品族：将各种相关的产品组合在一起的集合。

为了解决工厂类太多的问题，我们可以让一个工厂去生产对应的产品族。
从 1对1（工厂方法），变为1对N（抽象工厂）。

举个例子：

• 苹果手机，苹果笔记本，苹果台式电脑是一个产品族。苹果厂商负责生产这个产品族。
• 小米手机，小米笔记本，小米台式电脑是一个产品族。小米厂商负责生产这个产品族。

UML类图

工厂

public interface AbstractFactory {
    Pen createPen();

    Book createBook();

    Bag createBag();
}

class FactoryA implements AbstractFactory{

    @Override
    public Pen createPen() {
        return new Apen();
    }

    @Override
    public Book createBook() {
        return new Abook();
    }

    @Override
    public Bag createBag() {
        return new Abag();
    }
}

class FactoryB implements AbstractFactory{

    @Override
    public Pen createPen() {
        return new Bpen();
    }

    @Override
    public Book createBook() {
        return new Bbook();
    }

    @Override
    public Bag createBag() {
        return new Bbag();
    }
}

产品

public interface Pen {
    void function();
}
interface Book {
    void function();
}
interface Bag {
    void function();
}
class Apen implements Pen {
    @Override
    public void function() {
        System.out.println(" A 厂 Pen");
    }
}
class Abook implements Book {
    @Override
    public void function() {
        System.out.println(" A 厂 Book");
    }
}
class Abag implements Bag {
    @Override
    public void function() {
        System.out.println(" A 厂 Bag");
    }
}
class Bpen implements Pen {
    @Override
    public void function() {
        System.out.println(" B 厂 Pen");
    }
}
class Bbook implements Book {
    @Override
    public void function() {
        System.out.println(" B 厂 Book");
    }
}
class Bbag implements Bag {
    @Override
    public void function() {
        System.out.println(" B 厂 Bag");
    }
}

引入产品族的概念确实一定程度上的解决了工厂类的问题。

对于产品族而言，如果再增加又有新的厂商加入，那么再增加一个工厂即可。

注意点：

• 对于产品族的横向扩展，抽象工厂遵守了 “开闭原则”。（增加新的工厂）
• 但对于产品族的纵向扩展，即如果产品族内需要新增一种产品，则会面临大幅度的修改。

所以抽象工厂使用时，需要能够尽量全面的预估一个产品族需要包含的产品。

总结

1. 简单工厂：抽离创建对象这一过程，调用方统一获取对象；
2. 工厂方法：引入抽象工厂概念，1 个产品对应 1 个工厂；
3. 抽象工厂：引入产品族概念，1 个产品族对应 1 个工厂，N 个产品对应 1 个工厂；