使用JYaml实现Java对象与Yaml间的序列化与反序列化

JYaml是Java语言使用的Yaml库，能够用于读写Yaml文档，并能够实现Java对象和Yaml代码间的转换。

Yaml技术主页：http://yaml.org/

JYaml下载地址： http://sourceforge.net/projects/jyaml

下载下来是一个jar包（jyaml-1.3.jar） ，引入工程后便可使用，个人JDK版本为1.8

设咱们有一个名为Hero的类，将Hero类转变为对应yaml代码的写法为：

String yaml = Yaml.dump(hero);

再将这段代码转换为Hero类的写法为：

Hero result = (Hero) Yaml.load(yaml);

另外一种写法也能够：

Hero result = Yaml.loadType(yaml, Hero.class);

下面咱们举个例子，来讲明这两段代码的用法。

类Hero的实现以下：

import java.util.Date;
import java.util.LinkedList;

public class Hero {
    
    // 编号
    private long id;
    // 名称
    private String name;
    // 等级
    private int level;
    // 性别
    private Boolean gender;
    // 出生日期
    private Date birthDate;
    // 所获荣誉
    private String[] honors;
    // 改动记录
    private LinkedList<String> logs = new LinkedList<String>();
    // 配偶
    private Hero spouse;
    // 子女
    private Hero[] children;
    
    // Getter & Setter
    public long getId() {
        return id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getLevel() {
        return level;
    }
    public void setLevel(int level) {
        this.level = level;
    }
    public Boolean getGender() {
        return gender;
    }
    public void setGender(Boolean gender) {
        this.gender = gender;
    }
    public Date getBirthDate() {
        return birthDate;
    }
    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }
    public String[] getHonors() {
        return honors;
    }
    public void setHonors(String[] honors) {
        this.honors = honors;
    }
    public LinkedList<String> getLog() {
        return logs;
    }
    public void setLog(LinkedList<String> logs) {
        this.logs = logs;
    }
    public Hero getSpouse() {
        return spouse;
    }
    public void setSpouse(Hero spouse) {
        this.spouse = spouse;
    }
    public Hero[] getChildren() {
        return children;
    }
    public void setChildren(Hero[] children) {
        this.children = children;
    }
    
    public String toString()  
    {
        StringBuilder sb = new StringBuilder();
        sb.append("id:" + id + "\n");
        sb.append("name:" + name + "\n");
        sb.append("level:" + level + "\n");
        sb.append("gender:" + gender + "\n");
        sb.append("birthDate:" + birthDate.toString() + "\n");
        sb.append("honors:" + String.join(",", honors) + "\n");
        sb.append("logs:" + String.join(",", logs) + "\n");
        sb.append("spouse:" + spouse.name + "\n");
        sb.append("children:");
        for (int i = 0; i < children.length; i++) {
            if (i < children.length - 1) {
                sb.append(children[i].name + ",");
            } else {
                sb.append(children[i].name);
            }
        }
        sb.append("\n");
        return sb.toString();
    }
}

在main函数中新建一Hero类，代码以下：

Hero hero = new Hero();

hero.setId(1L);
hero.setName("Tsybius2014");
hero.setLevel(5);
hero.setGender(true);
try {
    hero.setBirthDate((new SimpleDateFormat("yyyy/MM/dd")).parse("1991/09/20"));
} catch (ParseException e) {
    e.printStackTrace();
}
hero.setHonors(new String[] {"abcdefg", "hijklmn", "opqrst", "uvwxyz"});
hero.getLog().addLast("log1");
hero.getLog().addLast("log2");
hero.getLog().addLast("log3");

Hero spouse = new Hero();
spouse.setId(2L);
spouse.setName("Galatea");
spouse.setGender(false);
spouse.setHonors(new String[] {"Honor1", "Honor2"});
hero.setSpouse(spouse);

Hero child1 = new Hero();
child1.setId(3L);
child1.setName("Quintus");
Hero child2 = new Hero();
child2.setId(4L);
child2.setName("Gaius");
hero.setChildren(new Hero[] {child1, child2});

String yaml = Yaml.dump(hero);
System.out.println(yaml);

最后输出的结果为：

--- !Hero
birthDate: !java.util.Date "685296000000"
children: !Hero[]
  - !Hero
    id: !java.lang.Long 3
    name: Quintus
  - !Hero
    id: !java.lang.Long 4
    name: Gaius
gender: true
honors: !java.lang.String[]
  - abcdefg
  - hijklmn
  - opqrst
  - uvwxyz
id: !java.lang.Long 1
level: 5
log: !java.util.LinkedList
  - log1
  - log2
  - log3
name: Tsybius2014
spouse: !Hero
  gender: false
  honors: !java.lang.String[]
    - Honor1
    - Honor2
  id: !java.lang.Long 2
  name: Galatea

现将这段yaml代码再反序列化到对象中，代码以下：

Hero result = (Hero) Yaml.load(yaml);
//Hero result = Yaml.loadType(yaml, Hero.class); //另外一种方法
System.out.println(result);

控制台输出的结果为：

id:1
name:Tsybius2014
level:5
gender:true
birthDate:Fri Sep 20 00:00:00 CST 1991
honors:abcdefg,hijklmn,opqrst,uvwxyz
logs:log1,log2,log3
spouse:Galatea
children:Quintus,Gaius

最后顺便再提一下，Java对象与XML间的序列化与反序列化，能够经过下面两个函数实现

import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

public class XmlParser {
    /**
     * 将对象序列化为XML
     * @param entity
     * @return
     */
    public static <T> String parseToXml(T entity) {  
        ByteArrayOutputStream out = new ByteArrayOutputStream();  
        XMLEncoder encoder = new XMLEncoder(new BufferedOutputStream(out));  
        encoder.writeObject(entity);  
        encoder.close();  
        return out.toString();  
    }  
    /**
     * 将XML反序列化到指定对象
     * @param xml
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T loadFromXml(String xml) {  
        ByteArrayInputStream in = new ByteArrayInputStream(xml.getBytes());  
        XMLDecoder decoder = new XMLDecoder(new BufferedInputStream(in));  
        decoder.close();  
        return (T) decoder.readObject();  
    }  
}

END