java bean与xml相互转换

最新推荐文章于 2024-06-13 11:24:43 发布

xianggugou

最新推荐文章于 2024-06-13 11:24:43 发布

阅读量1.7k

点赞数

分类专栏： java 文章标签： xml与bean互转

本文链接：https://blog.csdn.net/u013627689/article/details/78279464

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

java bean 与xml相互转换的方式有多种。这里介绍jaxb2.0和xstream的方式。首先需要引入xstream和jaxb2.0的jar包

<dependency>
    <groupId>com.thoughtworks.xstream</groupId>
    <artifactId>xstream</artifactId>
    <version>1.4.5</version>
</dependency>
<dependency>
    <groupId>javax.xml.bind</groupId>
    <artifactId>jaxb-api</artifactId>
    <version>2.2.3</version>
</dependency>

xstream方式

1. 实体类定义
1.1Book.java

public class Book {
    @XStreamAlias("Name")//通过注解的方式重定义节点名称
    private String name;
    private String author;

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

}

1.2Address.java

@XStreamAlias("Address")
public class Address {
    private String street;

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }
}

1.3Student.java

public class Student {

    @XStreamAlias("Name")
    private String name;
    //自定义的类型转换器
    @XStreamConverter(value=MyDateConverter.class,strings={"yyyyMMddHHmmss"})
    @XStreamAlias("Birth")
    private Date birthday;
    @XStreamAlias("Address")
    private Address address;
    @XStreamAlias("books")
    private List<Book> list;

    public String getName() {
        return name;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public List<Book> getList() {
        return list;
    }

    public void setList(List<Book> list) {
        this.list = list;
    }
}

2. 自定义类型转换器

/**
 * 通过注解对不同Date格式的支持
 * <p/>
 * XStream中DateConverter，它默认支持的格式是：yyyy-MM-dd HH:mm:ss.S 'UTC'
 * 通过@XStreamConverter注解可以定义自己的Date格式
 * <p/>
 * DateConverter(String defaultFormat, String[] acceptableFormats, TimeZone timeZone)
 * Construct a DateConverter with a given TimeZone
 */
public class MyDateConverter extends DateConverter {

    public MyDateConverter(String dateFormat) {

        super(dateFormat, new String[]{dateFormat}, TimeZone.getTimeZone("GMT+8"));
    }
}

3. xstream 转换工具类
工具类实现bean 和xml 之间相互转换

import com.hgsoft.yfzx.consumption.pos.entity.*;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.StaxDriver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;

public abstract class XStreamUtil {

    private final static Logger logger = LoggerFactory.getLogger(XStreamUtil.class);

    private final static StaxDriver domDriver = new StaxDriver();
    private final static XStream o2x = new XStream(domDriver);
    private final static XStream x2o = new XStream(domDriver);

    private final static void initO2X() {
        List<Class> basic = new ArrayList(3);
        //需要把用到的实体类都添加，否则不会使用注解方式来定义别名，但是这样的方式不好。代码侵入大
        basic.add(Student.class);
        basic.add(Address.class);
        basic.add(Book.class);
        Class[] clazzs = new Class[basic.size()];
        设置使用注解方式来处理别名信息
        o2x.processAnnotations(basic.toArray(clazzs));
    }

    private final static void initX2O() {
        List<Class> basic = new ArrayList(3);
        basic.add(Student.class);
        basic.add(Address.class);
        basic.add(Book.class);
        Class[] clazzs = new Class[basic.size()];
        x2o.processAnnotations(basic.toArray(clazzs));
    }

    static {
        initO2X();
        initX2O();
    }

    /**
     * 实体类转xml字符串
     * @param obj 实体类
     * @return
     * @throws Exception
     */
    public static String object2Xml(Object obj) throws Exception {
        if (null == obj) {
            return null;
        }
        StringWriter writer = new StringWriter();
        o2x.toXML(obj, writer);
        return writer.toString();
    }

    /**
     * 
     * xml字符串转实体类
     * @param xml 字符串
     * @param clazz 实体类
     * @return
     */
    public static Object xml2Object(String xml, Class<?> clazz) {
        if (null == xml || "".equals(xml.trim())) {
            return null;
        }
        Object obj = null;
        try {
            obj = x2o.fromXML(xml, clazz.newInstance());
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return obj;
    }
}

jaxb2.0方式

1. 实体类定义
1.1Summary.java

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;


@XmlRootElement(name = "Message")//表示该类是XML根元素  name属性定义了XML根元素的元素名
@XmlType(propOrder = { "authInfo", "summaryDetail" })
//定义XML的生成规则 propOrder 属性在xml里的出现顺序
public class Summary {

    private AuthInfo authInfo;
    private SummaryDetail summaryDetail;

    @XmlElement(name = "AuthInfo")//定义生成后的xml的属性名，这个和xstream区别是这个写在get方法上
    public AuthInfo getAuthInfo() {
        return authInfo;
    }

    public void setAuthInfo(AuthInfo authInfo) {
        this.authInfo = authInfo;
    }

    @XmlElement(name = "Detail")
    public SummaryDetail getSummaryDetail() {
        return summaryDetail;
    }

    public void setSummaryDetail(SummaryDetail summaryDetail) {
        this.summaryDetail = summaryDetail;
    }
}

1.2 AuthInfo.java

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;

@XmlType(propOrder = { "username", "password"})//节点显示的顺序
public class AuthInfo {

    private String username;
    private String password;

    @XmlElement(name = "UserName")
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @XmlElement(name = "Password")
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

1.3 SummaryDetail.java

import com.hgsoft.yfzx.consumption.pos.util.JaxbBigDecimalAdapter;
import com.hgsoft.yfzx.consumption.pos.util.JaxbDateAdapter;
import com.hgsoft.yfzx.consumption.pos.util.JaxbThirdDateAdapter;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;

@XmlType(propOrder = { "serviceId", "oprDt","bizCount" ,"bizAmount"})
public class SummaryDetail {

    private String serviceId;//服务商编号
    private Date oprDt;//交易时间
    private Integer bizCount;//交易总条数
    private BigDecimal bizAmount;//交易总金额

    @XmlElement(name = "ServiceId")
    public String getServiceId() {
        return serviceId;
    }

    public void setServiceId(String serviceId) {
        this.serviceId = serviceId;
    }

    @XmlElement(name = "OprDt")
    @XmlJavaTypeAdapter(JaxbThirdDateAdapter.class)
    public Date getOprDt() {
        return oprDt;
    }

    public void setOprDt(Date oprDt) {
        this.oprDt = oprDt;
    }

    @XmlElement(name = "BizCount")
    public Integer getBizCount() {
        return bizCount;
    }

    public void setBizCount(Integer bizCount) {
        this.bizCount = bizCount;
    }

    @XmlElement(name = "BizAmount")
    @XmlJavaTypeAdapter(JaxbBigDecimalAdapter.class)//自定义类型转换器
    public BigDecimal getBizAmount() {
        return bizAmount;
    }

    public void setBizAmount(BigDecimal bizAmount) {
        this.bizAmount = bizAmount;
    }
}

2. 自定义转换器

import javax.xml.bind.annotation.adapters.XmlAdapter;
import java.math.BigDecimal;
import java.text.DecimalFormat;

/**
 * BigDeciaml保留两位小数
 */
public class JaxbBigDecimalAdapter extends XmlAdapter<String, BigDecimal> {

    private DecimalFormat df = new DecimalFormat("#0.00");

    @Override
    public BigDecimal unmarshal(String v) throws Exception {
        BigDecimal a = new BigDecimal(v);
        a = a.setScale(2, BigDecimal.ROUND_HALF_UP);
        return a;
    }

    @Override
    public String marshal(BigDecimal v) throws Exception {
        if (v != null) {
            return df.format(v);
        }
        return null;
    }

}

import javax.xml.bind.annotation.adapters.XmlAdapter;
import java.text.SimpleDateFormat;
import java.util.Date;

public class JaxbThirdDateAdapter extends XmlAdapter<String, Date> {

    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

    @Override
    public Date unmarshal(String v) throws Exception {
        return sdf.parse(v);
    }

    @Override
    public String marshal(Date v) throws Exception {
        return sdf.format(v);
    }
}

3. 转换工具类
其一

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;

/**
 * XML的帮助类
 *
 * @version v1.0
 */
public class XmlHelper {
    /**
     * 将自定义数据对象转化为XML字符串
     *
     * @param clazz  自定义数据类型
     * @param object 自定义数据对象
     * @return XML字符串
     * @throws JAXBException 异常
     */
    public static String objectToXML(Class clazz, Object object)
            throws JAXBException {
        String xml = null;
        JAXBContext context = JAXBContext.newInstance(clazz);
        Marshaller m = context.createMarshaller();
        m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
        Writer w = new StringWriter();
        m.marshal(object, w);
        xml = w.toString();
        return xml;
    }

    /**
     * 将XML字符串转化为自定义数据对象
     *
     * @param clazz 自定义数据类型
     * @param xml   XML字符串
     * @return 自定义数据对象
     * @throws JAXBException 异常
     */
    public static Object xmlToObject(Class clazz, String xml)
            throws JAXBException {
        JAXBContext context = JAXBContext.newInstance(clazz);
        Unmarshaller um = context.createUnmarshaller();
        return um.unmarshal(new StringReader(xml));
    }
}

其二

import org.apache.commons.lang.StringUtils;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlAnyElement;
import javax.xml.namespace.QName;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Collection;

/**
 * 使用Jaxb2.0实现XML<->Java Object的Binder.
 * <p/>
 * 特别支持Root对象是List的情形.
 *
 * @author
 */
public class JaxbUtil {
    // 多线程安全的Context.
    private JAXBContext jaxbContext;

    /**
     * @param types 所有需要序列化的Root对象的类型.
     */
    public JaxbUtil(Class<?>... types) {
        try {
            jaxbContext = JAXBContext.newInstance(types);
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Java Object->Xml.
     */
    public String toXml(Object root, String encoding) {
        try {
            StringWriter writer = new StringWriter();
            createMarshaller(encoding).marshal(root, writer);
            return writer.toString();
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Java Object->Xml, 特别支持对Root Element是Collection的情形.
     */
    @SuppressWarnings("unchecked")
    public String toXml(Collection root, String rootName, String encoding) {
        try {
            CollectionWrapper wrapper = new CollectionWrapper();
            wrapper.collection = root;

            JAXBElement<CollectionWrapper> wrapperElement = new JAXBElement<CollectionWrapper>(
                    new QName(rootName), CollectionWrapper.class, wrapper);

            StringWriter writer = new StringWriter();
            createMarshaller(encoding).marshal(wrapperElement, writer);

            return writer.toString();
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Xml->Java Object.
     */
    @SuppressWarnings("unchecked")
    public <T> T fromXml(String xml) {
        try {
            StringReader reader = new StringReader(xml);
            return (T) createUnmarshaller().unmarshal(reader);
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Xml->Java Object, 支持大小写敏感或不敏感.
     */
    @SuppressWarnings("unchecked")
    public <T> T fromXml(String xml, boolean caseSensitive) {
        try {
            String fromXml = xml;
            if (!caseSensitive)
                fromXml = xml.toLowerCase();
            StringReader reader = new StringReader(fromXml);
            return (T) createUnmarshaller().unmarshal(reader);
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建Marshaller, 设定encoding(可为Null).
     */
    public Marshaller createMarshaller(String encoding) {
        try {
            Marshaller marshaller = jaxbContext.createMarshaller();

            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);

            if (StringUtils.isNotBlank(encoding)) {
                marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
            }
            return marshaller;
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 创建UnMarshaller.
     */
    public Unmarshaller createUnmarshaller() {
        try {
            return jaxbContext.createUnmarshaller();
        } catch (JAXBException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 封装Root Element 是 Collection的情况.
     */
    public static class CollectionWrapper {
        @SuppressWarnings("unchecked")
        @XmlAnyElement
        protected Collection collection;
    }
}