本文针对 Java 对象与特定格式字符串之间的相互转换问题，提供了三种更具维护性和可读性的解决方案。避免了硬编码映射，分别利用 JSON 序列化、Properties 类以及 Scanner 类，实现了 Config 对象的序列化与反序列化，旨在帮助开发者选择最适合自身场景的方法，提高代码质量和开发效率。
在实际开发中，经常会遇到需要将 Java 对象转换为字符串，或者将字符串转换为 Java 对象的需求，例如将配置对象转换为 HTTP 请求参数，或者将 HTTP 响应数据转换为配置对象。一种常见的做法是使用硬编码的方式进行映射，但这种方式缺乏可维护性，容易出错。本文将介绍三种更优雅的实现方案，分别是使用 JSON 序列化、Properties 类以及 Scanner 类。
方案一：使用 JSON 序列化
JSON 序列化是一种常用的数据交换格式，具有良好的可读性和跨平台性。通过使用 Jackson 等 JSON 库，可以轻松地将 Java 对象序列化为 JSON 字符串，也可以将 JSON 字符串反序列化为 Java 对象。
示例代码：
立即学习“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;
}
}
}代码解释：
- 引入 Jackson 库的依赖。
- 在 Config 类的字段上使用 @JsonProperty 注解，指定字段对应的 JSON 属性名。
- 使用 ObjectMapper 类的 writeValueAsString 方法将 Config 对象序列化为 JSON 字符串。
- 使用 ObjectMapper 类的 readValue 方法将 JSON 字符串反序列化为 Config 对象。
注意事项：
- 需要引入 Jackson 库的依赖。
- 可以使用 @JsonIgnore 注解忽略不需要序列化/反序列化的字段。
- 可以使用 @JsonFormat 注解指定日期/时间的格式。
方案二：使用 Properties 类
Properties 类是 Java 中用于处理配置文件的类，可以将 Java 对象转换为 Properties 文件格式的字符串，也可以将 Properties 文件格式的字符串反序列化为 Java 对象。
示例代码：
立即学习“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;
}
}
}代码解释：
- 定义 Config 类，包含需要序列化/反序列化的字段。
- 在 Config 类中定义 store 方法，用于将 Config 对象转换为 Properties 文件格式的字符串。
- 在 Config 类中定义 load 方法，用于将 Properties 文件格式的字符串反序列化为 Config 对象。
- 在 store 方法中，使用 Properties 类的 setProperty 方法设置属性值。
- 在 load 方法中，使用 Properties 类的 getProperty 方法获取属性值。
注意事项：
- Properties 文件格式的字符串只能包含字符串类型的属性值。
- 可以使用 Properties 类的 store 方法将 Properties 对象保存到文件中。
- 可以使用 Properties 类的 load 方法从文件中加载 Properties 对象。
方案三：使用 Scanner 类
Scanner 类是 Java 中用于扫描输入流的类，可以将 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('
');
buf.append(A2).append(DELIMITER).append(arg2).append('
');
buf.append(FL).append(DELIMITER).append(flag).append('
');
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;
}
}
}代码解释：
- 定义 Config 类，包含需要序列化/反序列化的字段。
- 在 Config 类中定义 serialize 方法，用于将 Config 对象转换为特定格式的字符串。
- 在 Config 类中定义 deserialize 方法，用于将特定格式的字符串反序列化为 Config 对象。
- 在 serialize 方法中，使用 StringBuilder 类拼接字符串。
- 在 deserialize 方法中，使用 Scanner 类的 useDelimiter 方法设置分隔符。
- 在 deserialize 方法中，使用 Scanner 类的 next 方法获取属性值。
注意事项：
- 需要根据实际情况设置分隔符。
- 需要根据实际情况使用 Scanner 类的不同方法获取不同类型的属性值。
- 需要注意处理异常情况。
总结
本文介绍了三种更优雅的 Java 对象与字符串的双向映射方案，分别是使用 JSON 序列化、Properties 类以及 Scanner 类。每种方案都有其优缺点，开发者可以根据实际情况选择最适合自身场景的方案。
- JSON 序列化： 优点是可读性好，跨平台性好，缺点是需要引入额外的依赖。
- Properties 类： 优点是简单易用，缺点是只能处理字符串类型的属性值。
- Scanner 类： 优点是灵活性高，可以处理各种格式的字符串，缺点是需要手动解析字符串。
选择合适的方案可以提高代码质量和开发效率，避免硬编码映射带来的问题。
