基于snakeyaml yaml 复杂set集合的配置

 参考官网：https://bitbucket.org/asomov/snakeyaml/wiki/Home

读取yaml工具类：

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

public class Util {

    public static String getLocalResource(String theName) {
        try {
            InputStream input;
            input = YamlDocument.class.getClassLoader().getResourceAsStream(theName);
            if (input == null) {
                throw new RuntimeException("Can not find " + theName);
            }
            BufferedInputStream is = new BufferedInputStream(input);
            StringBuilder buf = new StringBuilder(3000);
            int i;
            try {
                while ((i = is.read()) != -1) {
                    buf.append((char) i);
                }
            } finally {
                is.close();
            }
            String resource = buf.toString();
            // convert EOLs
            String[] lines = resource.split("\\r?\\n");
            StringBuilder buffer = new StringBuilder();
            for (int j = 0; j < lines.length; j++) {
                buffer.append(lines[j]);
                buffer.append("\n");
            }
            return buffer.toString();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

 

import junit.framework.TestCase;
import org.yaml.snakeyaml.Util;
import org.yaml.snakeyaml.Yaml;

import java.util.ArrayList;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;

public class TypeSafeSetWithInterfaceTest extends TestCase {
    /**
     * javaBean 转 yaml
     */
    public void testDumpYaml() {
        SetBean setBean = new SetBean();

        SortedSet<String> sortedSet = new TreeSet<String>();
        sortedSet.add("two");
        sortedSet.add("one");
        sortedSet.add("three");
        setBean.setSorted(sortedSet);

        SortedSet<Human> humans = new TreeSet<Human>();
        humans.add(new Developer("Fred", "creator"));
        humans.add(new Committer("John", "committer", 34));
        setBean.setHumans(humans);

        SortedSet<Committer> committers = new TreeSet<Committer>();
        committers.add(new Committer("Karl", "committer", 34));
        setBean.setCommitters(committers);

        Yaml yaml = new Yaml();
        String output = yaml.dumpAsMap(setBean);
        // System.out.println(output);
        String etalon = Util.getLocalResource("examples/set-bean-to-yaml.yaml");
        assertEquals(etalon, output);
    }

    /**
     * yaml to set
     */
    public void testLoadSet() {
        String output = Util.getLocalResource("examples/set-bean-to-yaml.yaml");
        // System.out.println(output);
        Yaml beanLoader = new Yaml();
        SetBean parsed = beanLoader.loadAs(output, SetBean.class);
        assertNotNull(parsed);

        SortedSet<String> sortedMap = parsed.getSorted();
        assertEquals(3, sortedMap.size());
        assertTrue(sortedMap.contains("one"));
        assertTrue(sortedMap.contains("two"));
        assertTrue(sortedMap.contains("three"));
        String first = sortedMap.iterator().next();
        assertEquals("one", first);

        // 字母顺序: one, three, two
        assertEquals("one", sortedMap.first());
        assertEquals("two", sortedMap.last());

        SortedSet<Human> humans = parsed.getHumans();
        assertEquals(2, humans.size());

        Developer fred = (Developer) humans.first();
        assertEquals("Fred", fred.getName());
        assertEquals("creator", fred.getRole());
        Committer john = (Committer) humans.last();
        assertEquals("John", john.getName());
        assertEquals("committer", john.getRole());
        assertEquals(34, john.getKey());


        // the order is not from YAML (must be sorted)
        SortedSet<Committer> committers = parsed.getCommitters();
        assertEquals(1, committers.size());
        assertEquals("Karl", committers.first().getName());
    }

    public static class SetBean {
        private SortedSet<String> sorted;
        private SortedSet<Human> humans;
        private SortedSet<Committer> committers;
        private String name;

        public SetBean() {
            name = "Bean123";
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public SortedSet<String> getSorted() {
            return sorted;
        }

        public void setSorted(SortedSet<String> sorted) {
            this.sorted = sorted;
        }

        public SortedSet<Human> getHumans() {
            return humans;
        }

        public void setHumans(SortedSet<Human> humans) {
            this.humans = humans;
        }

        public SortedSet<Committer> getCommitters() {
            return committers;
        }

        public void setCommitters(SortedSet<Committer> committers) {
            this.committers = committers;
        }
    }

    public static interface Human extends Comparable<Human> {

        public String getName();

        public void setName(String name);

    }

    public static class Developer implements Human {
        private String name;
        private String role;

        public Developer() {
        }

        public Developer(String name, String role) {
            this.name = name;
            this.role = role;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getRole() {
            return role;
        }

        public void setRole(String role) {
            this.role = role;
        }

        @Override
        public int compareTo(Human o) {
            return name.compareTo(o.getName());
        }
    }

    public static class Committer extends Developer {
        private int key;

        public Committer() {
        }

        public Committer(String string, String string2, int i) {
            super(string, string2);
            this.key = i;
        }

        public int getKey() {
            return key;
        }

        public void setKey(int key) {
            this.key = key;
        }
    }
}

yaml 配置文件：

? 号： 针对较为复杂的对象格式，可以使用问号加一个空格代表一个复杂的 key，配合一个冒号加一个空格代表一个 value： 

!! 号： !! YAML中使用!!做类型强行转换：这里是把Human制定对应的实现类

committers: !!set
  ? key: 34
    name: Karl
    role: committer
  : null
humans: !!set
  ? !!examples.collections.TypeSafeSetWithInterfaceTest$Developer
    name: Fred
    role: creator
  : null
  ? !!examples.collections.TypeSafeSetWithInterfaceTest$Committer
    key: 34
    name: John
    role: committer
  : null
name: Bean123
sorted: !!set
  one: null
  three: null
  two: null