Java 对象与字符串的优雅映射方法

本文针对 Java 对象与特定格式字符串之间的相互转换问题，提供了三种更具维护性和可读性的解决方案。避免了硬编码映射，分别利用 JSON 序列化、Properties 类以及 Scanner 类，实现了 Config 对象的序列化与反序列化，旨在帮助开发者选择最适合自身场景的方法，提高代码质量和开发效率。

在实际开发中，经常会遇到需要将 Java 对象转换为字符串，或者将字符串转换为 Java 对象的需求，例如将配置对象转换为 HTTP 请求参数，或者将 HTTP 响应数据转换为配置对象。一种常见的做法是使用硬编码的方式进行映射，但这种方式缺乏可维护性，容易出错。本文将介绍三种更优雅的实现方案，分别是使用 JSON 序列化、Properties 类以及 Scanner 类。

方案一：使用 JSON 序列化

JSON 序列化是一种常用的数据交换格式，具有良好的可读性和跨平台性。通过使用 Jackson 等 JSON 库，可以轻松地将 Java 对象序列化为 JSON 字符串，也可以将 JSON 字符串反序列化为 Java 对象。

示例代码：

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class ConfigJsonExample {

    public static void main(String... args) throws JsonProcessingException {
        Config config = new Config();
        config.arg1 = 0.1f;
        config.arg2 = 0.5f;
        config.flag = true;

        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(config);
        System.out.println("Serialized JSON: " + json);
        Config res = mapper.readValue(json, Config.class);
        System.out.println("Deserialized Config: arg1=" + res.arg1 + ", arg2=" + res.arg2 + ", flag=" + res.flag);
    }

    public static class Config {
        @JsonProperty("a1")
        private float arg1;
        @JsonProperty("a2")
        private float arg2;
        @JsonProperty("fl")
        private boolean flag;

        // Getters and setters (optional, but recommended)
        public float getArg1() {
            return arg1;
        }

        public void setArg1(float arg1) {
            this.arg1 = arg1;
        }

        public float getArg2() {
            return arg2;
        }

        public void setArg2(float arg2) {
            this.arg2 = arg2;
        }

        public boolean isFlag() {
            return flag;
        }

        public void setFlag(boolean flag) {
            this.flag = flag;
        }
    }
}

代码解释：

1. 引入 Jackson 库的依赖。
2. 在 Config 类的字段上使用 @JsonProperty 注解，指定字段对应的 JSON 属性名。
3. 使用 ObjectMapper 类的 writeValueAsString 方法将 Config 对象序列化为 JSON 字符串。
4. 使用 ObjectMapper 类的 readValue 方法将 JSON 字符串反序列化为 Config 对象。

注意事项：

• 需要引入 Jackson 库的依赖。
• 可以使用 @JsonIgnore 注解忽略不需要序列化/反序列化的字段。
• 可以使用 @JsonFormat 注解指定日期/时间的格式。

方案二：使用 Properties 类

Properties 类是 Java 中用于处理配置文件的类，可以将 Java 对象转换为 Properties 文件格式的字符串，也可以将 Properties 文件格式的字符串反序列化为 Java 对象。

示例代码：

import java.io.*;
import java.util.Properties;

public class ConfigPropertiesExample {

    public static void main(String... args) throws IOException {
        Config config = new Config();
        config.arg1 = 0.1f;
        config.arg2 = 0.5f;
        config.flag = true;

        File file = new File("foo.properties");
        file.delete();
        file.createNewFile();

        try (OutputStream out = new FileOutputStream(file, false)) {
            config.store(out);
        }

        Config res = null;

        try (InputStream in = new FileInputStream(file)) {
            res = Config.load(in);
        }
        System.out.println("Deserialized Config: arg1=" + res.arg1 + ", arg2=" + res.arg2 + ", flag=" + res.flag);
    }

    public static class Config {

        private static final String A1 = "a1";
        private static final String A2 = "a2";
        private static final String FL = "fl";

        private float arg1;
        private float arg2;
        private boolean flag;

        public void store(OutputStream out) throws IOException {
            Properties properties = new Properties();
            properties.setProperty(A1, String.valueOf(arg1));
            properties.setProperty(A2, String.valueOf(arg2));
            properties.setProperty(FL, String.valueOf(flag));
            properties.store(out, "Some description");
        }

        public static Config load(InputStream in) throws IOException {
            Properties properties = new Properties();
            properties.load(in);

            Config config = new Config();
            config.arg1 = Float.parseFloat(properties.getProperty(A1, String.valueOf(0.f)));
            config.arg2 = Float.parseFloat(properties.getProperty(A2, String.valueOf(0.f)));
            config.flag = Boolean.parseBoolean(properties.getProperty(FL, String.valueOf(false)));

            return config;
        }
    }
}

代码解释：

1. 定义 Config 类，包含需要序列化/反序列化的字段。
2. 在 Config 类中定义 store 方法，用于将 Config 对象转换为 Properties 文件格式的字符串。
3. 在 Config 类中定义 load 方法，用于将 Properties 文件格式的字符串反序列化为 Config 对象。
4. 在 store 方法中，使用 Properties 类的 setProperty 方法设置属性值。
5. 在 load 方法中，使用 Properties 类的 getProperty 方法获取属性值。

注意事项：

• Properties 文件格式的字符串只能包含字符串类型的属性值。
• 可以使用 Properties 类的 store 方法将 Properties 对象保存到文件中。
• 可以使用 Properties 类的 load 方法从文件中加载 Properties 对象。

方案三：使用 Scanner 类

Scanner 类是 Java 中用于扫描输入流的类，可以将 Java 对象转换为特定格式的字符串，也可以将特定格式的字符串反序列化为 Java 对象。

示例代码：

import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;

public class ConfigScannerExample {

    public static void main(String... args) throws IOException {
        Config config = new Config();
        config.arg1 = 0.1f;
        config.arg2 = 0.5f;
        config.flag = true;

        String str = config.serialize();
        Config res = Config.deserialize(str);
        System.out.println("Deserialized Config: arg1=" + res.arg1 + ", arg2=" + res.arg2 + ", flag=" + res.flag);
    }

    public static class Config {

        private static final String A1 = "a1";
        private static final String A2 = "a2";
        private static final String FL = "fl";
        private static final String DELIMITER = ":";

        private float arg1;
        private float arg2;
        private boolean flag;

        public String serialize() throws IOException {
            StringBuilder buf = new StringBuilder();
            buf.append(A1).append(DELIMITER).append(arg1).append('\n');
            buf.append(A2).append(DELIMITER).append(arg2).append('\n');
            buf.append(FL).append(DELIMITER).append(flag).append('\n');
            return buf.toString();
        }

        public static Config deserialize(String str) {
            Scanner scan = new Scanner(str);
            scan.useDelimiter(DELIMITER + "|\\n");
            scan.useLocale(Locale.ENGLISH);

            Config config = new Config();

            while (scan.hasNext()) {
                switch (scan.next()) {
                    case A1: config.arg1 = scan.nextFloat(); break;
                    case A2: config.arg2 = scan.nextFloat(); break;
                    case FL: config.flag = scan.nextBoolean(); break;
                }
            }

            return config;
        }

        public float getArg1() {
            return arg1;
        }

        public void setArg1(float arg1) {
            this.arg1 = arg1;
        }

        public float getArg2() {
            return arg2;
        }

        public void setArg2(float arg2) {
            this.arg2 = arg2;
        }

        public boolean isFlag() {
            return flag;
        }

        public void setFlag(boolean flag) {
            this.flag = flag;
        }
    }
}

代码解释：

1. 定义 Config 类，包含需要序列化/反序列化的字段。
2. 在 Config 类中定义 serialize 方法，用于将 Config 对象转换为特定格式的字符串。
3. 在 Config 类中定义 deserialize 方法，用于将特定格式的字符串反序列化为 Config 对象。
4. 在 serialize 方法中，使用 StringBuilder 类拼接字符串。
5. 在 deserialize 方法中，使用 Scanner 类的 useDelimiter 方法设置分隔符。
6. 在 deserialize 方法中，使用 Scanner 类的 next 方法获取属性值。

注意事项：

• 需要根据实际情况设置分隔符。
• 需要根据实际情况使用 Scanner 类的不同方法获取不同类型的属性值。
• 需要注意处理异常情况。

总结

本文介绍了三种更优雅的 Java 对象与字符串的双向映射方案，分别是使用 JSON 序列化、Properties 类以及 Scanner 类。每种方案都有其优缺点，开发者可以根据实际情况选择最适合自身场景的方案。

• JSON 序列化： 优点是可读性好，跨平台性好，缺点是需要引入额外的依赖。
• Properties 类： 优点是简单易用，缺点是只能处理字符串类型的属性值。
• Scanner 类： 优点是灵活性高，可以处理各种格式的字符串，缺点是需要手动解析字符串。

选择合适的方案可以提高代码质量和开发效率，避免硬编码映射带来的问题。