JAXB 实现JavaBean与xml互转（二）-封装

上篇博客对JAXB的进行了相关介绍以及简单的实例，但是运用到项目中显然还不够灵活，下面我们继续来对其进行封装。

1、xmlToObject和objectToXml方法封装

详细说明见代码注释

package com.jaxb;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

/**
 * JAXB，xml和object转换类
 *
 */
public class JAXB {
    
//    /**
//     * xml转bean(未封装)
//     * @param xml
//     * @return
//     * @throws JAXBException
//     */
//    public static Student xmlToBean(String xml) throws JAXBException{
//        //获取JAXBContext的新实例，传参数Student.class，创建的JAXBContext将识别Student类
//        JAXBContext jaxbContext = JAXBContext.newInstance(Student.class);
//        //创建Unmarshaller对象，可以将xml数据转换成java对象
//        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
//        //将字符串或字节数组变成输入流
//        InputStream inputStream = new ByteArrayInputStream(xml.getBytes());
//        //解析inputStream，返回java对象
//        Student student = (Student) unmarshaller.unmarshal(inputStream);
//        return student;
//    }
    
    /**
     * xmlToObject
     * @param <T> 三个T，第一个是定义泛型，第二个是返回的类型，第三个是参数的类型，这三个类型是由参数的类型来决定的。 
     * @param objectClass
     * @param xml
     * @return T
     * @throws JAXBException
     */
    @SuppressWarnings("unchecked")
    public static <T> T xmlToObject(Class<T> objectClass,String xml) throws JAXBException{
        InputStream inputStream = null;
        Unmarshaller unmarshaller = null;
        JAXBContext jaxbContext = null;

        //获取JAXBContext的新实例，创建的JAXBContext将识别参数objectClass类 new class[] objectClass.getClass()
        jaxbContext = JAXBContext.newInstance(objectClass);
        //创建Unmarshaller对象，可以将xml数据转换成java对象
        unmarshaller = jaxbContext.createUnmarshaller();  
        //将字符串或字节数组变成输入流
        inputStream = new ByteArrayInputStream(xml.getBytes());
        //判断输入流是否为空（调用close()时必须不为空）
        if(inputStream != null){
            try
            {
                //清除输入流内存占用
                inputStream.close();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }
        }
        //解析inputStream，返回对象
        return (T)unmarshaller.unmarshal(inputStream); 
    }  
    
    /**
     * objectToXml
     * @param object
     * @param format
     * @return string
     * @throws JAXBException
     */
    @SuppressWarnings("unchecked")
    public static <T> T objectToXml(Object object, boolean format) throws JAXBException
    {
        String xml;
        Marshaller marshaller = null;
        JAXBContext jaxbContext = null;
        ByteArrayOutputStream baos = null;
        
        jaxbContext = JAXBContext.newInstance(object.getClass());
        marshaller = jaxbContext.createMarshaller();
        
        //设置输出数据的编码格式(以防乱码)
        marshaller.setProperty("jaxb.encoding",  "UTF-8");
        //设置输出数据的编码格式,System.getProperty("file.encoding")表示格式同调用该方法的最上层的类的编码方式(这里就是main方法的java文件的保存编码)
        //marshaller.setProperty("jaxb.encoding", System.getProperty("file.encoding"));
        
        //格式化xml
        marshaller.setProperty("jaxb.formatted.output", format);
        
        baos = new ByteArrayOutputStream();
        //将object转换baos(字节数组)
        marshaller.marshal(object, baos);
        //转换为string类型
        xml = baos.toString();
        
        if(baos != null){
            try
            {
                baos.close();
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }
        }
        return (T)xml;
    }
}

2、实例-object

用来转换的object-Student实体：

package com.jaxb;

import java.io.Serializable;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient;

/**
 * @XmlAccessorType(XmlAccessType.FIELD):类中的每个非静态、非瞬态字段将会自动绑定到 XML，除非由 XmlTransient 注释。
 * @XmlRootElement:xml根标签名
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "student")
public class Student implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

        //将属性映射到派生于属性名称的 XML元素
	@XmlElement
	private String id;
	
	@XmlElement
	private String name;
	
	@XmlTransient
	private String country;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public String getCountry() {
		return country;
	}

	public void setCountry(String country) {
		this.country = country;
	}
	
	
}

@XmlAccessorType(XmlAccessType.FIELD) 枚举常量摘要
FIELD           JAXB 绑定类中的每个非静态、非瞬态字段将会自动绑定到 XML，除非由 XmlTransient 注释。
NONE           所有字段或属性都不能绑定到 XML，除非使用一些 JAXB 注释专门对它们进行注释。
PROPERTY           JAXB 绑定类中的每个获取方法/设置方法对将会自动绑定到 XML，除非由 XmlTransient 注释。
PUBLIC_MEMBER           每个公共获取方法/设置方法对和每个公共字段将会自动绑定到 XML，除非由 XmlTransient 注释。

3、实例-main

先将xml转为object，再将object转为xml：

package com.jaxb;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;


public class JaxbMain {

    public static void main(String[] args) throws JAXBException {
        //xml
        String xml = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?><student><id>001</id><name>AKK</name><country>中国</country></student>";
        
        //xmlToObject
        Student student = (Student) JAXB.xmlToObject(Student.class, xml);
        
        System.out.println(student.getName());
        
        xml = null;
        //objectToXml
        xml = JAXB.objectToXml(student, true);
        
        System.out.println(xml);
        
    }
}

4、运行-输出结果

AKK
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<student>
    <id>001</id>
    <name>AKK</name>
</student>

总的来说，封装并不难，不过是把与业务相关的参数和返回值进行抽象，通常使用也就是通过泛型来实现，正如我们JAXB的转换方法。