本文旨在提供一种更具可维护性的方法，用于在 Java 类的字段和字符串值之间进行双向映射，从而实现配置对象的序列化和反序列化。我们将探讨使用 JSON 序列化、Properties 类和 Scanner 类的多种实现方案，并分析各自的优缺点，帮助开发者选择最适合其应用场景的方案。
在实际开发中，经常会遇到需要将 Java 对象转换为字符串，或者将字符串转换为 Java 对象的情况，尤其是在处理配置信息时。例如，将配置对象转换为 HTTP 请求参数，或者从配置文件中读取配置信息。手动编写序列化和反序列化逻辑虽然可行，但容易出错且难以维护。本文将介绍几种更优雅的实现方式，以提高代码的可读性和可维护性。
1. 使用 JSON 序列化
JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写。Java 中有许多 JSON 库，例如 Jackson、Gson 等，可以方便地将 Java 对象序列化为 JSON 字符串，以及将 JSON 字符串反序列化为 Java 对象。
示例代码 (使用 Jackson):
立即学习“Java免费学习笔记（深入）”；
首先，需要添加 Jackson 依赖到你的项目中。 如果使用 Maven，可以在 pom.xml 文件中添加以下依赖：
com.fasterxml.jackson.core jackson-databind 2.13.0
然后，可以使用以下代码进行序列化和反序列化：
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);
Config res = mapper.readValue(json, Config.class);
System.out.println("arg1: " + res.getArg1());
System.out.println("arg2: " + res.getArg2());
System.out.println("flag: " + res.isFlag());
}
}在这个例子中，@JsonProperty 注解用于指定 Java 字段对应的 JSON 属性名称。这样，就可以灵活地控制序列化和反序列化的行为。
优点:
- 代码简洁，易于理解。
- 支持复杂的数据结构。
- 具有良好的可扩展性。
缺点:
- 需要引入额外的依赖库。
- 序列化后的字符串可读性稍差，不如 Properties 文件。
2. 使用 Properties 类
java.util.Properties 类用于处理 Java 属性文件，属性文件是一种简单的文本文件，用于存储配置信息。Properties 类提供了 store() 和 load() 方法，可以将 Java 对象序列化为属性文件，以及将属性文件反序列化为 Java 对象。
示例代码:
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;
// 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 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;
}
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");
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());
System.out.println("arg2: " + res.getArg2());
System.out.println("flag: " + res.isFlag());
}
}在这个例子中，store() 方法将 Java 对象的字段转换为属性，并将其存储到输出流中。load() 方法从输入流中读取属性，并将其转换为 Java 对象的字段。
优点:
- 序列化后的字符串可读性好，易于编辑。
- 不需要引入额外的依赖库。
缺点:
- 只支持简单的数据类型。
- 需要手动编写序列化和反序列化逻辑。
- 不适合复杂的数据结构。
3. 使用 Scanner 类
java.util.Scanner 类可以用于读取各种输入流，包括字符串。我们可以使用 Scanner 类将 Java 对象序列化为字符串，以及将字符串反序列化为 Java 对象。
示例代码:
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;
// 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 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 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();
System.out.println("Serialized String: \n" + str);
Config res = Config.deserialize(str);
System.out.println("arg1: " + res.getArg1());
System.out.println("arg2: " + res.getArg2());
System.out.println("flag: " + res.isFlag());
}
}在这个例子中，serialize() 方法将 Java 对象的字段转换为字符串，并使用分隔符 DELIMITER 分隔。deserialize() 方法使用 Scanner 类从字符串中读取字段，并将其转换为 Java 对象的字段。
优点:
- 不需要引入额外的依赖库。
- 可以自定义序列化和反序列化的格式。
缺点:
- 需要手动编写序列化和反序列化逻辑。
- 容易出错，需要进行严格的错误处理。
- 不适合复杂的数据结构。
总结
本文介绍了三种在 Java 中实现对象与字符串双向映射的方法：JSON 序列化、Properties 类和 Scanner 类。每种方法都有其优缺点，开发者应根据实际情况选择最适合的方法。一般来说，如果需要处理复杂的数据结构，建议使用 JSON 序列化。如果只需要处理简单的数据类型，并且需要序列化后的字符串具有良好的可读性，可以使用 Properties 类。如果需要自定义序列化和反序列化的格式，可以使用 Scanner 类。无论选择哪种方法，都应该注意代码的可读性和可维护性，并进行严格的错误处理。
