简单工厂、工厂方法、抽象工厂和策略模式

?摘要

本文简介软件开发过程中面临的痛点，几个总体原则。详细介绍了简单工厂、工厂方法、抽象工厂和策略模式的视线，以及各种模式之间的类似、区别。

背景

开发面临哪些问题（痛点）？

相信做过大型软件开发的tx都遇到过以下类似问题。在原有代码基础上扩展新功能，需修改历史代码，又会影响已交付功能。且还需同步修改测试用例。debug时则陷入“无尽”的方法调用、分支逻辑判断中。

软件开发大致包括扩展软件新功能、维护旧功能、测试和debug。如何减少上述过程耗费的时间精力，是设计模式方法论的最终目的：降低软件开发、测试、变更、维护成本。

代码需具备哪些特性（需求）？

代码需具备高内聚，低耦合总特性才能减缓软件开发中面临的痛点。代码结构清晰易看懂，易维护、可复用，容易扩展，且灵活性好。

tips：如何学习设计模式？

• 学习过程中，一定要按照自己对知识的理解，独立输出一份可以表达某一种模式思想的toy代码。
• 有开发经验的同学，可以从软件开发过程中遇到的痛点、需求出发，尝试用不同的设计模式解决相同的问题，思考总结出各种设计模式之间的联系和区别，而不是生搬硬套。

总体原则

单一职责

一个类/方法应该仅有一个引起它变化的原因

开放-封闭原则

软件实体（类、模块、函数等）应该可以扩展，但不可修改。已完成的抽象应尽可能覆盖后续可能的变化

依赖倒置原则

高层不应该依赖底层模模块，两者都应依赖抽象接口

抽象不应该依赖细节。细节应该依赖抽象。针对接口编程而非实现编程

里氏替换原则

子类必须能替换它们的父类

只有当子类可以替换父类，父类才能真正被复用，子类也能够在父类基础上增加新的行为。例如：在软件设计领域，鸟会飞，企鹅不会飞，企鹅不是鸟的子类，两者没有继承关系

tips：实现总体原则的方法论：24个设计模式

23 种设计模式详解（全23种） - 知乎

设计模式的目的是开发出高内聚、低耦合的软件系统，高内聚、低耦合离不开面向对象中封装、继承、多态特性。封装、继承、多态在java中的实现则是类、接口父子类、接口引用不同实现对象。

面向对象三大特性：封装、继承、多态。

• 封装，即隐藏对象的属性和实现细节，仅对外公开接口。将数据（属性）和操作数据的行为（方法）组合为类。
• 继承，即已有的类中派生出新的类，新的类具备已有类的数据属性和行为，并能扩展新的能力
• 多态，即可以用一种类型的变量引用另一种类型的对象，例如在java中，接口可以引用不同接口实现类对象。

简单工厂模式

简单工厂类通过输入参数创建具体对象的模式，简化client调用负担。简单工厂类不必单独创建，可结合在其他类中。

适用于接口/父类有多个实现/子类、且可能继续扩展的创建对象（关注点在创建对象）的场景

?需求举例

实现加法、减法、乘法、除法，后续还可能扩展根号、乘方等

?分析

定义操作符父类，实现不同加、减等子类，简单工厂方法根据输入参数创建并返回不同的操作符子类。后续扩展，只需新增子类，并在简单工厂类中新增条件分支。

Java实现

抽象操作符父类

定义操作符父类，抽象出getResult()方法

public abstract class Operation {
    private double numberA = 0;
    private double numberB = 0;

/**省略get和set方法*/
    public double getResult(){
        return 0;
    }
}

加法子类

加法子类实现操作符父类的getResult()方法

public class AddOperation extends Operation{
    @Override
    public double getResult(){
        return super.getNumberA() + super.getNumberB();
    }
}

简单工厂类

简单工厂类封装client需要判断的逻辑，根据传入参数返回不同的操作符子类对象。

public class OperationFactory {
    public static Operation createOperation(String opr){
        Operation operation = null;
        switch (opr){
            case "+":
                operation = new AddOperation();
                break;
            default:
        }
        return operation;
    }
}

客户端调用

 public static void main(String[]args){
        Operation opr ;
        opr = OperationFactory.createOperation("+");
        opr.setNumberA(1);
        opr.setNumberB(2);
        System.out.println(opr.getResult());
    }

扩展新功能

扩展减法子类

减法子类实现操作符父类的getResult()方法

public class SubOperation extends Operation{
    @Override
    public double getResult(){
        return super.getNumberA() - super.getNumberB();
    }
}

修改简单工厂类

简单工厂类扩展case条件分支，提供创建减法操作对象功能

    public static Operation createOperation(String opr){
        Operation operation = null;
        switch (opr){
            case "+":
                operation = new AddOperation();
                break;
            case "-"://添加减法类
                operation = new SubOperation();
                break;
            default:

        }
        return operation;
    }

存在的问题？

新增操作符子类，需要修改简单工厂类，添加case语句。扩展新业务需要修改历史业务代码，不符合“开闭原则”。后续工厂方法模式，通过抽象工厂类接口，满足“开闭原则”。

策略模式

定义不同算法簇并分别封装，不同算法之间可相互替换，算法的变化不会影响使用算法的人

适用于同一个类中出现不同的业务规则场景，通过策略模式封装处理不同变化。

不同的行为堆砌在一个类中，很难避免用条件语句选择合适行为，将行为封装在独立的strategy类中，可在类中消除条件语句。

Java实现

策略接口

public interface IStrategy {
    double algorithm(double money);
}

业务策略1

public class CashReturn implements IStrategy{
    private double moneyCondition = 0.d;
    private double moneyReturn  = 0.d;
    public CashReturn(double moneyCondition,double moneyReturn){
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }
    @Override
    public double algorithm(double money) {
        if(money > moneyCondition){
            return money - Math.floor( money/moneyCondition) * moneyReturn;
        }
        return money;
    }
}

业务策略2

public class CashRebate implements IStrategy{
    private double rebate = 1d;

    public CashRebate(double rebate){
        this.rebate = rebate;
    }

    @Override
    public double algorithm(double money) {
        return money*rebate;
    }
}

策略上下文类

public class CashContext {
    IStrategy strategy;
    public CashContext(String type){
        switch (type){
            case "discount":
                strategy = new CashRebate(0.8);
                break;
            case "return":
                strategy = new CashReturn(200,30);
                break;
            default:
        }
    }

    public double getResult(double money){
        return strategy.algorithm(money);
    }
}

client调用

    public static void main(String[]args){
        double inputMoney = 100;
        String type = "discount";
        //1.简单工厂方法：类型为参数通过工厂方法返回不同计算对象，对象计算最终值。
        //client需要使用工厂类  +  不同计算类
        //2.类型作为参数，通过上下文对象，直接获取最终值。将不同计算对象封装入上下文对象。
        //client只需要使用上下文类。
        double outputMoney = new CashContext(type).getResult(inputMoney);
        System.out.println(outputMoney);
    }

简单工厂和策略模式区别

策略模式将简单工厂创建对象过程封装在上下文类内部，不再对外暴露具体对象，降低了client使用类的难度。本质是在继承、多态的基础上新增了一层上下文类，达到client和业务逻辑类之间的解耦。

具体选择：从业务角度考虑，如果仅创建对象，使用工厂模式。如果业务存在不同的规则，使用策略模式。

从侧重点理解：

• 简单工厂关注对象的创建。例如实例化不同对象。
• 策略模式关注业务行为封装。例如实现某一系列算法。

从client角度理解：

• 简单工厂先实例化对象，再调用对象的方法
• 策略模式直接调用上下文对象的方法。实例化对象放在了上下文类中。

从测试角度理解：

• 简单工厂模式需要测试对象的每个方法
• 策略模式只需要调用上下文对象的方法即可

工厂方法模式

定义创建对象的工厂接口，让类的实例化延迟到工厂子类。工厂方法模式，通过抽象出工厂接口，解决了简单工厂模式无法满足“开闭原则”的问题。

需求举例?

同样以简单工厂模式中介绍的加、减操作实现为例。

Java实现

操作符父类

定义操作符父类抽象方法getResult()

public abstract class IOperation {
    public double numA = 0;
    public double numB = 0;
    abstract double getResult();
}

加法子类

定义加法操作符子类，并实现getResult()

public class AddOperation extends IOperation{
    public AddOperation(double numA,double numB){
        super.numA = numA;
        super.numB = numB;
    }
    @Override
    public double getResult() {
        return numA + numB;
    }
}

工厂方法接口

定义工厂类接口createOperation()

public interface IFactory {
    IOperation createOperation(double numA,double numB);
}

加法工厂子类

定义加法工厂子类，并实现createOperation()方法

public class AddFactory implements IFactory{
    @Override
    public IOperation createOperation(double numA,double numB) {
        return new AddOperation(numA,numB);
    }
}

客户端调用

public static void main(String[]args){
        IOperation opr = new AddFactory().createOperation(1,3);
        System.out.println(opr.getResult());
    }

扩展新功能

减法子类

public class SubOperation extends IOperation{
    public SubOperation(double numA,double numB){
        super.numA = numA;
        super.numB = numB;
    }
    @Override
    public double getResult() {
        return numA - numB;
    }
}

减法工厂子类

public class SubFactory implements IFactory{
    @Override
    public IOperation createOperation(double numA,double numB) {
        return new SubOperation(numA,numB);
    }
}

优缺点

满足开放封闭原则

• 扩展新业务，例如新增减法操作，只需新增减法子类和减法工厂子类，无需修改历史代码。
• client调用，仅需修改new AddFactory()为new SubFactory()。

?业务扩展产生过多工厂子类

不同于简单工厂模式，新增业务只需增加switch分支，工厂方法模式新增业务需要新增工厂子类。不断扩充业务时，工厂子类也会不断扩充冗余。

简单工厂与工厂方法区别

• 简单工厂使用工厂类直接创建对象，而工厂方法则定义工厂接口，工厂子类负责创建对象。
• 简单工厂不满足“开闭原则”，工厂方法满足。
• 简单工厂扩充业务无需新增工厂类，工厂方法会不断扩充工厂子类。

抽象工厂模式

抽象工厂模式，类似工厂方法模式，提供创建不同种类对象的接口方法。例如提供创建A对象、B对象方法。

?需求举例

支持sqlserver、access类型数据库连接user表、department表，后续还可能扩展mysql方式，以及其他表

?分析

目的是方便替换不同访问数据库的方式，因此需要在访问数据库方式上使用继承和多态特性。需要抽象出顶层接口，创建不同方式访问对象。具体实现思路：

1. 抽象出user、department表行为接口，分别以sqlserver、access方式实现上述的表接口。
2. 工厂模式创建user、department对象
3. client利用工厂方法直接调用user、department行为接口

Java实现

user、department接口和实现

//接口定义
public interface IUserService {
    User getUser();
}

//Access实现
public class AccessUser implements IUserService {
    @Override
    public User getUser() {
        System.out.println("访问access get user");
        return null;
    }
}

//Sqlserver实现
public class SqlserverUser implements IUserService {
    @Override
    public User getUser() {
        System.out.println("访问Sqlserver get user");
        return null;
    }
}

//接口定义
public interface IDepartmentService {
    Department getDepartment();
}

//Access实现
public class AccessDepartment implements IDepartmentService {
    @Override
    public Department getDepartment() {
        System.out.println("访问access get department");
        return null;
    }
}
//Sqlserver实现
public class SqlserverDepartment implements IDepartmentService {

    @Override
    public Department getDepartment() {
        System.out.println("访问Sqlserver get department");
        return null;
    }
}

优化简单工厂类

使用反射替代switch条件语句，且反射的参数值，还可以通过配置文件得到。达到了解耦+开闭原则。

public class DataAccessFactory {
//根据变量的值，选择Access或Sqlserver方式访问数据库。该值可以写入配置文件中，更加方便
    String dbAccessMethod = "test.factory.abstfactory.impl.access.";
    public IUserService createUserService() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        String className =dbAccessMethod + "AccessUser";
        Class clazz = Class.forName(className);
        return  (IUserService) clazz.getDeclaredConstructor().newInstance();
    }

    public IDepartmentService creteDeparmentService() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        String className =dbAccessMethod + "AccessDepartment";
        Class clazz = Class.forName(className);
        return (IDepartmentService) clazz.getDeclaredConstructor().newInstance();
    }
}

??client调用

public static void main(String[]args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
        DataAccessFactory dataAccess = new DataAccessFactory();

        IUserService userService = dataAccess.createUserService();
        userService.getUser();

        IDepartmentService departmentService = dataAccess.creteDeparmentService();
        departmentService.getDepartment();
    }

优缺点

抽象工厂类似工厂方法，但是抽象工厂提供多个接口。扩展业务时新增工厂子类，造成工厂类簇冗余，但是具备开闭原则。而简单工厂模式扩展业务时，只需在工厂类中新增判断分支，不需要新增工厂子类，但是不能满足开闭原则。

抽象工厂总结?

在抽象工厂模式中，可以使用简单工厂模式中的工厂类 + 反射技术，替换简单工厂方法中switch分支语句，再+配置文件，可以将反射需要的变量配置在配置文件中。这种方式解决了工厂类冗余问题，又满足开闭原则