导入包

这里用的是yamlbeans包，官方github有中文文档，很友好。

地址：https://github.com/EsotericSoftware/yamlbeans

        <dependency>
            <groupId>com.esotericsoftware.yamlbeans</groupId>
            <artifactId>yamlbeans</artifactId>
            <version>1.08</version>
        </dependency>

[zd-plane title=”官方中文文档”]

概述

YAML是一种人性化的数据格式，使用YAML来替代XML和properties文件，可以获得更多的表现力（支持lists，maps，anchors等结构），以及更容易的手工编辑。 而YamlBeans则可以让Java对象和YAML格式之间的转换（序列化和反序列化）变得更容易。

Maven 仓库: http://repo1.maven.org/maven2/com/esotericsoftware/yamlbeans/yamlbeans/

基本的反序列化

YamlReader这个类用于将YAML格式数据反序列化为Java对象。下面定义了一个包含4个实体的Map,其中最后一个实体项phone numbers又是一个包含了2个item的List集合，而每一个item又是一个Map结构。

    name: Nathan Sweet
    age: 28
    address: 4011 16th Ave S
    phone numbers:
     - name: Home
       number: 206-555-5138
     - name: Work
       number: 425-555-2306

“read()”方法可用来读取contact.yml文件中描述的YAML对象，并将其反序列化为对应的HashMaps，ArrayLists和Strings。因为我们已经知道上面示例的YAML文件中定义的对象是一个Map，所以下面示例中我们可以直接转换为java对象并使用它。

    YamlReader reader = new YamlReader(new FileReader("contact.yml"));
    Object object = reader.read();
    System.out.println(object);
    Map map = (Map)object;
    System.out.println(map.get("address"));

多个对象

一个YAML格式的文件中可以包含多个YAML对象,多个YAML对象之间用---隔开（开头第一个可以省略）

    name: Nathan Sweet
    age: 28
    ---
    name: Some One
    age: 25

下面示例中，当while循环中每次调用YamlReader类中read（）方法时，就会将contact.yml文件中对应顺序的YAML对象反序列化成一个与之对应结构的Java对象。 下面代码会先后输出字符串"28","25":

    YamlReader reader = new YamlReader(new FileReader("contact.yml"));
    while (true) {
    	Map contact = reader.read();
    	if (contact == null) break;
    	System.out.println(contact.get("age"));
    }

反序列化其他类

有两种方法来反序列化除HashMaps，ArrayLists和Strings之外的其他自定义数据格式，例如下面这个YAML文件和Java类:

    name: Nathan Sweet
    age: 28

    public class Contact {
    	public String name;
    	public int age;
    }

在“read()”方法的入参中传递一个类，这样YamlReader就可以直接反序列化为指定的类:

    YamlReader reader = new YamlReader(new FileReader("contact.yml"));
    Contact contact = reader.read(Contact.class);
    System.out.println(contact.age);

上面YamlReader创建了一个Contact.class的实例对象，并给“name”和“age”字段赋值，且YamlReader会把YAML中“age”的值转换为int。如果age不是int类型，则反序列化将失败。

除了上面这种反序列化方法外，还可以在YAML中使用添加!全限定类名方式来直接指定类型：

    !com.example.Contact
    name: Nathan Sweet
    age: 28

序列化对象

YamlWriter这个类用来把Java对象序列化为YAML格式。且“write()”方法会自动识别处理public字段和getter方法(一般private属性会生成getter方法)。

    Contact contact = new Contact();
    contact.name = "Nathan Sweet";
    contact.age = 28;
    YamlWriter writer = new YamlWriter(new FileWriter("output.yml"));
    writer.write(contact);
    writer.close();

输出：

    !com.example.Contact
    name: Nathan Sweet
    age: 28

上面!com.example.Contact部分会根据需要自动输出，以便YamlReader类能够反序列化时重建对应的Java对象。但序列化ArrayList时则不会输出任何类似!com.example.Contact的格式内容,因为YamlReader默认就会用ArrayList。

    List list = new ArrayList();
    list.add("moo");
    list.add("cow");

    - moo
    - cow

但是如果List的接口实现是LinkedList，而不是ArrayList（默认）,那么YamlWriter类就会输出，例如下面：

    List list = new LinkedList();
    list.add("moo");
    list.add("cow");

    !java.util.LinkedList
    - moo
    - cow

Note that it is not advisable to subclass Collection or Map. YamlBeans will only serialize the collection or map and its elements, not any additional fields.

注意，在yaml中把集合或Map设置为子类节点是不可取的。YamlBeans只会序列化集合或Map及其中的元素，而不会对其他字段进行序列化。

复杂结构

YamlBeans可序列化任何对象。

    public class Contact {
    	public String name;
    	public int age;
    	public List phoneNumbers;
    }
    
    public class Phone {
    	public String name;
    	public String number;
    }

    friends:
      - !com.example.Contact
        name: Bob
        age: 29
        phoneNumbers:
            - !com.example.Phone
              name: Home
              number: 206-555-1234
            - !com.example.Phone
              name: Work
              number: 206-555-5678
      - !com.example.Contact
        name: Mike
        age: 31
        phoneNumbers:
            - !com.example.Phone
              number: 206-555-4321
    enemies:
      - !com.example.Contact
        name: Bill
        phoneNumbers:
            - !com.example.Phone
              name: Cell
              number: 206-555-1234

上面是一个由Contact类的List集合构成的复杂Map结构，而且Contact类中还包含phoneNumbers这个List属性。另外，public类型声明的字段也可以是java bean的属性（而不仅仅是getter方法对应的private类型字段）。

标签截取

!com.example.Contact这种形式的YAML标签有时可能会很长，会让YAML格式显得混乱不堪，不利于阅读。这时可以给类指定一个替代标签来代替，而不是用类的完整类名。

    YamlWriter writer = new YamlWriter(new FileWriter("output.yml"));
    writer.getConfig().setClassTag("contact", Contact.class);
    writer.write(contact);
    writer.close();

下面输出不再包含Contact类的完整类名。

    !contact
    name: Nathan Sweet
    age: 28

List 和 Map

在读取或写入一个List或Map时，YamlBeans有时压根不知道List或Map中应该是什么类型的对象，因此它会输出一个类似!com.example.Contact的标签。

    !com.example.Contact
    name: Bill
        phoneNumbers:
            - !com.example.Phone
              number: 206-555-1234
            - !com.example.Phone
              number: 206-555-5678
            - !com.example.Phone
              number: 206-555-7654

这样会导致YAML的可读性变的更差。为了提高可读性，你可以在List或Map对象的字段中，指定该字段所属的类型，像下面这样：

    YamlWriter writer = new YamlWriter(new FileWriter("output.yml"));
    writer.getConfig().setPropertyElementType(Contact.class, "phoneNumbers", Phone.class);
    writer.write(contact);
    writer.close();

现在，YamlBeans知道“phoneNumbers”字段的类型是什么了，因此不会额外输出多余的标签。

    !com.example.Contact
    name: Bill
        phoneNumbers:
            - number: 206-555-1234
            - number: 206-555-5678
            - number: 206-555-7654

Map中value值的类型，可以根据期望的情况来指定，但Map中的键总是字符串类型。

锚点

当一个对象的结构中包含对其他同一对象的多个引用时，可以设置一个锚点，这样这个被引用的对象只需要在YAML中定义一次。

    oldest friend:
        &1 !contact
        name: Bob
        age: 29
    best friend: *1

在上面map中，”oldest friend” 和 “best friend” 字段引用了同一个对象。在反序列化构建对象时，YamlReader会自动处理YAML中的锚点。同时，在默认情况下，YamlWriter在序列化对象时也会自动输出锚点。

    Contact contact = new Contact();
    contact.name = "Bob";
    contact.age = 29;
    Map map = new HashMap();
    map.put("oldest friend", contact);
    map.put("best friend", contact);

让重复字段生效

默认情况下，YAML在解析时是忽略重复字段的。例如，以下情况：

    name: Nathan Sweet
    age: 28
    address:
      line1: 485 Madison Ave S
      line1: 711 3rd Ave S
      line2: NYC

上面的YAML将会为address的line1字段赋值为711 3rd Ave S而不是485 Madison Ave S。这是因为上面YAML中的字段line1是重复的，因此line1的最后一个值将会被保留。但是，如果你的业务逻辑要求重复字段都生效，那么你可以在YamlConfig类进行设置。以下是设置方法:

    try {
        YamlConfig yamlConfig = new YamlConfig();
        yamlConfig.setAllowDuplicates(false); // default value is true
        YamlReader reader = new YamlReader(new FileReader("contact.yml"), yamlConfig);
        Object object = reader.read();
        System.out.println(object);
        Map map = (Map)object;
        System.out.println(map.get("address"));
    } catch (YamlException ex) {
        ex.printStackTrace();
        // or handle duplicate key case here according to your business logic
    }

上面的代码不会打印任何东西，但会在第5行抛出YamlReaderException异常说Duplicate key found 'line1'

体系结构

YAML的tokenizer，parser，emitter组件是基于JvYAML项目中的。这些功能已被重构，修复bug等。由于JvYAML的复杂性，剩下部分未被使用。 YamlBeans努力于实现简单可行的事情—让使用Java操作YAML数据格式变得更加容易。

YamlBeans 支持 YAML 1.0 和 1.1 版本 。

[/zd-plane]

yaml格式如下：

network: 
   ethernets: 
      enp1s0: 
         addresses: 
         - 192.168.1.80/24
         gateway4: 192.168.1.1
         nameservers: 
            addresses: 
            - 192.168.1.1
            - 114.114.114.114
   version: 2

创建对应的实体类：

import lombok.Data;

@Data
public class NetConfig {
    public Network network;
}

import lombok.Data;

@Data
public class Network {
    private Ethernets ethernets;
    private Integer version;
}

import lombok.Data;

@Data
public class Ethernets {
    private Enp enp1s0;
}

import lombok.Data;

import java.util.List;

@Data
public class Enp {
    private List<String> addresses;
    private boolean dhcp4;
    private boolean optional;
    private String gateway4;
    private Nameservers nameservers;
}

import lombok.Data;

import java.util.List;

@Data
public class Nameservers {
    private List<String> addresses;
}

业务代码：

    @Test
    public void asd() throws Exception {
        String path = "G:\\desktop\\net.yaml";
        //读取yaml
        YamlReader reader = new YamlReader(new FileReader(path));
        //读取成map
        Map<String, Object> object = (Map<String, Object>) reader.read();
        //map转实体类
        NetConfig netConfig = this.yamlMapToNetConfig(object);
        System.out.println(netConfig);

        //写入yaml
        YamlWriter writer = new YamlWriter(new FileWriter(path));
        
        //改一下写入的东西  辨别是否更改
        Network network = netConfig.getNetwork();
        network.setVersion(1);
        netConfig.setNetwork(network);
        
        //写入
        writer.write(netConfig);
        writer.close();

        //写入后第一行会自动生成一个感叹号+NetConfig的全路径类名 
        //如果单纯的java读取是没问题   
        //但是如果是其他环境识别yaml就会出错
        //所以在这儿把!替换成#
        this.autoReplace(path,"!com.anran.domain.net.NetConfig","#com.anran.domain.net.NetConfig");
    }

    /**
     * ubuntu yaml网络配置转实体类 
     * 这个根据自己的实际情况来
     * @param map
     * @return
     */
    public static NetConfig yamlMapToNetConfig(Map map) {
        NetConfig netConfig = JSONUtil.toBean(JSON.toJSONString(map), NetConfig.class);
        Network network = netConfig.getNetwork();
        network.setVersion(2);
        Ethernets ethernets = network.getEthernets();
        Enp enp = ethernets.getEnp1s0();
        if (null == enp.getGateway4()) {
            enp.setGateway4("192.168.1.1");
        }
        Nameservers nameservers = enp.getNameservers();
        if (null == nameservers) {
            List<String> list = new ArrayList<>();
            list.add("192.168.1.1");
            list.add("114.114.114.114");
            Nameservers n = new Nameservers();
            n.setAddresses(list);
            nameservers = n;
            enp.setNameservers(nameservers);
        }
        return netConfig;
    }
    
    /**
     *文件修改
     * @param filePath 文件名称
     * @param oldstr   要修改的字符串
     * @param newStr   新的字符串
     */
    public static void autoReplace(String filePath, String oldstr, String newStr) {
        //创建文件
        File file = new File(filePath);
        //记录文件长度
        Long fileLength = file.length();
        //记录读出来的文件的内容
        byte[] fileContext = new byte[fileLength.intValue()];
        FileInputStream in = null;
        PrintWriter out = null;
        try {
            in = new FileInputStream(filePath);
            //读出文件全部内容(内容和文件中的格式一致,含换行)
            in.read(fileContext);
            // 避免出现中文乱码
            String str = new String(fileContext, "utf-8");
            //修改对应字符串内容
            str = str.replace(oldstr, newStr);
            //再把新的内容写入文件
            out = new PrintWriter(filePath);
            out.write(str);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                out.flush();
                out.close();
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

结果：