switch方法重构案例

面向对象语言开发过程中对于switch语句是很敏感的，大多数switch基本都可以通过多态方式进行重构，从而使程序获得较好的拓展能力，最近项目开发中遇到这样一个案例，在此分享一下。

重构前程序

Java代码

1. public void update(Request newReq){
3. Request existReq=dao.getExist();
4. Type _type=newReq.getMsgType();//Type为枚举类型
5. ...
6. switch (_type) {
7. case A_MSG:
8. existMsg = methodA(existReq);
9. case B_MSG:
10. existMsg = methodB(existReq, newReq);
11. case C_MSG:
12. if(...) {existReq = methodA(existReq);}
13. else { existReq=methodB(existReq, newReq);}
14. }

public void update(Request newReq){                       Request existReq=dao.getExist();               Type _type=newReq.getMsgType();//Type为枚举类型               ...                switch (_type) {                    case A_MSG:                        existMsg = methodA(existReq);                    case B_MSG:                        existMsg = methodB(existReq, newReq);                    case C_MSG:                        if(...) {existReq = methodA(existReq);}                        else { existReq=methodB(existReq, newReq);}                }

Java代码

1. dao.update(existReq);

                dao.update(existReq);}

Java代码

根据重构一般原则需要对_type进行抽象并建立继承关系，这里命名基类为MsgType

Java代码

1. public abstract MsgType{
2. protected Request methodA(Request existReq,
3. Request newReq) {
4. ...
5. }
8. protected Request methodB(Request existReq) {
9. ...
10. }
12. public abstract Request changeRequest(Request existReq, Request newReq);
13. }

public abstract MsgType{protected Request methodA(Request existReq,Request newReq) {...}protected Request methodB(Request existReq) {...}public abstract Request changeRequest(Request existReq, Request newReq); }

Java代码

1. 然后针对各Msg类型建立相应子类，并实现changeRequest方法

然后针对各Msg类型建立相应子类，并实现changeRequest方法

Java代码

1. public AMsgType extends MsgType{
3. public Request changeRequest(Request existReq, Request newReq){
4. return super.methodA();
5. }
6. }

public AMsgType extends MsgType{public  Request changeRequest(Request existReq, Request newReq){              return super.methodA();   }}

Java代码

1. public BMsgType extends MsgType{
3. public Request changeRequest(Request existReq, Request newReq){
4. return super.methodB();
5. }
6. }

public BMsgType extends MsgType{public  Request changeRequest(Request existReq, Request newReq){              return super.methodB();   }}

Java代码

之后创立一个工厂方法，注意，这里仍然有一个switch，因为我们需要根据msgType来创建相应的type类。

Java代码

1. public class MsgTypeFactory {
3. public static MsgType createMsgType(Request newReq) {
4. switch (newReq.getMsgType()) {
5. case A_MSG:
6. return new AMsgType();
7. case B_MSG:
8. return new BMsgType();
9. case C_MSG:
10. return new CMsgType();
11. default:
12. throw new RuntimeException("不兼容消息类型:"+newReq.getMsgType());
13. }
14. }
15. }

public class MsgTypeFactory {public static MsgType createMsgType(Request newReq) {switch (newReq.getMsgType()) {case A_MSG:return new AMsgType();case B_MSG:return new BMsgType();case C_MSG:return new CMsgType();default:throw new RuntimeException("不兼容消息类型:"+newReq.getMsgType());}}}

工具已经齐备，可以向原程序开炮了，重构后程序如下：

Java代码

1. public void update(Request newReq){
3. Request existReq=dao.getExist();
4. MsgType msgType=MsgTypeFactory.createMsgType(newReq);
6. //根据不同消息类型做不同作更新操作
7. existReq=msgType.changeRequest(existReq, newReq);
9. dao.update(existReq);
10. }

 public void update(Request newReq){                       Request existReq=dao.getExist();               MsgType msgType=MsgTypeFactory.createMsgType(newReq);        //根据不同消息类型做不同作更新操作      existReq=msgType.changeRequest(existReq, newReq);               dao.update(existReq);}

之前还对factory里面的switch方法耿耿于怀，以为重构前功尽弃，但是仔细一想，其实现在的程序已经完成了service层的解耦，当有一个新Msg类型添加的时候只需要增加相应的子类，在工厂方法配制一下就可以了，同样当对某个msg变更处理策略时也可以控制在很小的修改范围。

据此，我的结论是：重构过程不是一个教条的过程，或许最后还是没办法完全消灭switch，但是重构的目的达到了就已经算是成功。