工厂模式 - 《设计模式笔记》

简单工厂模式
工厂方法模式
抽象工厂模式

当需要创建的对象他有非常非常多的属性需要设置时，一个个set显然比较麻烦
而工厂模式可根据不同的业务场景将需要设置的属性封装成一个个方法，一劳永逸

工厂模型核心是生产，用户，销售分开，这样可以降低耦合，处理高并发情况下导致的仓库里没东西了还继续售卖的情况(超卖)，对电商项目很有用

简单工厂模式

简单工厂模式属于创建型模式，工厂模式的一种，由一个工厂对象决定创建出哪一种产品类的实例
定义一个创建对象的类，由这个类来封装实例化对象的行为
用到大量的创建某种，某类或者某批对象时，会用到工厂模式

简单工厂简单来说就是把创建对象的方法都交给一个工厂类来实现

简单工厂模式又叫做静态工厂模式

举例：

以生产披萨为例，披萨制作分为四个步骤，写成四个方法

为了方便这里使用抽象类，一般接口用的比较多

先定义一个抽象的Pizza类，里面定义四个方法

public abstract class Pizza {
    private String pizzaName;
    /**
     * 准备材料
     */
    void prepare() {
        System.out.println(pizzaName + " prepare");
    }
    /**
     * 烘焙
     */
    void bake() {
        System.out.println(pizzaName + " bake");
    }
    /**
     * 切
     */
    void cut() {
        System.out.println(pizzaName + " cut");
    }
    /**
     * 包装
     */
    void box() {
        System.out.println(pizzaName + " box");
    }
    public void setPizzaName(String pizzaName) {
        this.pizzaName = pizzaName;
    }
}

然后建两个子类继承披萨父类，是为奶酪披萨和胡椒披萨

public class CheesePizza extends Pizza {
    public CheesePizza() {
        this.setPizzaName("奶酪");
    }
}

public class PepperPizza extends Pizza {
    public PepperPizza() {
        this.setPizzaName("胡椒");
    }
}

然后创建一个简单工厂类还封装创建对象的方法

根据输入的类型判断你要创建哪一种披萨

public class SimpleFactory {
    //虽然这种方法封装了创建对象的方法
    //但是也违背了开闭原则
    //每新增一个披萨类型就需要改方法里的代码
    public static Pizza create(String type){
        if ("cheese".equals(type)){
            return new CheesePizza();
        }
        if ("pepper".equals(type)) {
            return new PepperPizza();
        }
        return null;
    }
}

然后在获取实例的时候直接根据简单工厂类的方法就可以直接获取对象

    public static void main(String[] args) {
        Pizza pizza = SimpleFactory.create("cheese");
        assert pizza != null;
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }

简单工厂获取对象的流程就是这样

当新增披萨种类时，只需要在简单工厂类里改相应的实例化对象的代码，但是这样有违开闭原则

可能就会有疑问，这样比起直接new对象还多一个写工厂类的步骤，好像更麻烦了

那是因为这里写的代码比较少，当涉及业务扩展，功能增加，对象参数增多的时候，如果是直接new对象就需要在每个创建对象的地方改代码，而使用简单工厂模式就只需要在工厂类里改代码就行了

工厂方法模式

简单工厂模式在类的属性变多时的可维护性，可扩展性就不是很好了

而工厂方法模式是在业务扩展时不修改原有的代码，对于扩展维护比较友好

和简单工厂的区别就是

简单工厂模式需要动原有的工厂类的代码
工厂方法模式，不改原有工厂类代码，而是新建一个工厂类

仍以上面披萨为例

两种类型的披萨，就先创建一个工厂接口，定义好创建对象的接口，具体的实现方法交给子类完成

public interface MethodFactory {
    Pizza createPizza();
}

两个具体的创建对象的工厂类，这里写的比较简单，当有较为复杂的业务逻辑和较多的属性时可以在此封装

不同的披萨对象交由不同的工厂来生产

奶酪披萨工厂

public class CheeseMethodFactory implements MethodFactory {
    public Pizza createPizza() {
        return new CheesePizza();
    }
}

public class PepperMethodFactory implements MethodFactory {
    public Pizza createPizza() {
        return new PepperPizza();
    }
}

调用方就是这样，根据不同的工厂拿到不同的对象

    public static void main(String[] args) {
        Pizza pizza = new CheeseMethodFactory().createPizza();
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        Pizza pizza2 = new PepperMethodFactory().createPizza();
        pizza2.prepare();
        pizza2.bake();
        pizza2.cut();
        pizza2.box();
    }

工厂方法模式获取实例流程就像这样，对于扩展更友好

扩展多少个种类的披萨就新建多少个生产披萨对象的工厂

抽象工厂模式

抽象工厂可以理解为生产工厂的工厂

假设小米生产手机和路由器，华为也生产手机和路由器

小米手机与华为手机同属于一个产品等级，小米手机和小米路由器同属一个产品族

以此来举例

手机产品可以指定一个接口，路由器的产品也可以指定一个接口

然后可以指定一个抽象产品工厂，围绕这个超级工厂创建其他工厂

手机产品特征接口

public interface PhoneProduct {
    void start();
    void shutdown();
    void call();
    void sendSms();
}

路由器产品特征

public interface RouterProduct {
    void start();
    void shutdown();
    void openWifi();
    void settings();
}

然后创建小米和华为的手机和路由器类实现具体的方法

就只拿华为举例复制多了没意义

华为手机类实现手机产品接口

public class HuaweiPhone implements PhoneProduct {
    public void start() {
        System.out.println("华为手机开机");
    }
    public void shutdown() {
        System.out.println("华为手机关机");
    }
    public void call() {
        System.out.println("华为手机打电话");
    }
    public void sendSms() {
        System.out.println("华为手机发短信");
    }
}

华为路由器类实现路由器产品接口

public class HuaweiRouter implements RouterProduct {
    public void start() {
        System.out.println("华为路由器开机");
    }
    public void shutdown() {
        System.out.println("华为路由器关机");
    }
    public void openWifi() {
        System.out.println("华为路由器wifi");
    }
    public void settings() {
        System.out.println("华为路由器设置");
    }
}

然后指定一个抽象产品工厂，其他工厂将围绕此工厂创建

这个工厂来指明生产哪些产品

public interface ProductFactory {
    PhoneProduct phoneProduct();
    RouterProduct routerProduct();
}

然后就创建一个华为的工厂，实现抽象产品工厂接口，此工厂用于创建具体的产品对象

public class HuaweiFactory implements ProductFactory {
    public PhoneProduct phoneProduct() {
        return new HuaweiPhone();
    }
    public RouterProduct routerProduct() {
        return new HuaweiRouter();
    }
}

最终获取对象就根据对应的工厂类来获取

    public static void main(String[] args) {
        //使用小米工厂生产小米的产品
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        PhoneProduct xiaomiPhone = xiaomiFactory.phoneProduct();
        RouterProduct xiaomiRouter = xiaomiFactory.routerProduct();
        //使用华为工厂生产华为的产品
        HuaweiFactory huaweiFactory = new HuaweiFactory();
        PhoneProduct huaweiPhone = huaweiFactory.phoneProduct();
        RouterProduct huaweiRouter = huaweiFactory.routerProduct();
    }

抽象工厂模式获取对象的方法流程大概就是这样

从设计层面看，抽象工厂模式就是对简单工厂模式的改进或者称为进一步的抽象。

将工厂抽象成两层

AbsFactory( 抽象工厂 ) 和具体实现的工厂子类。

程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂族更利于代码的维护和扩展。

适用场景：

不依赖产品实例如何被创建、实现等细节
强调同一个产品族的一系列产品

优点：

具体产品在应用层的代码隔离，无需关心细节
将一个系列的产品统一到一起创建

缺点：

规定了所有可能被创建的产品集合，产品族扩展新产品就会比较麻烦
增加系统抽象性和理解难度