在开发微服务项目时通常会做一些组件的封装，将公用的功能进行各种抽离单独使用打成一个 jar 包，在需要的服务中直接使用 maven 依赖即可，能够达到优化服务代码的目的。

    但是，也会在各个服务之间也会存在扩展的问题，比如在公用的 jar 中封装统一响应功能。

    在做统一响应时大多数是定义一个枚举响应类，在业务中根据结果进行响应成功与失败。如下：

    • 定义一个结果类：

      1. @Getter
      2. @Setter
      3. @ToString
      4. @EqualsAndHashCode
      5. public class Result<T> {
      7.   private Integer code;
      9.   private String message;
      11.   private T data;
      13.   public Result() {
      14.   }
      16.   public String toJson() {
      17.       return JacksonUtils.toJson(this);
      18.   }
      19. }

    • 定义一个状态码枚举类： ```java public enum BasicErrorCode {

      FAILURE(-1, “Failure”),

      SUCCESS(0, “Success”);

    1. private final int code;
    3. private final String message;
    5. BasicErrorCode(int code, String message) {
    6.     this.code = code;
    7.     this.message = message;
    8. }
    10. public int code() {
    11.     return code;
    12. }
    14. public String message() {
    15.     return message;
    16. }

    }

    2. - 最后再来一个响应工具类：
    3. ```java
    4. public class ResponseMsgUtil {
    6.     private ResponseMsgUtil() {
    7.     }
    9.     private static <T> Result<T> builderResponse(int code, String message, T data) {
    10.         Result<T> result = new Result<>();
    11.         result.setCode(code);
    12.         result.setMessage(message);
    13.         result.setData(data);
    14.         return result;
    15.     }
    18.     /**
    19.      * 请求失败
    20.      */
    21.     public static <T> Result<T> failure() {
    22.         return failure(BasicErrorCode.FAILURE);
    23.     }
    25.     public static <T> Result<T> failure(String message) {
    26.         return builderResponse(BasicErrorCode.FAILURE.code(), message, null);
    27.     }
    29.     /**
    30.      * 请求成功
    31.      */
    32.     public static <T> Result<T> success() {
    33.         return success(BasicErrorCode.SUCCESS.message());
    34.     }
    36.     public static <T> Result<T> success(String message) {
    37.         return success(message, null);
    38.     }
    40.     public static <T> Result<T> success(T data) {
    41.         return success(BasicErrorCode.SUCCESS.message(), data);
    42.     }
    44.     public static <T> Result<T> success(String message, T data) {
    45.         return builderResponse(BasicErrorCode.SUCCESS.code(), message, data);
    46.     }
    48. }

    在使用时返回返回成功或失败，直接使用 ResponseMsgUtil 调用定义的方法即可。比如请求失败：

    1. return ResponseMsgUtil.failure();

    但是微服务架构是分模块的，而在公用类中定义的枚举状态码是完全无法满足不同服务的定制化响应。比如在用户系统中，用户登录账号或密码错误该公用的枚举状态码就无法满足。

    所以就有这么个需求：对枚举进行扩展。

    但是，我们都知道： java 枚举类是一个 final 类，内部定义的枚举值其实都是常量，所以想要使用继承等方式来达到扩展的目的是不可能的事。

    不过呢，我们可以反过来想一种实现方式，那就是面向接口编程。看下下面的例子：

    1. public interface Animal {
    2.     void printName();
    3. }
    5. public class Cat implements Animal {
    6.     @Override
    7.     public void printName() {
    8.         System.out.println("i am a cat");
    9.     }
    10. }
    12. public class Dog implements Animal {
    13.     @Override
    14.     public void printName() {
    15.         System.out.println("i am a dog");
    16.     }
    17. }

    面向接口编程时我们会发现，不管是 Cat 还是 Dog 它都是属于 Animal 这个类型，在作参数传递时我们将参数设置为 Animal 是不是就可以接受这个接口的任何实例了？

    所以，枚举类虽然是个 final 类，但是我们可以定义一个接口，让枚举类去实现它，这样是不是就达到对枚举响应码进行扩展的目的了？

    看下如何处理，我们只需要将开始定义的枚举类做下修改即可：

    • 定义一个枚举接口类：
    1. public interface ErrorCode {
    3.     int code();
    5.     String message();
    6. }

    让枚举状态码实现该接口：

    1. enum BasicErrorCode implements ErrorCode {
    3.     FAILURE(-1, "Failure"),
    5.     SUCCESS(0, "Success"),
    7.     ;
    10.     private final int code;
    12.     private final String message;
    14.     BasicErrorCode(int code, String message) {
    15.         this.code = code;
    16.         this.message = message;
    17.     }
    19.     @Override
    20.     public int code() {
    21.         return code;
    22.     }
    24.     @Override
    25.     public String message() {
    26.         return message;
    27.     }
    28. }

    而响应工具类 ResponseMsgUtil 只需要增加一个方法：

    1. /**
    2.  * 扩展使用
    3.  */
    4. public static <T> Result<T> failure(ErrorCode errorCode) {
    5.     return builderResponse(errorCode.code(), errorCode.message(), null);
    6. }

    在这个扩展方法中接收的参数的类型是 ErrorCode，而该类型是一个接口。这样其他服务如果有扩展枚举响应码需求的话只需要定义一个枚举类实现该接口进行响应的扩展即可，如：

    1. public enum ExampleErrorCode implements ErrorCode {
    3.     // 根据各自服务业务需求在这里定义扩展响应码
    5.     // 如用户系统, 用户密码错误
    6.     USER_OR_PASSWORD_ERROR(10001, "用户名或密码错误"),
    8.     // other
    9.     ;
    11.     // 下面的代码不需要变化, 直接拷贝即可
    13.     private final int code;
    15.     private final String message;
    17.     ExampleErrorCode(int code, String message) {
    18.         this.code = code;
    19.         this.message = message;
    20.     }
    22.     @Override
    23.     public int code() {
    24.         return code;
    25.     }
    27.     @Override
    28.     public String message() {
    29.         return message;
    30.     }
    31. }

    响应：

    1. return ResponseMsgUtil.failure(ExampleErrorCode.USER_OR_PASSWORD_ERROR);

    这样是不是就达到我们的目的了？

    参考资料：Extending Enums in Java