Java代码整洁-消除ifelse

繁琐的ifelse

先看一个ifelse的逻辑判断

/**
 * 根据角色判断有什么权限
 * if else 逻辑简单，但如果角色有十几个时，判断就会变得很繁琐，我们可以使用一些特殊的处理方法使ifelse变得简洁
 *
 * @param roleName
 * @return
 */
public String judge(String roleName) {
    String result = "";
    if ("ROLE_ADMIN".equals(roleName)) {
        result = "ROLE_ADMIN has AAA permission";
    } else if ("ROLE_HR".equals(roleName)) {
        result = "ROLE_HR has BBB permission";
    } else if ("ROLE_NORMAL".equals(roleName)) {
        result = "ROLE_NORMAL has CCC permission";
    } else {
        result = "other";
    }
    return result;
}

public static void main(String[] args) {
    String hrPermission = new ComplexIfElse().judge("ROLE_HR");
    System.out.println(hrPermission);
}

使用ifelse判断，当判断的数量较少的时候确实比较清晰，但当超过一定数量以后，ifelse就会变得很繁琐，维护起来成本很高，我们可以使用一些特殊处理去消除ifelse，使代码维护起来方便

使用枚举优化

• 先定义一个角色的操作接口，RoleOperator

public interface RoleOperation {
    String operate();
}

• 定义枚举

public enum RoleEnum implements RoleOperation{
    // role admin
    ROLE_ADMIN {
        public String operate() {
            return "ROLE_ADMIN has AAA permission";
        }
    },
    ROLE_HR {
        public String operate() {
            return "ROLE_HR has BBB permission";
        }
    },
    ROLE_NORMAL {
        public String operate() {
            return "ROLE_NORMAL has CCC permission";
        }
    },
    ROLE_OTHER {
        public String operate() {
            return "ROLE_OTHER has DDD permission";
        }
    };
}

• 在进行角色判断判断的时候就变得方便了

public class Main {

    /**
     * 使用枚举优化后，再进行判断就会变得比较方便简洁了
     *
     * @param roleName
     * @return
     */
    public String judge(String roleName) {
        return RoleEnum.valueOf(roleName).operate();
    }

    public static void main(String[] args) {
        System.out.println(new Main().judge("ROLE_HR"));
    }
}

使用工厂模式

• 先定义各类角色

public class RoleAdmin implements RoleOperation {

    private String roleName;

    public RoleAdmin(){}

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

    public String operate() {
        return roleName + " has AAA permission";
    }
}

public class RoleHR implements RoleOperation {

    private String roleName;

    public RoleHR(){}

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

    public String operate() {
        return roleName + " has BBB permission";
    }
}

public class RoleNormal implements RoleOperation {

    private String roleName;

    public RoleNormal(){}

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

    public String operate() {
        return roleName + " has CCC permission";
    }
}

public class RoleOther implements RoleOperation {

    private String roleName;

    public RoleOther(){}

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

    public String operate() {
        return roleName + " has DDD permission";
    }
}

• 定义一个工厂

public class RoleFactory {

    private static Map<String, RoleOperation> roleOperationMap = new HashMap<String, RoleOperation>(16);

    static {
        roleOperationMap.put("ROLE_ADMIN", new RoleAdmin("ROLE_ADMIN"));
        roleOperationMap.put("ROLE_HR", new RoleHR("ROLE_HR"));
        roleOperationMap.put("ROLE_NORMAL", new RoleNormal("ROLE_NORMAL"));
        roleOperationMap.put("ROLE_OTHER", new RoleOther("ROLE_OTHER"));
    }

    public static RoleOperation getRole(String roleName) {
        return roleOperationMap.get(roleName);
    }
}

• 使用工厂模式判断

public class Main {

    /**
     * 使用工厂模式
     *
     * @param roleName
     * @return
     */
    public String judge(String roleName) {
        return RoleFactory.getRole(roleName).operate();
    }

    public static void main(String[] args) {
        System.out.println(new Main().judge("ROLE_HR"));
    }
}

源码：github.com/solitary-s/…