大蕉蕉的三道 Java 私房菜 No.131

大蕉蕉每个月写这么多 Java 代码呢，也存着很多私房菜，也总结下给大家玩玩，用完保证代码量 biu biu biu 飙升，信我。

Top1 : ResultExecutor + ResultDTO 组合

首先说下为什么会出现这个组合，这个组合我是在第二份工作的时候才学到的。不知道大家还有没有印象，很多时候我们写一些接口的时候，有可能会给调用方返回一个非常鸡肋的 500 错误。使用了这个组合，能从根本上解决 500 错误。这个组合对于错误异常等的封装非常好，写法规范，值得学习。希望大家也在自己的项目里整一个，从此告别500错误，反正我是再没见过500了。

这个组合定义了一个 ResultExecutor 的抽象 run 方法，用来解决怎么处理以及返回什么参数的问题，在使用的时候直接使用匿名类的方式实现自己想要的业务逻辑就好了。

第二呢，用一个 ResultDTO 将返回的结果规范化起来，这也保证了无论我们程序逻辑是怎样的，业务方肯定能获取到一个结果，至于结果是success 还是 fail，需要业务方通过字段来确认。

public abstract class ResultExecutor<T> {
   
   abstract T run();
   public ResultDTO<T> execute(){
      try{
         T runResult = run();
         ResultDTO<T> result = new ResultDTO<>();
         result.setSuccess(true);
         result.setData(runResult);
         return result;
      }catch (Throwable t){
         ResultDTO<T> result = new ResultDTO<>();
         result.setSuccess(false);
         return result;
      }
   }

}

public class ResultDTO<T> {
   private T data;
   private Boolean success;
}

public class BananaService {
   public ResultDTO<Boolean> runSomeThing(){
      return new ResultExecutor<Boolean>() {
         @Override
         Boolean run() {
            /**
             * 写逻辑
             */
            return true;
         }
      }.execute();
   }
}

Top2 : Center+Processor 组合

这个组合呢，好处就是能把很多的逻辑不同阶段的数据处理，拆分到不同的类里边去编写，这对于代码逻辑的解耦能起到非常非常好的作用，这对于状态机类的处理非常友好，因为状态机可能有几十个状态需要一一处理，如果都写在同一个类里那可能 if else 马上把你绕晕了。

这个呢，在一些分类比较多的场景，也建议你尝试一下，拓展性非常非常好。而且这个套路可以一直往下套，可以往下套个三四层什么的。

public class ExecuteCenter {
   @Resource
   Set<BaseExecuteProcessor> processorSet;
   public void execute(String type,String params){
      for(BaseExecuteProcessor executeProcessor :getProcessors(type)){
         executeProcessor.execute(params);
      }
   }
   
   private List<BaseExecuteProcessor> getProcessors(String type){
      return processorSet.stream().filter(processor -> type.equals(processor.getSupportType())).collect(Collectors.toList());
   }
}

public interface BaseExecuteProcessor {
   String getSupportType();
   void execute(String params);
}

Top3 : Enum + swith 组合

这个我真的是很喜欢，在很多地方，只要需要根据某个枚举的状态来做一些额外的处理，到了一定程度，又不想写太多类去处理这些问题，我就用 Enum + Switch 来解决。

好处就是，无论功能有多少有多深，入口是统一的，添加一个枚举类型几乎毫无成本，更改一个不会影响到其他的分支实现。

public enum SomeTypeEnum {
   T1,T2,T3,T4;
   public void main(String[] args){
      String type = "T1";
      SomeTypeEnum someTypeEnum = SomeTypeEnum.valueOf(type);
      switch (someTypeEnum){
         case T1:{
            executeT1();break;
         }
         case T2:{
            executeT2();break;
         }
         default:{
            
         }
      }

   }

   private void executeT1(){}
   private void executeT2(){}
}

就酱，我不知道你喜不喜欢，我反正每天都在写。