一、需求背景

假设现在我们需要在web页面中，实现一个简单计算器，满足2个数值的（加，减，乘，除）运算。

1）最简单的实现方法

考虑到示例仅仅是为了表述核心的思想或者说代码思路，所以没有做太多的数值合法性等校验判断。

//伪代码，模拟web服务的控制器，实际可能是servlet或者其他
public class CalcController extends Controller{
    public void calc(double firstNum, double secondNum, String operate){
        double result = 0d;
        if ( "+".equals ( operate ) ) {
            result = firstNum + secondNum;
        } else if ( "-".equals( operate ) ){
            result = firstNum - secondNum;
        } else if ( "*".equals( operate ) ){
            result = firstNum * secondNum;
        } else if ( "/".equals( operate )){
            result = firstNum / secondNum;
        }else{
            result = 0d;
        }
        //伪代码，模拟将结果输出返回到html页面
        renderHtml("/view/calc.html",result);   
    }
}

上面最简单的实现方法，运行上是满足需求了。
那么现在我们又来了一个需求，另外一个功能模块中，也要实现相同的功能，需要一个计算器。那么，现在我们怎么办？把代码复制一份到另外一个XxxController中去？
显然，既然都是相同的功能，复制一份过去，虽然可以满足需求，但是日后维护起来，会带来很多的麻烦。
所以，进一步优化后，代码可以写成这样。

//我们可以将计算的业务，单独重构成一个独立的运算函数，将计算和页面处理逻辑进行分离，这样其他的页面就可以复用这个计算函数
public class CalcUtil {
    public static double getResult(double firstNum, double secondNum, String operate){
        if ( "+".equals ( operate ) ) {
            return firstNum + secondNum;
        } else if ( "-".equals( operate ) ){
            return firstNum - secondNum;
        } else if ( "*".equals( operate ) ){
            return firstNum * secondNum;
        } else if ( "/".equals( operate )){
            return firstNum / secondNum;
        }else{
            return 0d;
        }
    }
}

然后原先的页面控制器CalcController可以改写成这样：

//伪代码，模拟web服务的控制器，实际可能是servlet或者其他
public class CalcController extends Controller{
    public void calc(double firstNum, double secondNum, String operate){
        //通过重构，将计算逻辑，分离到一个独立的工具类中
        double result = CalcUtil.getResult(firstNum, secondNum, operate);
        //伪代码，模拟将结果输出返回到html页面
        renderHtml("/view/calc.html",result);   
    }
}

这样改完之后，我们的代码也变的简单了，并且将运算逻辑和页面逻辑进行了分离。
但是，现在如果我们的需要发生一些变化，我们需要增加次方运算，怎么办？
首先我们最先想到的办法就是，在CalcUtil的getResult方法中，增加一个if else的判断就好了。
嗯，这个办法没毛病，也是最直接可行的办法。我们这边的示例中，运算逻辑很简单，如果我们的运算逻辑是非常复杂的运算，那么我们增加一个if的判断分支，会使代码的可阅读性变的更差，同时，如果一个不小心，在增加判断时，引入了一个bug的话，那么会直接导致整个运算函数出现不可知的结果，这个是非常可怕的。
那么，这个时候我们就可以考虑，将加、减、乘、除，各个运算逻辑进行分离，独立处理自己的逻辑。如果需要增加次方运算，我们只要增加一套运算逻辑，可能会有bug，但是如果出现了bug，并不会导致其他运算出错。

//我们通过分析发现，加、减、乘、除运算，除了运算公式不同，其他的部分是相同的
//所以我们可以考虑提出一个抽象的运算类
public class Operator {
    private double firstNum;
    private double secondNum;
    
    public double getResult(){
        return 0d;
    }

    public double getFirstNum() {
        return firstNum;
    }

    public double getSecondNum() {
        return secondNum;
    }

    public void setFirstNum(double firstNum) {
        this.firstNum = firstNum;
    }

    public void setSecondNum(double secondNum) {
        this.secondNum = secondNum;
    }
}

//加运算
//继承于Operator运算类，并且重写了getResult()方法
public class AddOperator extends Operator{
    @Override
    public double getResult(){
        return getFirstNum() + getSecondNum();
    }
}

//减运算
//继承于Operator运算类，并且重写了getResult()方法
public class SubtractOperator extends Operator{
    @Override
    public double getResult(){
        return getFirstNum() - getSecondNum();
    }
}

//乘运算
//继承于Operator运算类，并且重写了getResult()方法
public class MultiplyOperator extends Operator{
    @Override
    public double getResult(){
        return getFirstNum() * getSecondNum();
    }
}

//除运算
//继承于Operator运算类，并且重写了getResult()方法
public class DivideOperator extends Operator{
    @Override
    public double getResult(){
        return getFirstNum() / getSecondNum();
    }
}

然后，我们需要修改我们的CalcUtil的运算函数

public class CalcUtil {
    public static double getResult(double firstNum, double secondNum, String operate){
        Operator oper = null;
        if ( "+".equals ( operate ) ) {
            oper = new AddOperator();
        } else if ( "-".equals( operate ) ){
            oper = new SubtractOperator();
        } else if ( "*".equals( operate ) ){
            oper = new MultiplyOperator();
        } else if ( "/".equals( operate )){
            oper = new DivideOperator();
        }
        oper.setFirstNum(firstNum);
        oper.setSecondNum(secondNum);
        return oper.getResult();
    }
}

改完之后，我们的页面逻辑部分，代码什么都不需要改，就可以继续运行了。
但是，我们来看目前我们是将整个的判断逻辑，放到了CalcUtil的getResult函数中，我们是否可以将这个函数的功能指责划分的更清晰一些呢？
这个时候，就是我们引入工厂模式的时候了，我们可以考虑创建一个Operator的工厂，这个工厂的职责就是生成我们要用的Operator实例。

public class OperatorFactory {
    public static Operator createOperator(String operate){
        Operator oper = null;
        if ( "+".equals ( operate ) ) {
            oper = new AddOperator();
        } else if ( "-".equals( operate ) ){
            oper = new SubtractOperator();
        } else if ( "*".equals( operate ) ){
            oper = new MultiplyOperator();
        } else if ( "/".equals( operate )){
            oper = new DivideOperator();
        }
        return oper;
    }
}

我们看到OperatorFactory就是根据我们的需要的运算类型，产生对应的Operator实例。
我们的CalcUtil就可以继续重构

public class CalcUtil {
    public static double getResult(double firstNum, double secondNum, String operate){
        Operator oper = OperatorFactory.createOperator(operate);
        oper.setFirstNum(firstNum);
        oper.setSecondNum(secondNum);
        double result = oper.getResult();
        return result;
    }
}

这样我们的工厂模式的实验就做完了，除了CalcController是一个伪代码外，其他的实例都是可以编译运行的。如果我们需要测试，我们可以写一个main方法进行测试

public class MainTest {
    public static void main(String[] args) {
        double result = CalcUtil.getResult(10, 9.8, "+");
        System.out.println(result);
    }
}

©声明：除非注明，本站所有文章皆为原创，转载请以链接形式标明本文地址。
©转载请注明来源：https://www.rjkf.cn/design-pattern-factory/