java xml 转换对象

最新推荐文章于 2024-01-11 11:04:03 发布
最新推荐文章于 2024-01-11 11:04:03 发布
阅读量1.6k 收藏
点赞数
分类专栏： javaEE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/javahepeng/article/details/69555438
版权

使用JAXB 来完成  xml 转换为java对象。





示例 如



<list>
 <acmUser>
  <userName>wangfeng</userName>
  <userGroupId>761</userGroupId>
  <userGroupName>sub54</userGroupName>
  <fullName>wangfeng</fullName>
  <status>1</status>
  <userCreateTime>2011-12-22</userCreateTime>
  <invalidTime></invalidTime>
  <feeType>2</feeType>
  <currentBalance>0.00</currentBalance>
  <ifWsmEnable>0<ifWsmEnable>
  <link op="GET" rel="self" href="http://192.168.1.103/imcrs/uam/acmUser/wangfeng"/>
 </acmUser>
 ...
</list>  
将以上xml 内容转换为对象， 由于 acmUser 是list中的多个子元素。

需要定义2个实体类


/**
 * acmlist
 * @author hp
 *
 */
@XmlAccessorType(XmlAccessType.FIELD)
//XML文件中的根标识  
@XmlRootElement(name = "list")  
//控制JAXB 绑定类中属性和字段的排序  
@XmlType(propOrder = {   
     "acmUser"  
})  
public class AcmUserList  implements Serializable{
    
    /**
     *
     */
    private static final long serialVersionUID = 625542009032819964L;
    public List<AcmUser> acmUser;

    public List<AcmUser> getAcmUser() {
        return acmUser;
    }

    public void setAcmUser(List<AcmUser> acmUser) {
        this.acmUser = acmUser;
    }

}



说明   @XmlRootElement(name = "list")         list 即为xml 根节点名称。





@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "acmUser")
public  class AcmUser implements Serializable{

    @XmlTransient
    private static final long serialVersionUID = -4966651810940446365L;

    @XmlElement
    private String platUserId;
    @XmlElement
    private String fullName;
    @XmlElement
    private String certification;
    @XmlElement
    private String phone;
    @XmlElement
    private String userGroupId;
    @XmlElement
    private String userGroupName;
    @XmlElement
    private String UserId;
    @XmlElement
    private String userName;
    @XmlElement
    private String userPassword;
    @XmlElement
    private String appliedService;
    @XmlElement
    private String serviceTemplateId;
    @XmlElement
    private String userIp;
    @XmlElement
    private String invalidTime;
    
    public String getPlatUserId() {
        return platUserId;
    }
    public void setPlatUserId(String platUserId) {
        this.platUserId = platUserId;
    }
    public String getUserPassword() {
        return userPassword;
    }
    public void setUserPassword(String userPassword) {
        this.userPassword = userPassword;
    }
    public String getUserId() {
        return UserId;
    }
    public void setUserId(String userId) {
        UserId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserGroupId() {
        return userGroupId;
    }
    public void setUserGroupId(String userGroupId) {
        this.userGroupId = userGroupId;
    }
    public String getUserGroupName() {
        return userGroupName;
    }
    public void setUserGroupName(String userGroupName) {
        this.userGroupName = userGroupName;
    }
    public String getFullName() {
        return fullName;
    }
    public void setFullName(String fullName) {
        this.fullName = fullName;
    }
    public String getCertification() {
        return certification;
    }
    public void setCertification(String certification) {
        this.certification = certification;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getAppliedService() {
        return appliedService;
    }
    public void setAppliedService(String appliedService) {
        this.appliedService = appliedService;
    }
    public String getServiceTemplateId() {
        return serviceTemplateId;
    }
    public void setServiceTemplateId(String serviceTemplateId) {
        this.serviceTemplateId = serviceTemplateId;
    }
    public String getUserIp() {
        return userIp;
    }
    public void setUserIp(String userIp) {
        this.userIp = userIp;
    }
    public String getInvalidTime() {
        return invalidTime;
    }
    public void setInvalidTime(String invalidTime) {
        this.invalidTime = invalidTime;
    }
    @Override
    public String toString() {
        return "AcmUser [platUserId=" + platUserId + ", fullName=" + fullName
                + ", certification=" + certification + ", phone=" + phone
                + ", userGroupId=" + userGroupId + ", userGroupName="
                + userGroupName + ", UserId=" + UserId + ", userName="
                + userName + ", userPassword=" + userPassword
                + ", appliedService=" + appliedService + ", serviceTemplateId="
                + serviceTemplateId + ", userIp=" + userIp + ", invalidTime="
                + invalidTime + "]";
    }
    
}

 

@XmlRootElement(name = "acmUser") 这里的 acmUser 对应 xml中的 子元素的节点名称。




转换部分的代码

XmlConverter<AcmUserList> entity = new XmlConverter<AcmUserList>(AcmUserList.class);
                        userList = entity.unmarshal(xmlContent);
                        System.out.println(userList);




工具类


/**
 *
 * XML文档转换器。
 *
 * @param <T> 转换对象的类型
 */
public class XmlConverter<T> {

    /** 日志记录对象。 */
    private Log runLog = LogFactory.getLog(XmlConverter.class);
    
    /** 实体类型 */
    private Class<T> entityClass = null;
    
    /**
     * 构造函数。
     * @param entityClass 实体类型
     */
    public XmlConverter(Class<T> entityClass) {
        this.entityClass = entityClass;
    }
    
    /**
     * 创建没有表头的xmlString
     * @param t 需要转换的对象
     * @return
     */
    public String createJaxbXml(T t) {
        String xmlString = "";
        if (t == null) {
            runLog.info("createJaxbXml object is null.");
            return xmlString;
        }
        try {
            JAXBContext context = JAXBContext.newInstance(entityClass);
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
            // 去掉xml的头
            //marshaller.setProperty(Marshaller.JAXB_FRAGMENT,true);
            // 格式化xml
            //marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            // 把对象转化成xml字符串
            StringWriter writer = new StringWriter();
            marshaller.marshal(t, writer);
            String xmlDocument = writer.toString().trim();
            xmlString = xmlDocument;
            runLog.info("createJaxbXml xmlString: " + xmlString);
        } catch (JAXBException e) {
            runLog.error("createJaxbXml failure.", e);
        }
        return xmlString;
    }
    
    /**
     * 将XML文件解析并封装为实体集合。
     *
     * @param xmlContent
     *            XML文档内容
     * @param root
     *            是否去除根节点
     * @return 解析后的实体集合
     */
    public List<T> unmarshal(String xmlContent, boolean root) {
        // 构建结果实体集合
        List<T> resultList = new ArrayList<T>();
        if (StringUtils.isBlank(xmlContent)) {
            return resultList;
        }
        // 创建工厂对象，用户进行XML数据解析
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try {
            // 解析XML数据，生成DOM对象
            DocumentBuilder builder = factory.newDocumentBuilder();
            StringReader sr = new StringReader(xmlContent);
            InputSource is = new InputSource(sr);
            Document document = builder.parse(is);

            // 将根节点下的所有元素解析为对象
            NodeList nodeList = null;
            if (root) {
                // 去除根节点元素
                Element list = document.getDocumentElement();
                nodeList = list.getChildNodes();
            } else {
                // 将根节点下的所有元素解析为对象
                nodeList = document.getChildNodes();
            }

            int size = nodeList.getLength();
            //add by chenya 0503
            /*if (nodeList.getLength()== 0){
                resultList.add(null);
            }*///end  chenya
            
            for (int i = 0; i < size; i++) {
                resultList.add(createEntity(nodeList.item(i)));
            }
            // 释放内存
            is = null;
            try {
                sr.close();
            } catch (Exception e) {
            }
            sr = null;
            builder = null;
        } catch (Exception e) {
            runLog.error(e);
        } finally {
            factory = null;
        }
        return resultList;
    }
    
    /**
     * 将XML节点转换为对象(该对象必须配置@XmlRootElement属性)。
     *
     * @param node
     *            XML节点
     * @return 转换后的对象
     */
    @SuppressWarnings({ "unchecked" })
    public T unmarshal(String xml) {
        if(StringUtils.isBlank(xml)) return null;
        StringReader reader = null;
        try {
            JAXBContext jaxbCtx = JAXBContext.newInstance(entityClass);
            Unmarshaller unmarshaller = jaxbCtx.createUnmarshaller();
            reader = new StringReader(xml);
            return (T) unmarshaller.unmarshal(reader);
        } catch (JAXBException ex) {
            runLog.error(ex);
        }
        return null;
    }
    
    /**
     * 将xml文件转换为对象
     * @param context 文件路径
     * @return
     */
    @SuppressWarnings("unchecked")
    public T convertXmlString(String context) {
        try {
            JAXBContext jc = JAXBContext.newInstance(entityClass);
            Unmarshaller u = jc.createUnmarshaller();
            return (T) u.unmarshal(new File(context));
        } catch (JAXBException e) {
            runLog.error(e);
        }
        return null;
    }
    
    /**
     * 将xml文件转换为对象
     * @param fileConf  xml文件
     * @return
     */
    @SuppressWarnings("unchecked")
    public T convertXmlFile(File fileConf) {
        InputStream inputStrem = null;
        try {
            JAXBContext jc = JAXBContext.newInstance(entityClass);
            Unmarshaller u = jc.createUnmarshaller();
            inputStrem = new FileInputStream(fileConf);
            return (T) u.unmarshal(inputStrem);
        } catch (Exception e) {
            runLog.error(e);
        }
        return null;
    }
    
    /**
     * 将xml文件转换为对象
     * @param fileConf  xml文件
     * @return
     */
    @SuppressWarnings("unchecked")
    public T convertXmlInputStream(String context) {
        InputStream inputStrem = null;
        try {
            JAXBContext jc = JAXBContext.newInstance(entityClass);
            Unmarshaller u = jc.createUnmarshaller();
            inputStrem = Thread.currentThread()
                    .getContextClassLoader()
                    .getResourceAsStream(context);
            return (T) u.unmarshal(inputStrem);
        } catch (Exception e) {
            runLog.error(e);
        }
        return null;
    }

    public Class<T> getEntityClass() {
        return entityClass;
    }

    public void setEntityClass(Class<T> entityClass) {
        this.entityClass = entityClass;
    }
    
    /**
     * 将数据实体装载为XML文档内容。
     *
     * @param entities
     *            数据实体
     * @return 装载后的XML文档内容
     */
    public String marshal(List<T> entities) {
        // 初始化返回值
        String xmlContent = null;
        // 入参判断
        if (null == entities || 0 >= entities.size()) {
            return xmlContent;
        }
        // 先将内存中的数据结构表示为DOM文档格式
        // 然后再通过XSLT直接转换为XML字符流
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        ByteArrayOutputStream baos = null;
        try {
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.newDocument();

            // 将数据实体转换为XML元素并加入到根节点中
            for (T entity : entities) {
                addEntityToElement(entity, document);
            }

            // 数据全部存入DOM树结构中后，使用JAXP提供的XSLT直接进行转换
            TransformerFactory tFactory = TransformerFactory.newInstance();
            Transformer transformer = tFactory.newTransformer();
            // 设置目标XML文档的语言
            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
            // 转换源为存放输入信息的DOM数据结构
            DOMSource source = new DOMSource(document);
            // 构造转换目的流
            baos = new ByteArrayOutputStream();
            // 生成表示转换结果的数据结构，并设置转换目的流的字符编码
            StreamResult result = new StreamResult(baos);
            // 调用XSLT进行数据转换
            transformer.transform(source, result);
            // 将转换结果保存到xmlData属性中，注意对XML字符编码的转换
            xmlContent = baos.toString("UTF-8");

            // 清空引用
            result = null;
            source = null;
            transformer = null;
            tFactory = null;
            builder = null;
        } catch (Exception e) {
            runLog.error(e);
        } finally {
            // 释放内存
            factory = null;
            if (null != baos) {
                try {
                    baos.close();
                } catch (Exception e) {
                    runLog.error(e);
                }
            }
        }
        return xmlContent;
    }

    
    /**
     * 将对象转换为XML节点(需转换对象必须配置@XmlRootElement属性)。
     *
     * @param t
     *            需要转换的对象
     * @param parentNode
     *            转换后节点的父节点
     */
    private void addEntityToElement(T t, Node parentNode) {
        try {
            JAXBContext jaxbCtx = JAXBContext.newInstance(entityClass);
            Marshaller marshaller = jaxbCtx.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
                    Boolean.TRUE);
            marshaller.marshal(t, parentNode);
        } catch (JAXBException ex) {
            runLog.error(ex);
        }
    }

    /**
     * 将XML节点转换为对象(该对象必须配置@XmlRootElement属性)。
     *
     * @param node
     *            XML节点
     * @return 转换后的对象
     */
    @SuppressWarnings("unchecked")
    private T createEntity(Node node) {
        try {
            JAXBContext jaxbCtx = JAXBContext.newInstance(entityClass);
            Unmarshaller unmarshaller = jaxbCtx.createUnmarshaller();
            return (T) unmarshaller.unmarshal(node);
        } catch (JAXBException ex) {
            runLog.error(ex);
        }
        return null;
    }
}










java将xml转成对象_Java开发中对象与Xml之间互相转换
weixin_32331345的博客
02-16 4754
【web开发】☆★之Obj与Xml之间互相转换在有些项目的维护过程中，客户需要对某些数据库表进行添加字段，如果你老老实实的不断增加数据库字段，那么维护起来非常困难，同时也大大增加自己的工作量。因此，我采取的是将，新增字段转化成一个xml字符串，将这个xml存储到表中某一个字段中，同时，需要字段的时候解析这个xml字符串就行了，这样完全解决我们的问题，同时大大提高代码的可维护性！实例代码如下！1、模...
JAXB工具类 xml转为java对象 java对象转为xml
05-17
要将XML转换为Java对象，首先需要一个对应的Java类，该类的字段与XML元素对应。JAXB通过注解这些字段来完成映射，如`@XmlElement`、`@XmlAttribute`等。以下是一个简单的例子： ```java import javax.xml.bind....
xml文件自动转成java对象工具
01-05
xml文件自动转成java对象工具，生成xsd文件,xsd转java
Java 读取XML 并转为JAVA对象
小姐姐
06-27 4008
读取xml文件 XML转JAVA对象
JAVA xml格式转为java对象
Amelia_Liu的博客
11-07 682
【代码】JAVA xml格式转为java对象。
Java 解析XML成对象
夕四
09-23 3399
java 使用dom4j解析XML成对象
XML转换为JAVA对象的方法
09-20
将XML数据转换为Java对象，能够方便地在两者之间进行数据操作和处理。在这个过程中，XStream库扮演了关键角色。 XStream是一个强大的Java库，它可以将Java对象序列化为XML，同时也能将XML反序列化为等效的Java对象...
xml与Java对象的转换详解
08-30
在实际开发中，我们经常需要将XML文档转换为Java对象，反之亦然，以便于数据处理和操作。下面我们将详细介绍XML与Java对象之间的转换，并通过实例进行演示。 1. **XStream库的使用** XStream是一个用于Java的轻量...
java的xml和json相互转换工具类，亲测直接用
05-26
要将XML转换为JSON，我们需要使用Jackson的两个模块：`jackson-dataformat-xml`和`jackson-databind`。首先，引入这些依赖库到项目中。接着，可以创建一个`XmlToJson`工具类，包含以下方法： ```java import ...
基于java的转换xml.zip
05-28
在进行XML转换时，需要注意一些潜在问题，比如循环引用（对象之间相互引用）可能导致无限递归，以及安全性问题，因为XStream默认允许反序列化任何类，这可能会导致安全漏洞。因此，必须谨慎配置XStream，避免这些...
JAVA解析XML的四种方法
cnaning的专栏
03-31 423
XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。对于XML本身的语法知识与技术细节,需要阅读相关的技术文献,这里面包括的内容有DOM(Document Object Model),DTD(Document Type Definition),SAX(Simple API for XML),XSD(Xml Schema Definit...
Java解析Xml文件转为数据对象
AsterCass的博客
08-26 267
这里我们以弹幕的xml文件为例。
JAVA XML转对象
weixin_30909575的博客
07-13 853
public static Object getRootObjec(String xmlStr,Class obj) throws Exception{ StringBuffer xml=new StringBuffer();String str=xmlStr.substring(0, 6);if(!str.equals("<root>")){//如果没有<root>节点...
xml转java对象
weixin_43949803的博客
07-31 1251
controller接口接收xml文件转为实体类，直接获取各节点属性。 要点： 实体类的使用的xml JABX注解。 针对命名空间的解析，及配置命名空间后产生的前缀处理 针对xml直接生成java对象方法（解决方法的要点） 一、JABX注解： 参考W3C文档：https://www.w3cschool.cn/jaxb2/jaxb2-8pa22zoi.html 二、直接生成java对象的方法： 1、xml转xsd 在线转换工具：https://www.luxonsoftware.com/converter/
java操作XML转对象，对象装xml
zgp11_2018的博客
03-21 574
java中对象转xml
java 将XML解析处理成对应的对象
最新发布
weixin_45128512的博客
01-11 594
xml解析对象
xml操作
a8865423的博客
06-30 99
一：SAXReader读取xml信息到map /** * 解析微信发来的请求（XML） * * @param request * @return * @throws Exception */ @SuppressWarnings("unchecked") public static Map...
JAVA如何把XML文件转为对象
song_lyzz的博客
06-21 5325
上图为xml的文件内容对象类 代码的实现：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值