通过java示例学习设计模式-(1)工厂模式

一、需求背景

假设现在我们需要在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/