【创建型】简单工厂模式&工厂方法

简单工厂模式

简单工厂模式，其实不算23种设计模式之一，它引入了创建者的概念，将实例化的代码从客户端代码中抽离，交给服务端维护

Java代码实现

需求：服务端开发一个计算器功能，完成加减乘除运算操作

根据简单工厂模式，可以画出它的UML类图如下：

1、需要一个产品抽象类（Operation父类）、工厂类、具体的实现类（AddOperation...）

2、Operation类中有操作数x和y，以及获取结果的函数getResult()

3、工厂类OperationFactory类创建具体的Operation，其中OperationFactory类依赖Operation类

服务端代码

public class OperationFactory {

    public static Operation createOperation(String operate) {
        Operation operation = null;
        switch (operate) {
            case "+":
                operation = new AddOperation();
                break;
            case "-":
                operation = new SubOperation();
                break;
            case "*":
                operation = new MulOperation();
                break;
            case "/":
                operation = new DivOperation();
                break;
        }
        return operation;
    }
}

public abstract class Operation {
    double x;
    double y;
    double result;

    public void setX(double x) {
        this.x = x;
    }

    public void setY(double y) {
        this.y = y;
    }

    public double getResult() throws Exception {
        return result;
    }
}

public class AddOperation extends Operation {
    @Override
    public double getResult() {
        return x + y;
    }
}

public class SubOperation extends Operation {
    @Override
    public double getResult() throws Exception {
        return x - y;
    }
}

public class MulOperation extends SubOperation {
    @Override
    public double getResult() throws Exception {
        return x / y;
    }
}
public class DivOperation extends MulOperation {
    @Override
    public double getResult() throws Exception {
        if (0 == y) {
            throw new Exception("除数不能为0");
        }
        return x / y;
    }
}

客户端代码

public class Main {
    public static void main(String[] args) throws Exception {
        Operation operation = OperationFactory.createOperation("+");
        operation.setX(1);
        operation.setY(2);
        System.out.println(operation.getResult()); // print 3.0
    }
}

C代码实现

需求：某一项目需要用到 eeprom、flash 这两个设备保存不同数据，有初始化、读、写三个功能，后续有可能扩展设备

服务端代码：

需要定义设备类型flash.c flash.h eeprom.c eeprom.h

// flash.c
#include <stdint.h>
#include <stdio.h>
#include "factory_function.h"

void flash_init(void) {
    printf("初始化 FLASH\n");
}

void flash_open(void) {
    printf("启用 FLASH\n");
}

void flash_write(uint32_t addr, uint8_t *data, uint16_t len) {
    printf("向FLASH 地址:%x 写入%d 字节数据:%s\n", addr, len, (char *) data);

// eeprom.c
#include <stdint.h>
#include <stdio.h>

void eeprom_init(void) {
    printf("初始化 EEPROM\n");
}

void eeprom_open(void) {
    printf("启用 EEPROM\n");
}

void eeprom_write(uint32_t addr, uint8_t *data, uint16_t len) {
    printf("向EEPROM 地址:%x 写入%d 字节数据:%s\n", addr, len, (char *) data);
}

需要定义工厂方法：

// factory_function.c
#include <string.h>
#include "factory_function.h"
#include "flash.h"
#include "eeprom.h"

typedef struct {
    char *name;
    void (*init)(void);
    void (*open)(void);
    void (*write)(uint32_t, uint8_t *, uint16_t);
} Storage;

Storage storage_list[] = {
        {"eeprom", eeprom_init, eeprom_open, eeprom_write},
        {"flash",  flash_init,  flash_open,  flash_write},
};

Storage *factory_pro(char *name) {
    for (int i = 0; i < sizeof(storage_list) / sizeof(storage_list[0]); ++i) {
        if (0 == strcmp(name, storage_list[i].name)) {
            storage_list->init();
            storage_list->open();
            return &storage_list[i];
        }
    }
    return NULL;
}

客户端代码

void test_01_factory_method() {
    char *str[] = {"我是EEPROM", "我是FLASH"};
    Storage *byte_data = factory_pro("eeprom");
    Storage *sector_data = factory_pro("flash");
	
    byte_data->write(0x0100, str[0], strlen(str[0]));
    sector_data->write(0x02000100, str[1], strlen(str[1]));
}

模式应用

1、JDK类库中广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间

public final static DateFormat getDateInstance(); 
public final static DateFormat getDateInstance(int style); 
public final static DateFormat getDateInstance(int style,Locale locale);

2、获取不同加密算法的密钥生成器

KeyGenerator keyGen=KeyGenerator.getInstance("DESede");

总结

简单工厂模式下，后续拓展功能，需要侵入式的修改工厂中的代码，违反了开闭原则，但是客户端代码不用修改。

C语言的简单工厂模式和面向对象的Java略有不同

1、Java用的继承和多态的思想按需动态的创建所需要的类型

2、C语言用循环遍历的方式来寻找具体的类型并执行方法

工厂方法

需求：服务端开发一个计算器功能，完成加减乘除运算操作。

相比简单工厂模式，工厂方法的UML类图如下：

针对不同的操作，有不同的工厂，这种修改带来了优点是减少侵入式修改，但是会增加服务端的开发量同时客户端需要适配