在 Java 开发中，经常会遇到需要将对象转换为字符串，或者将字符串转换为对象的情况。例如，在进行 HTTP 请求时，可能需要将配置对象作为参数传递，这时就需要将其序列化为字符串。反之，接收到 HTTP 响应后，可能需要将响应字符串反序列化为配置对象。本文将围绕 Config 类与特定格式字符串（如 a1:0.1|a2:0.5|fl:true）的双向转换展开，介绍几种实现方案，并分析它们的优缺点。
使用 JSON 进行序列化和反序列化
JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。在 Java 中，可以使用 Jackson、Gson 等库来处理 JSON 数据。
以下是使用 Jackson 库实现 Config 对象与 JSON 字符串相互转换的示例代码：
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 (omitted for brevity)
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;
}
}
}代码解释:
立即学习“Java免费学习笔记（深入）”；
-
依赖引入: 需要添加 Jackson 依赖到你的项目中。例如，在 Maven 中，可以添加以下依赖：
<dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.13.0</version> <!-- 使用最新版本 --> </dependency> @JsonProperty 注解: 使用 @JsonProperty 注解将类字段与 JSON 属性名进行映射。例如，arg1 字段被映射到 JSON 属性 a1。
ObjectMapper: ObjectMapper 类是 Jackson 库的核心类，用于执行序列化和反序列化操作。
writeValueAsString(): 将 Config 对象序列化为 JSON 字符串。
readValue(): 将 JSON 字符串反序列化为 Config 对象。
优点:
- 简单易用，代码简洁。
- 可读性好，JSON 格式清晰明了。
- 灵活性高，可以通过注解进行更细粒度的控制。
- 广泛使用，拥有成熟的生态系统和丰富的文档。
缺点:
- 需要引入额外的依赖库。
- JSON 格式可能比自定义格式更冗长。
使用 Properties 类进行序列化和反序列化
java.util.Properties 类可以用于存储和加载键值对，其中键和值都是字符串。可以将 Config 对象的字段存储为 Properties 对象的键值对，然后将其保存到文件中或从文件中加载。
以下是使用 Properties 类实现 Config 对象与 Properties 文件相互转换的示例代码：
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("Loaded 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;
}
// Getters and setters (omitted for brevity)
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;
}
}
}代码解释:
立即学习“Java免费学习笔记（深入）”；
常量定义: 定义常量来存储属性名，避免硬编码。
store() 方法: 将 Config 对象的字段存储到 Properties 对象中，然后将其写入到输出流。
load() 方法: 从输入流中加载 Properties 对象，然后将其转换为 Config 对象。
优点:
- 不需要引入额外的依赖库。
- Properties 文件格式简单易懂。
- 可以方便地进行配置管理。
缺点:
- 只能存储字符串类型的键值对，需要进行类型转换。
- Properties 文件格式相对简单，缺乏灵活性。
- 不适合存储复杂的数据结构。
使用 Scanner 进行自定义格式的序列化和反序列化
如果需要使用自定义的字符串格式，可以使用 java.util.Scanner 类来解析字符串，并将其转换为 Config 对象。
以下是使用 Scanner 类实现 Config 对象与自定义格式字符串相互转换的示例代码：
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();
System.out.println("Serialized String: " + str);
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;
}
// Getters and setters (omitted for brevity)
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;
}
}
}代码解释:
立即学习“Java免费学习笔记（深入）”；
serialize() 方法: 使用 StringBuilder 构建自定义格式的字符串。
-
deserialize() 方法: 使用 Scanner 解析自定义格式的字符串。
- scan.useDelimiter(DELIMITER + "|\n"): 设置分隔符为 ":" 或换行符。
- scan.useLocale(Locale.ENGLISH): 设置 Locale 为 ENGLISH，确保浮点数解析正确。
- 使用 switch 语句根据属性名设置 Config 对象的字段值.
优点:
- 可以灵活地定义字符串格式。
- 不需要引入额外的依赖库。
缺点:
- 代码相对复杂，需要手动解析字符串。
- 容易出错，需要仔细处理各种边界情况。
- 可维护性较差，修改字符串格式需要修改代码。
总结
本文介绍了三种在 Java 中实现类字段与 String 值之间双向映射转换的方案：使用 JSON、Properties 类和 Scanner。
- JSON: 简单易用，可读性好，灵活性高，但需要引入额外的依赖库。
- Properties: 不需要引入额外的依赖库，Properties 文件格式简单易懂，但只能存储字符串类型的键值对，不适合存储复杂的数据结构。
- Scanner: 可以灵活地定义字符串格式，但代码相对复杂，容易出错，可维护性较差。
在实际开发中，应根据具体的需求选择最合适的方案。如果需要存储复杂的数据结构，或者需要进行更细粒度的控制，建议使用 JSON。如果只需要存储简单的键值对，并且不需要引入额外的依赖库，可以使用 Properties 类。如果需要使用自定义的字符串格式，可以使用 Scanner，但需要仔细处理各种边界情况，并注意代码的可维护性。
