​ 在开发中我们经常会碰到有些场景,需要根据某个字段的不同含义,去执行不同的逻辑操作,一般我们会倾向于使用if/else或者switch/case的方式,但当字段的含义不断增加,或者各种含义情况都需要执行非常多逻辑的时候,使用if/else/switch会使代码不易维护,且可读性差。那么,使用枚举,将是一种非常好的改善方式。

​ 举例:当不同角色去审批员工请假单时,执行的逻辑是不一样的,比如直属小组长需要确认员工的工作进度是否正常,工作交接是否正常,而团队负责人要确认总项目进度是否有影响等等。如果使用if/else的方式,我们的代码会是如下这样:


public void judge(Long applyId, String role){
        if (role.equals("leader")) {
            //leader doing
        } else if (role.equals("service owner")) {
            //service owner doing
        } else if (role.equals("project manager")) {
            //project manager doing
        } else if (role.equals("supervisor")) {
            //supervisor doing
        }

​ 后续如果再增加人物角色,会不断增多if/else,有代码洁癖的会很难受。。一旦角色数量达到几十的时候,看代码估计要疯。。非常不利于扩展和维护。

接下来我们使用java枚举的方式改造一下。首先定义一个公用接口:

public interface RoleService {

    //审批操作,后续增加其他操作只需要再新建方法
    void approve();
}

​ 接下来我们定义一个不同角色执行不同逻辑的枚举类 RoleServiceEnum来实现接口,将不同角色的逻辑全部交由这个枚举类来做:

public enum RoleServiceEnum implements RoleService {
    ROLE_LEADER(){
        @Override
        public void approve() {
            System.out.println("leader doing sth");
        }
    },

    ROLE_SERVICE_OWNER(){
        @Override
        public void approve() {
            System.out.println("so doing sth");
        }
    },

    ROLE_PROJECT_MANAGER(){
        @Override
        public void approve() {
            System.out.println("pm doing sth");
        }
    },

    ROLE_SUPERVISOR(){
        @Override
        public void approve() {
            System.out.println("supervisor doing sth");
        }
    };
 接下来我们再调用这个枚举类,执行不同角色审批请假单的逻辑,一行代码就行了: 
 public void judge(String role){
        RoleServiceEnum.valueOf(role).approve();
}

使用工厂模式:

​ 不同分支做不同的事情,很明显就提供了使用工厂模式的契机,我们只需要将不同情况单独定义好,然后去工厂类里面聚合即可。

​ 首先,针对不同的角色,单独定义其业务类:

public class RootAdminRole implements Roleoperation {
    private String roleName;

    public RootAdminRole(String roleName) {
        this.roleName = roleName;
    }

    @Override
    public String op() {
        return roleName+"系统管理员操作权限";
    }
}
public class OrderAdminRole implements Roleoperation {
    private String roleName;

    public OrderAdminRole(String roleName) {
        this.roleName = roleName;
    }

    @Override
    public String op() {
        return roleName+"订单管理员操作权限";
    }
}
public class NormalRole implements Roleoperation {
    private String roleName;

    public NormalRole(String roleName) {
        this.roleName = roleName;
    }

    @Override
    public String op() {
        return roleName+"普通用户操作权限";
    }
}

接下来再写一个工厂类RoleFactory对上面不同角色进行聚合:

public class RoleFactory {
   static Map<String,Roleoperation> roleoperationMap = new HashMap<>();
    static {
        roleoperationMap.put("ROOT_ADMIN",new RootAdminRole("ROOT_ADMIN"));
        roleoperationMap.put("ORDER_ADMIN",new RootAdminRole("ORDER_ADMIN"));
        roleoperationMap.put("NORMAL",new RootAdminRole("NORMAL"));
    }
    public static Roleoperation getOp(String roleName){
        return roleoperationMap.get(roleName);
    }

接下来借助上面这个工厂,业务代码调用也只需要一行代码,if/else同样被消除了

RoleFactory.getOp("ROOT_ADMIN").op()

这样的话以后想扩展条件也很容易,只需要增加新代码,而不需要动以前的业务代码,非常符合“开闭原则”。


一个好奇的人