17370845950

本文旨在提供高效且易于维护的方法，解决 Java 对象与特定格式字符串之间的双向映射问题。在需要将 Java 对象的配置信息以特定格式（如 a1:0.1|a2:0.5|fl:true）传递或存储时，手动编写序列化和反序列化逻辑容易出错且难以维护。本文将介绍三种不同的方法：使用 JSON 库、利用 Properties 类以及借助 Scanner 类，来优雅地实现对象字段与字符串之间的双向映射，避免硬编码，提高代码的可读性和可维护性。

方案一：使用 JSON 库

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，非常适合用于序列化和反序列化 Java 对象。通过使用像 Jackson 这样的 JSON 库，可以轻松地将 Java 对象转换为 JSON 字符串，反之亦然。

示例代码：

首先，需要添加 Jackson 依赖到你的项目中。 如果使用 Maven，可以在 pom.xml 文件中添加以下依赖：

    com.fasterxml.jackson.core
    jackson-databind
    2.13.0 

然后，创建包含 @JsonProperty 注解的 Config 类：

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

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

    // Getters and setters (建议添加)
    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;
    }

    public static void main(String... args) throws JsonProcessingException {
        Config config = new Config();
        config.setArg1(0.1f);
        config.setArg2(0.5f);
        config.setFlag(true);

        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(config);
        System.out.println("JSON: " + json); // 输出: {"a1":0.1,"a2":0.5,"fl":true}
        Config res = mapper.readValue(json, Config.class);

        System.out.println("arg1: " + res.getArg1()); // 输出: arg1: 0.1
        System.out.println("arg2: " + res.getArg2()); // 输出: arg2: 0.5
        System.out.println("flag: " + res.isFlag());  // 输出: flag: true
    }
}

说明：

• @JsonProperty("a1") 注解用于指定 JSON 字符串中字段 a1 对应于 Config 类的 arg1 字段。
• ObjectMapper 类负责将 Java 对象序列化为 JSON 字符串 (writeValueAsString)，以及将 JSON 字符串反序列化为 Java 对象 (readValue)。
• 务必包含 getter 和 setter 方法，Jackson 需要通过这些方法访问和设置字段值。

优点：

• 简洁易用，代码量少。
• 可读性强，JSON 格式清晰明了。
• 通用性强，JSON 是一种广泛使用的数据交换格式。

缺点：

• 需要引入额外的 JSON 库依赖。
• JSON 字符串可能比其他格式更冗长。

方案二：使用 Properties 类

Java 的 Properties 类提供了一种简单的方式来存储和加载键值对。可以将 Java 对象的字段作为键，字段值作为值，存储到 Properties 对象中，然后将其保存到文件或输出流中。

示例代码：

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

public 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 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;
    }

    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, "Config data");
    }

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

        Config config = new Config();
        config.setArg1(Float.parseFloat(properties.getProperty(A1, String.valueOf(0.f))));
        config.setArg2(Float.parseFloat(properties.getProperty(A2, String.valueOf(0.f))));
        config.setFlag(Boolean.parseBoolean(properties.getProperty(FL, String.valueOf(false))));

        return config;
    }

    public static void main(String... args) throws IOException {
        Config config = new Config();
        config.setArg1(0.1f);
        config.setArg2(0.5f);
        config.setFlag(true);

        File file = new File("foo.properties");
        if (file.exists()) {
            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("arg1: " + res.getArg1()); // 输出: arg1: 0.1
        System.out.println("arg2: " + res.getArg2()); // 输出: arg2: 0.5
        System.out.println("flag: " + res.isFlag());  // 输出: flag: true
    }
}

说明：

• store(OutputStream out) 方法将 Config 对象的字段存储到 Properties 对象中，然后将 Properties 对象写入到输出流。
• load(InputStream in) 方法从输入流中读取 Properties 对象，然后将 Properties 对象中的值设置到 Config 对象的字段中。
• 使用常量来定义属性名称，提高代码可读性和可维护性。
• getProperty(key, defaultValue) 方法在属性不存在时提供默认值，避免空指针异常。

优点：

• 简单易用，无需引入额外的依赖。
• 可读性较好，Properties 文件格式清晰。
• 支持注释，可以添加描述信息。

缺点：

• 只支持字符串类型的键和值，需要手动进行类型转换。
• 不适合存储复杂的数据结构。

方案三：使用 Scanner 类

Scanner 类可以用于解析字符串，并将其转换为不同的数据类型。可以自定义序列化和反序列化逻辑，使用分隔符将 Java 对象的字段连接成字符串，然后使用 Scanner 类解析该字符串。

示例代码：

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

public 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 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;
    }

    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.setArg1(scan.nextFloat()); break;
                case A2: config.setArg2(scan.nextFloat()); break;
                case FL: config.setFlag(scan.nextBoolean()); break;
            }
        }

        return config;
    }

    public static void main(String... args) throws IOException {
        Config config = new Config();
        config.setArg1(0.1f);
        config.setArg2(0.5f);
        config.setFlag(true);

        String str = config.serialize();
        Config res = Config.deserialize(str);

        System.out.println("arg1: " + res.getArg1()); // 输出: arg1: 0.1
        System.out.println("arg2: " + res.getArg2()); // 输出: arg2: 0.5
        System.out.println("flag: " + res.isFlag());  // 输出: flag: true
    }
}

说明：

• serialize() 方法使用 StringBuilder 将字段名和值拼接成字符串，使用 DELIMITER 分隔字段名和值，使用换行符分隔不同的字段。
• deserialize(String str) 方法使用 Scanner 类解析字符串，使用 DELIMITER + "|\\n" 作为分隔符，将字符串分割成字段名和值，然后将值设置到 Config 对象的字段中。
• scan.useLocale(Locale.ENGLISH) 确保浮点数解析使用英文格式，避免因本地化设置导致解析错误。

优点：

• 不需要引入额外的依赖。
• 可以自定义序列化和反序列化逻辑，灵活性高。

缺点：

• 代码量相对较多。
• 容易出错，需要仔细处理分隔符和数据类型转换。
• 可读性相对较差。

总结

本文介绍了三种不同的方法来实现 Java 对象与字符串之间的双向映射。选择哪种方法取决于具体的应用场景和需求。

• 如果需要处理复杂的数据结构，并且希望代码简洁易用，建议使用 JSON 库。
• 如果只需要存储简单的键值对，并且不需要引入额外的依赖，可以使用 Properties 类。
• 如果需要自定义序列化和反序列化逻辑，并且对性能有较高的要求，可以使用 Scanner 类。

无论选择哪种方法，都应该尽量避免硬编码映射关系，提高代码的可读性和可维护性。使用常量来定义字段名和分隔符，可以减少出错的可能性。同时，应该编写单元测试来验证序列化和反序列化逻辑的正确性。