jackJson根据String类型枚举值返回数据返回枚举其余参数

因alibaba阿里巴巴开发手册规定

【强制】二方库里能够定义枚举类型，参数能够使用枚举类型，可是接口返回值不容许使用枚
举类型或者包含枚举类型的 POJO 对象。

因此就用这个方式返回枚举中的其余方法

首先须要添加一个接口给到枚举类实现

import com.common.utils.i18n.I18nUtils;
import com.fasterxml.jackson.annotation.JsonProperty;

public interface BaseEnum {

  /**
   * 获取I8N国际化key
   *
   * @return code
   */
  String key();

  /**
   * 获取存入数据库的值
   *
   * @return value
   */
  String value();

  /**
   * 获取I18N国际化信息
   *
   * @return 国际化信息
   */
  @JsonProperty("Description")
  default String getDescription() {
    return I18nUtils.getEnumMessage(key());
  }

  @JsonProperty("Value")
  default String getValue() {
    return value();
  }
}

而后建立一个注解提供给到序列化识别并获取参数

import com.common.comment.impl.EnumSerializer;
import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 枚举序列化返回参数
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@JacksonAnnotationsInside
@JsonSerialize(using = EnumSerializer.class)
public @interface JaskonEnum {

  Class<?> enumClass();

  String methodName();
}

最后就是jackJson的序列化

import com.common.base.code.BaseExceptionCode;
import com.common.base.enums.BaseEnum;
import com.common.base.excetion.BaseException;
import com.common.comment.JaskonEnum;
import com.common.utils.logger.LoggerUtils;
import com.common.utils.verification.ValidateUtils;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import org.slf4j.Logger;

public class EnumSerializer extends JsonSerializer<String> implements ContextualSerializer {

  private Logger logger = LoggerUtils.logger(getClass());

  private Map<String, String> valueLabelMap;

  public EnumSerializer() {
  }

  public EnumSerializer(Map<String, String> valueLabelMap) {
    this.valueLabelMap = valueLabelMap;
  }

  @Override
  public void serialize(String o, JsonGenerator jsonGenerator, SerializerProvider serializerProvider)
      throws IOException {
    if (ValidateUtils.isEmpty(valueLabelMap)) {
      return;
    }
    jsonGenerator.writeString(o);
    String values = valueLabelMap.get(o);
    if (ValidateUtils.isEmpty(values)) {
      return;
    }
    String[] split = values.split(":");
    jsonGenerator.writeStringField(split[0], split[1]);
  }

  @Override
  public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty)
      throws JsonMappingException {
    if (ValidateUtils.isEmpty(beanProperty)) {
      return serializerProvider.findNullValueSerializer(beanProperty);
    }

    if (!Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
      return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
    }

    JaskonEnum enumLabel = beanProperty.getAnnotation(JaskonEnum.class);
    if (ValidateUtils.isEmpty(enumLabel)) {
      return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
    }
    // key:getValue value:getLabel
    // 枚举类的成员
    BaseEnum[]          enumInstances = (BaseEnum[]) enumLabel.enumClass().getEnumConstants();
    Map<String, String> map           = new HashMap<>(enumInstances.length);
    try {
      String prefix = enumLabel.methodName();
      for (BaseEnum baseEnum : enumInstances) {
        String value       = baseEnum.getValue();
        String description = baseEnum.getDescription();
        map.put(value, new StringBuilder().append(prefix).append(":").append(description).toString());
      }
    } catch (Exception e) {
      logger.error("jackJson 转义注解失败,失败异常为 e:{}",e);
      throw new BaseException(BaseExceptionCode.BASE_EXCETION_CODE);
    }
    return new EnumSerializer(map);
  }

这样子便可实现返回枚举参数同时，一并返回enum中的getDescription出去，若是须要返回多个参数能够修改baseEnum增长方法