一、需求背景
假设现在我们需要在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/
扫一扫
256
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
