YAML是一种常用的数据序列化格式，在Java应用程序中读写YAML数据是常见的任务。
本文介绍了3个受欢迎的Java工具包：SnakeYAML、Jackson Dataformat YAML和YAMLBeans，它们都提供了读写YAML数据的功能。本文将逐一介绍这些工具包的特点、Maven依赖配置，并给出使用示例。
关于yaml的介绍，参考【YAML 入门教程】（ YAML 入门教程-CSDN博客 ）
一、工具包介绍
1. SnakeYAML
SnakeYAML是一个功能强大且流行的Java库，用于读取和写入YAML数据。
提供简单而灵活的API，可以将YAML数据转换为Java对象，或将Java对象转换为YAML数据。
官方网站： https://bitbucket.org/asomov/snakeyaml
Maven 依赖
<dependency>
<groupId>org.yaml</groupId>
<artifactId>snakeyaml</artifactId>
<version>1.28</version>
</dependency>
2. Jackson Dataformat YAML
Jackson Dataformat YAML是Jackson库的扩展，提供对YAML格式的支持。
允许使用相同的API来处理JSON和YAML数据。
Maven 依赖
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-yaml</artifactId>
<version>2.12.5</version>
</dependency>
3. YAMLBeans
YAMLBeans是一个轻量级的Java库，用于读取和写入YAML数据。
提供简单的API，可将YAML数据映射到Java对象，并将Java对象转换为YAML数据。
官方网站： GitHub - EsotericSoftware/yamlbeans: Java object graphs, to and from YAML automatically
Maven 依赖
<dependency>
<groupId>net.sourceforge.yamlbeans</groupId>
<artifactId>yamlbeans</artifactId>
<version>1.14</version>
</dependency>
二、工具包优缺点总结
1.SnakeYAML
优点：功能强大、灵活的API、广泛使用。
缺点：相对复杂，需要处理更多的细节。
2.Jackson Dataformat YAML
优点：与JSON处理库相同的API、广泛使用、与Jackson生态系统集成。
缺点：相对复杂，需要在Jackson库的基础上进行配置和使用。
3.YAMLBeans
优点：轻量级、简单易用。
缺点：相对功能较少，适用于简单的YAML数据处理。
4.总结
三种库各有千秋，根据项目需求和偏好，可以选择适合的工具包。
如果需要更多的灵活性和功能，可以选择SnakeYAML或Jackson Dataformat YAML。
如果的需求相对简单，YAMLBeans可能是一个更轻量级的选择。
无论选择哪个工具包，都可以使用上述示例代码作为起点，根据您的具体需求进行定制和扩展。
三、使用示例
1. SnakeYAML
第一步：在 pom.xml下引入依赖
<dependencies>
<dependency>
<groupId>org.yaml</groupId>
<artifactId>snakeyaml</artifactId>
<version>1.30</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>
第二步：写个工具类
import org.yaml.snakeyaml.Yaml;
import java.io.StringWriter;
public class YamlUtil {
private YamlUtil() {
}
/**
* Java 对象转 yaml 字符串
*
* @param object 对象
* @return 字符串
*/
public static String objectToString(Object object) {
Yaml yaml = new Yaml();
StringWriter sw = new StringWriter();
yaml.dump(object, sw);
return sw.toString();
}
/**
* 从 yaml 字符串读取转到 Java 对象
*
* @param yamlStr yaml 字符串
* @param clazz 目标类.class
* @param <T> 目标类
* @return 目标类对象
*/
public static <T> T stringToObject(String yamlStr, Class<T> clazz) {
Yaml yaml = new Yaml();
return yaml.loadAs(yamlStr, clazz);
}
}
第三步：写一个实体类
import lombok.Data;
import java.util.List;
import java.util.Map;
@Data
public class Cat {
private String name;
private Integer age;
private List<String> list;
private Map<String, String> map;
}
注意：一定要有@Data注解
第四步：代码调用
public class Demo {
public static void main(String[] args) {
// 预设的yaml字符串
String yamlString = "name: 喵喵\n" +
"age: 2\n" +
"list: [捉老鼠, 吃鱼]\n" +
"map: {k1: v1, k2: v2, k3: v3}\n";
// yaml 字符串转成 Java 对象
Cat cat = YamlUtil.stringToObject(yamlString, Cat.class);
System.out.println(cat);
System.out.println("---------------------------------");
// java 对象转 yaml 字符串
String yamlString2 = YamlUtil.objectToString(cat);
System.out.println(yamlString2);
System.out.println("---------------------------------");
// yaml 字符串转成 Java 对象
Cat cat2 = YamlUtil.stringToObject(yamlString2, Cat.class);
System.out.println(cat2);
}
}
第五步：运行结果
Cat(name=喵喵, age=2, list=[捉老鼠, 吃鱼], map={k1=v1, k2=v2, k3=v3})
---------------------------------
!!Cat
age: 2
list: [捉老鼠, 吃鱼]
map: {k1: v1, k2: v2, k3: v3}
name: 喵喵
---------------------------------
Cat(name=喵喵, age=2, list=[捉老鼠, 吃鱼], map={k1=v1, k2=v2, k3=v3})
2. Jackson Dataformat YAML
第一步：在 pom.xml下引入依赖
<dependencies>
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-yaml</artifactId>
<version>2.12.4</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>
第二步：写个工具类
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
import com.fasterxml.jackson.dataformat.yaml.YAMLGenerator;
import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
import java.io.IOException;
import java.io.StringWriter;
public class YamlUtil {
/**
* 将yaml字符串转成类对象
*
* @param yamlStr String
* @param clazz 目标类
* @param <T> 泛型
* @return 目标类
*/
public static <T> T stringToObject(String yamlStr, Class<T> clazz) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
mapper.findAndRegisterModules();
return mapper.readValue(yamlStr, clazz);
}
/**
* 将类对象转yaml字符串
*
* @param object Object
* @return yaml String
*/
public static String objectToString(Object object) throws IOException {
ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
mapper.findAndRegisterModules();
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
mapper = new ObjectMapper(new YAMLFactory().disable(YAMLGenerator.Feature.WRITE_DOC_START_MARKER));
StringWriter stringWriter = new StringWriter();
mapper.writeValue(stringWriter, object);
return stringWriter.toString();
}
/**
* json 2 yaml
*
* @param jsonStr json String
* @return yaml String
* @throws JsonProcessingException Exception
*/
public static String json2Yaml(String jsonStr) throws JsonProcessingException {
JsonNode jsonNode = new ObjectMapper().readTree(jsonStr);
return new YAMLMapper().writeValueAsString(jsonNode);
}
}
第三步：写一个实体类
import lombok.Data;
import java.util.List;
import java.util.Map;
@Data
public class Cat {
private String name;
private Integer age;
private List<String> list;
private Map<String, String> map;
}
注意：一定要有@Data注解
第四步：代码调用
import java.io.IOException;
public class Demo {
public static void main(String[] args) throws IOException {
// 预设的yaml字符串
String yamlString = "name: 喵喵\n" +
"age: 2\n" +
"list: [捉老鼠, 吃鱼]\n" +
"map: {k1: v1, k2: v2, k3: v3}\n";
// yaml 字符串转成 Java 对象
Cat cat = null;
cat = YamlUtil.stringToObject(yamlString, Cat.class);
System.out.println(cat);
System.out.println("---------------------------------");
// java 对象转 yaml 字符串
String yamlString2 = YamlUtil.objectToString(cat);
System.out.println(yamlString2);
System.out.println("---------------------------------");
// yaml 字符串转成 Java 对象
Cat cat2 = YamlUtil.stringToObject(yamlString2, Cat.class);
System.out.println(cat2);
}
}
第五步：运行结果
Cat(name=喵喵, age=2, list=[捉老鼠, 吃鱼], map={k1=v1, k2=v2, k3=v3})
---------------------------------
name: "喵喵"
age: 2
list:
- "捉老鼠"
- "吃鱼"
map:
k1: "v1"
k2: "v2"
k3: "v3"
---------------------------------
Cat(name=喵喵, age=2, list=[捉老鼠, 吃鱼], map={k1=v1, k2=v2, k3=v3})
3. YAMLBeans
第一步：在 pom.xml下引入依赖
<dependencies>
<dependency>
<groupId>com.esotericsoftware.yamlbeans</groupId>
<artifactId>yamlbeans</artifactId>
<version>1.15</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>
第二步：写个工具类
import com.esotericsoftware.yamlbeans.YamlException;
import com.esotericsoftware.yamlbeans.YamlReader;
import com.esotericsoftware.yamlbeans.YamlWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class YamlUtil {
private YamlUtil() {
}
/**
* 将 Java 对象写到 yaml 文件
*
* @param object 对象
* @param yamlPath 文件路径
*/
public static void writeYaml(Object object, String yamlPath) {
try {
YamlWriter writer = new YamlWriter(new FileWriter(yamlPath));
writer.write(object);
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 从 yaml 文件读取转到 Java 对象
*
* @param yamlPath 文件路径
* @param clazz 目标类.class
* @param <T> 目标类
* @return 目标类对象
*/
public static <T> T readYaml(String yamlPath, Class<T> clazz) {
try {
YamlReader reader = new YamlReader(new FileReader(yamlPath));
try {
return reader.read(clazz);
} catch (YamlException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return null;
}
}
第三步：写一个实体类
import lombok.Data;
import java.util.List;
import java.util.Map;
@Data
public class Cat {
private String name;
private Integer age;
private List<String> list;
private Map<String, String> map;
}
第四步：代码调用
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class Demo {
public static void main(String[] args) throws IOException {
// 1、准备 Java 对象
Map<String, String> map = new HashMap<>();
map.put("k1", "v1");
map.put("k2", "v2");
map.put("k3", "v3");
Cat cat = new Cat();
cat.setName("喵喵");
cat.setAge(2);
cat.setList(Arrays.asList("捉老鼠", "吃鱼"));
cat.setMap(map);
System.out.println(cat);
YamlUtil.writeYaml(cat, "D:/1.yml");
System.out.println("---------------------------------");
Cat cat2 = YamlUtil.readYaml("D:/1.yml", Cat.class);
System.out.println(cat2);
}
}
第五步：运行结果
Cat(name=喵喵, age=2, list=[捉老鼠, 吃鱼], map={k1=v1, k2=v2, k3=v3})
---------------------------------
Cat(name=喵喵, age=2, list=[捉老鼠, 吃鱼], map={k1=v1, k2=v2, k3=v3})
在D盘根目录下生成一个1.yml的文件内容如下：
!Cat
name: "\u55b5\u55b5"
age: 2
list: !java.util.Arrays$ArrayList
- "\u6349\u8001\u9f20"
- "\u5403\u9c7c"
map:
k1: v1
k2: v2
k3: v3
3360
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
