工厂设计模式-三种实现方式

工厂设计模式说明

一、简单工厂模式 Simple Factory

简单工厂模式没有被归类到常见23种设计模式中，此处主要是和工厂方法、抽象工厂对比，方便理解。
简单工厂模式：把对象的创建放到一个工厂类中，通过参数来创建不同的对象。

1.1案例代码

角色组成

• 抽象产品：定义了抽象产品具有的基本操作
• 产品实现类：实现抽象产品类对定义的抽象方法
• 生产工厂：不同的参数生成具体的产品对象

/**
 * 抽象产品:  配置接口
 */
interface OSSConfig {
    /**
     * 初始化OSS配置
     */
    void init();
}

/**
 * 具体产品:  阿里云OSS配置
 */
class AlibabaOSSConfig implements OSSConfig {

    @Override
    public void init() {
        System.out.println("初始化--阿里云--OSS配置");
    }
}

/**
 * 具体产品:  腾讯云OSS配置
 */
class TencentOSSConfig implements OSSConfig {

    @Override
    public void init() {
        System.out.println("初始化--腾讯云--OSS配置");
    }
}

/**
 * 简单工厂类
 */
public class SimpleFactory {
    /**
     * 生产工厂
     */
    public static OSSConfig createOSSConfig(String name) {
        OSSConfig config = null;
        switch (name) {
            case "alibaba":
                config = new AlibabaOSSConfig();
                break;
            case "tencent":
                config = new TencentOSSConfig();
                break;
            default:
                break;
        }
        return config;
    }

    public static void main(String[] args) {
        OSSConfig alibabaConifg = SimpleFactory.createOSSConfig("alibaba");
        alibabaConifg.init();

        OSSConfig tencentConfig = SimpleFactory.createOSSConfig("tencent");
        tencentConfig.init();
    }
}

二、工厂方法模式 Factory Method

工厂方法模式: 每种产品由一种工厂来创建，一个工厂处理一个对象。

• 一个抽象产品类，可以派生出多个具体产品类。
• 一个抽象工厂类，可以派生出多个具体工厂类。
• 每个具体工厂类只能创建一个具体产品类的实例。

2.1案例代码

角色组成

• 抽象工厂: 定义工厂类所具有的基本的操作
• 具体工厂：该类必须继承抽象工厂，实现抽象工厂定义的方法，返回一个对象
• 抽象产品：定义了抽象产品具有的基本操作
• 产品实现类：实现抽象产品类对定义的抽象方法，和具体工厂一一对应

/**
 * 抽象产品: 配置接口
 */
interface OSSConfig {
    /**
     * 初始化OSS配置
     */
    void init();
}

/**
 * 具体产品: 阿里云OSS配置
 */
class AlibabaOSSConfig implements OSSConfig {

    @Override
    public void init() {
        System.out.println("初始化--阿里云--OSS配置");
    }
}

/**
 * 具体产品: 腾讯云OSS配置
 */
class TencentOSSConfig implements OSSConfig {

    @Override
    public void init() {
        System.out.println("初始化--腾讯云--OSS配置");
    }
}


/**
 * 抽象工厂
 */
interface Factory {
    OSSConfig createOSSConfig();
}

/**
 * 具体工厂: 腾讯云工厂
 */
class TencentOSSFactory implements Factory {

    @Override
    public OSSConfig createOSSConfig() {
        return new TencentOSSConfig();
    }
}

/**
 * 具体工厂: 阿里云工厂
 */
class AlibabaOSSFactory implements Factory {

    @Override
    public OSSConfig createOSSConfig() {
        return new AlibabaOSSConfig();
    }
}

/**
 * 工厂设计模拟类
 */
public class FactoryMethod {

    public static void main(String[] args) {
        AlibabaOSSFactory alibabaOSSFactory = new AlibabaOSSFactory();
        OSSConfig alibabaConifg = alibabaOSSFactory.createOSSConfig();
        alibabaConifg.init();

        TencentOSSFactory tencentOSSFactory = new TencentOSSFactory();
        OSSConfig tencentConfig = tencentOSSFactory.createOSSConfig();
        tencentConfig.init();
    }
}

三、抽象工厂模式 Abstract Factory

抽象工厂模式：工厂方法模式的进一步延伸

• 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
• 一个抽象工厂类，可以派生出多个具体工厂类。
• 每个具体工厂类可以创建多个具体产品类的实例。

3.1案例代码

角色组成

• 抽象工厂: 定义工厂类所具有的基本的操作
• 具体工厂：具体工厂实现了抽象工厂，每个工厂方法返回多个具体对象
• 抽象类接口：定义了产品具有的基本操作,提供一组所有类都具有的业务方法
• 抽象类：用于实现抽象接口所定义的业务方法,只做抽象接口，具体由产品实现类处理
• 产品实现类：实现抽象产品类对定义的抽象方法，和具体工厂一对多

/**
 * 抽象产品: 配置接口
 */
interface OSSConfig {
    /**
     * 初始化OSS配置
     */
    void init();
}

/**
 * 具体产品: 阿里云OSS配置
 */
abstract class AlibabaOSSConfig implements OSSConfig {
    public abstract void init();
}

/**
 * 具体产品: 阿里云OSS配置Test环境
 */
class AlibabaTstOSSConfig extends AlibabaOSSConfig {
    @Override
    public void init() {
        System.out.println("初始化--阿里云--test环境--OSS配置");
    }
}

/**
 * 具体产品: 阿里云OSS配置生产环境
 */
class AlibabaPreOSSConfig extends AlibabaOSSConfig {
    @Override
    public void init() {
        System.out.println("初始化--阿里云--Pre环境--OSS配置");
    }
}

/**
 * 抽象产品: 腾讯云OSS配置
 */
abstract class TencentOSSConfig implements OSSConfig {
    public abstract void init();
}

/**
 * 抽象产品: 腾讯云OSS配置
 */
class TencentProOSSConfig extends TencentOSSConfig {
    @Override
    public void init() {
        System.out.println("初始化--腾讯云--Pre环境--OSS配置");
    }
}

/**
 * 抽象工厂
 */
interface Factory {
    /**
     * 获取测试环境配置
     */
    OSSConfig createOSSTestConfig();

    /**
     * 获取生成环境配置
     */
    OSSConfig createOSSPreConfig();
}

/**
 * 具体工厂: 腾讯云工厂
 */
class TencentOSSFactory implements Factory {

    @Override
    public OSSConfig createOSSTestConfig() {
        return null;
    }

    @Override
    public OSSConfig createOSSPreConfig() {
        return new TencentProOSSConfig();
    }
}

/**
 * 具体工厂: 腾讯云工厂
 */
class AlibabaOSSFactory implements Factory {

    @Override
    public OSSConfig createOSSTestConfig() {
        return new AlibabaTstOSSConfig();
    }

    @Override
    public OSSConfig createOSSPreConfig() {
        return new AlibabaPreOSSConfig();
    }
}

/**
 * 工厂设计模拟类
 * 产品接口可以定义OSS配置的操作接口，不同的厂商实现都去实现接口，通过工厂动态生成配置
 */
public class AbstractFactory {

    public static void main(String[] args) {
        // 阿里云oss配置
        AlibabaOSSFactory alibabaOSSFactory = new AlibabaOSSFactory();
        OSSConfig alibabaConifg = alibabaOSSFactory.createOSSPreConfig();
        alibabaConifg.init();
        OSSConfig alibabaTestConifg = alibabaOSSFactory.createOSSTestConfig();
        alibabaTestConifg.init();
		
		// 腾云云oss配置
        TencentOSSFactory tencentOSSFactory = new TencentOSSFactory();
        OSSConfig tencentConifg = tencentOSSFactory.createOSSPreConfig();
        tencentConifg.init();
    }
}

四、工厂模式和抽象工厂模式对比

区别：
工厂方法模式：具体工厂类只能创建一个具体产品类的实例
抽象工厂模式：具体工厂类可以创建多个具体产品类的实例。