如何优雅实现Config类与HTTP参数字符串的双向映射？

我定义了如下Config类：

public class Config {
  private float arg1;
  private float arg2;
  private boolean flag;
  // 省略其他代码
}

需要实现以下需求：

• 将Config对象转换为a1:0.1|a2:0.5|fl:true格式的字符串（作为HTTP请求参数），并能将该格式的字符串反序列化为Config实例；
• 实现上述转换的反向操作（从Config实例生成对应格式的字符串）。

要建立类字段（如arg1）与字符串中对应字段（如a1）的双向映射，我目前的实现方式如下：

String serialize(Config config){
  return "a1:" + config.arg1 + "|" + "a2:" + config.arg2 + "|" + "fl:" + config.flag;
}

Config deserialize(String configStr){
  Config config = new Config();

  for (String param : StringUtils.split(configStr, '|')) {
    final String[] fields = StringUtils.split(param, ':');
    final String value = fields[1];

    switch (fields[0]) {
      case "a1" -> config.arg1 = Float.parseFloat(value);
      case "a2" -> config.arg2 = Float.parseFloat(value);
      case "fl" -> config.flag = Boolean.parseBoolean(value);
    }
  }

  return config;
}

但这种方式需要在两个方法中维护硬编码的映射关系，可读性与可维护性较差，请问有没有更优的实现方案？

方案一：自定义注解+反射实现 #

通过自定义注解标记字段对应的外部别名，结合反射统一处理序列化和反序列化逻辑，把映射关系集中在字段注解上，避免硬编码分散。

1. 定义自定义别名注解 #

import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ParamAlias {
    String value();
}

2. 给Config字段添加注解 #

public class Config {
    @ParamAlias("a1")
    private float arg1;
    @ParamAlias("a2")
    private float arg2;
    @ParamAlias("fl")
    private boolean flag;
    // 省略getter/setter，反射时会直接设置字段访问权限
}

3. 实现通用序列化/反序列化工具 #

import org.apache.commons.lang3.StringUtils;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class ConfigSerializer {

    // 序列化：Config转目标格式字符串
    public static String serialize(Config config) throws IllegalAccessException {
        List<String> paramList = new ArrayList<>();
        Field[] fields = Config.class.getDeclaredFields();
        for (Field field : fields) {
            ParamAlias alias = field.getAnnotation(ParamAlias.class);
            if (alias == null) continue;

            field.setAccessible(true);
            Object value = field.get(config);
            paramList.add(alias.value() + ":" + value.toString());
        }
        return StringUtils.join(paramList, "|");
    }

    // 反序列化：字符串转Config实例
    public static Config deserialize(String configStr) throws IllegalAccessException, InstantiationException {
        Config config = Config.class.newInstance();
        String[] params = StringUtils.split(configStr, '|');
        Field[] fields = Config.class.getDeclaredFields();

        for (String param : params) {
            String[] keyValue = StringUtils.split(param, ':');
            if (keyValue.length != 2) continue;

            String alias = keyValue[0];
            String valueStr = keyValue[1];
            for (Field field : fields) {
                ParamAlias fieldAlias = field.getAnnotation(ParamAlias.class);
                if (fieldAlias != null && fieldAlias.value().equals(alias)) {
                    field.setAccessible(true);
                    // 根据字段类型做值转换
                    if (field.getType() == float.class) {
                        field.setFloat(config, Float.parseFloat(valueStr));
                    } else if (field.getType() == boolean.class) {
                        field.setBoolean(config, Boolean.parseBoolean(valueStr));
                    }
                    break;
                }
            }
        }
        return config;
    }
}

这种方式的优势是：新增或修改字段时，只需给字段添加/修改注解，无需改动序列化核心逻辑，可维护性大幅提升。

方案二：枚举维护映射关系 #

通过枚举统一管理字段名、别名、类型转换逻辑，把所有映射规则集中在一处，无需依赖反射，性能更优。

1. 定义映射枚举 #

import java.util.function.BiConsumer;
import java.util.function.Function;

public enum ConfigFieldMapping {
    ARG1("a1", float.class, 
            config -> config.arg1, 
            (config, value) -> config.arg1 = Float.parseFloat(value)),
    ARG2("a2", float.class,
            config -> config.arg2,
            (config, value) -> config.arg2 = Float.parseFloat(value)),
    FLAG("fl", boolean.class,
            config -> config.flag,
            (config, value) -> config.flag = Boolean.parseBoolean(value));

    private final String alias;
    private final Function<Config, Object> getter;
    private final BiConsumer<Config, String> setter;

    ConfigFieldMapping(String alias, Class<?> type, Function<Config, Object> getter, BiConsumer<Config, String> setter) {
        this.alias = alias;
        this.getter = getter;
        this.setter = setter;
    }

    public static ConfigFieldMapping getByAlias(String alias) {
        for (ConfigFieldMapping mapping : values()) {
            if (mapping.alias.equals(alias)) {
                return mapping;
            }
        }
        return null;
    }

    // getter方法
    public String getAlias() { return alias; }
    public Function<Config, Object> getGetter() { return getter; }
    public BiConsumer<Config, String> getSetter() { return setter; }
}

2. 实现序列化/反序列化方法 #

import org.apache.commons.lang3.StringUtils;
import java.util.ArrayList;
import java.util.List;

public class ConfigSerializer {

    public static String serialize(Config config) {
        List<String> paramList = new ArrayList<>();
        for (ConfigFieldMapping mapping : ConfigFieldMapping.values()) {
            Object value = mapping.getGetter().apply(config);
            paramList.add(mapping.getAlias() + ":" + value.toString());
        }
        return StringUtils.join(paramList, "|");
    }

    public static Config deserialize(String configStr) {
        Config config = new Config();
        String[] params = StringUtils.split(configStr, '|');
        for (String param : params) {
            String[] keyValue = StringUtils.split(param, ':');
            if (keyValue.length != 2) continue;

            ConfigFieldMapping mapping = ConfigFieldMapping.getByAlias(keyValue[0]);
            if (mapping != null) {
                mapping.getSetter().accept(config, keyValue[1]);
            }
        }
        return config;
    }
}

这种方式的优势是：所有映射和转换逻辑都集中在枚举中，新增字段只需添加枚举项，逻辑清晰直观，且避免了反射带来的性能损耗。

内容的提问来源于stack exchange，提问作者waynewingorc