策略模式，重构if-else

       最近完成了我们公司的公众号开发，在微信消息路由选择的时候一开始都是用if-else 来判断，后面if-else月写越多显得十分的乱。在网上简单查了一下解决方法，果然有不少干货，感觉最经典最简洁的还是使用策略模式来重构过多的if-else 选择。

首先我们新建一个interface

public interface InnerCommand {
    void process(String msg);
}

　  然后把每一个if逻辑都单独抽取到一个类里面如

/**
 * @author lee.
 * @date 2019/5/24 15:53
 */
@Service
public class PrintAdminCommand implements InnerCommand {
    @Override
    public void process(String msg) {
        System.out.println("PrintAdminCommand");
    }
}

      这里就不一一列举了。

      然后我们这里新建一个enum CommonCode

/**
 * @author lee.
 * @date 2019/5/24 15:51
 */
public enum CommonCode {

    USER("user", "用户", "com.yumstone.invoiceapply.Command.impl.PrintUserCommand"),
    ADMIN("admin", "管理员", "com.yumstone.invoiceapply.Command.impl.PrintAdminCommand");
    private String code;
    private String desc;
    private String clazz;
    private static final Map<String, String> classes = new HashMap<String, String>();

    static {
        for (CommonCode refer : CommonCode.values()) {
            classes.put(refer.getCode(), refer.getClazz());
        }
    }

     CommonCode(String code, String desc, String clazz) {
        this.code = code;
        this.desc = desc;
        this.clazz = clazz;
    }

    public static Map<String, String> getAllClazz() {
        return classes;
    }
    public static String getDescByCode(int code) {
        return classes.get(code);
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
    public String getClazz() {
        return clazz;
    }
    public void setClazz(String clazz) {
        this.clazz = clazz;
    }
}

       这里我们可以看到枚举类里面有一个静态代码块在程序一开始执行的的时候就会把类和对应的code 加载到内存中。

      再然后我们新建一个组件处理根据不同的code获取不同的处理类，

/**
 * @author lee.
 * @date 2019/5/24 15:59
 */
@Component
public class InnerCommandContext {
    @Autowired
    ApplicationContext applicationContext;

    public InnerCommand getInstance(String command) {
        //getAllClazz
        Map<String, String> allClazz = CommonCode.getAllClazz();
        String clazz = allClazz.get(command);
        InnerCommand innerCommand = null;
        try {
            if (clazz==null||clazz.length()==0) {
                clazz = PrintAdminCommand.class.getName() ;
            }
            innerCommand = (InnerCommand)applicationContext.getBean(Class.forName(clazz));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return innerCommand;
    }
}

       这里我们可以看到获取的类是通过反射在spring容器里面找到的。好了到这里我们的准备工作就做完了最后写我们的逻辑部分。

/**
 * @author lee.
 * @date 2019/5/24 16:06
 */
@RestController
public class TextController {
    @Autowired
    InnerCommandContext innerCommandContext;
    @RequestMapping("text")
    public String test(@RequestParam String name){
        InnerCommand innerCommand = innerCommandContext.getInstance(name);
        innerCommand.process(name);
        return "ok" ;
    }
}

       是不是特别简洁 原来可能很多if-else 的判断现在被优化成了两行代码

  InnerCommand innerCommand = innerCommandContext.getInstance(name);
  innerCommand.process(name);
  总结程序在启动的时候会把所有的逻辑类的类名加载到内存中，然后通过code找到所需的类型通过反射构建出来，最后就可以执行所需要处理的业务了，在新增一个逻辑只需要新增一个

InnerCommand 的实现类并且添加到枚举类里面去就行了。然后就可以通过该类型的code来获取。

 

转载于:https://www.cnblogs.com/Kevinmanlee/p/11297673.html