java-xml解析

目录

XML转对象

JAXB注解

示例

xml和java对象互转的工具类

XML转map

---

XML转对象

JAXB注解

1.@XmlRootElement，用于类级别的注解，对应xml的跟元素。通过name属性定义这个根节点的名称。

2.@XmlAccessorType，定义映射这个类中的何种类型都需要映射到xml。(如果不存在@XmlAccessorType,默认使用XmlAccessType.PUBLIC_MEMBER注解)

　　参数：XmlAccessType.FIELD: java对象中的所有成员变量。

　　XmlAccessType.PROPERTY：java对象中所有通过getter/setter方式访问的成员变量。

　　XmlAccessType.PUBLIC_MEMBER：java对象中所有的public访问权限的成员变量和通过getter/setter方式访问的成员变量。

　　XmlAccessType.NONE: java对象的所有属性都不映射为xml的元素。

3.@XmlAttribute，用于把java对象的属性映射为xml的属性,并可通过name属性为生成的xml属性指定别名。

4.@XmlElement，指定一个字段或get/set方法映射到xml的节点。通过name属性定义这个根节点的名称。

5.@XmlElementWrapper，为数组或集合定义一个父节点。通过name属性定义这个父节点的名称。

示例

学生类，Student如下：

public class Student {
    String name; //姓名
    String sex; //性别
    int number; //学号
    String className; //班级
    List<String> hobby; //爱好

    public Student(){
    }

    public Student(String name,String sex,int number,String className,List<String> hobby)     {
        this.name = name;
        this.sex = sex;
        this.number = number;
        this.className = className;
        this.hobby = hobby;
    }

    @XmlAttribute(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @XmlAttribute(name="sex")
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

    @XmlAttribute(name="number")
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }

    @XmlElement(name="className")
    public String getClassName() {
        return className;
    }
    public void setClassName(String className) {
        this.className = className;
    }

    @XmlElementWrapper(name="hobbys")
    @XmlElement(name = "hobby")
    public List<String> getHobby() {
        return hobby;
    }
    public void setHobby(List<String> hobby) {
        this.hobby = hobby;
    }
}

学生集合类，StudentList如下：

@XmlRootElement(name="list")
public class StudentList {
    List<Student> students; //所有学生信息的集合
    @XmlElement(name = "student")
    public List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }
}

xml和java对象互转的工具类

(通过Marshaller类实现将对象转换为xml，同时也可利用Unmarshaller类进行xml转换为类)：

/**
* java对象转换为xml
* @param obj java对象
* @param load java对象.Class
* @return
* @throws JAXBException
*/
public static String beanToXml(Object obj,Class<?> load) throws JAXBException{
    JAXBContext context = JAXBContext.newInstance(load);
    Marshaller marshaller = context.createMarshaller();
    marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    marshaller.setProperty(Marshaller.JAXB_ENCODING, "GBK");
    StringWriter writer = new StringWriter();
    marshaller.marshal(obj,writer);
    return writer.toString();
}

/**
* xml文件配置转换为对象
* @param xmlstr xml
* @param load java对象.Class
* @return java对象
* @throws JAXBException
* @throws IOException
*/

public static Object xmlToBean(String xmlstr,Class<?> load) throws JAXBException, IOException {
    JAXBContext context = JAXBContext.newInstance(load);
    Unmarshaller unmarshaller = context.createUnmarshaller();
    Object object = unmarshaller.unmarshal(new ByteArrayInputStream(xmlstr.getBytes("utf-8")));
    return object;
}

---

XML转map

1、依赖

        <!-- dom4j -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>

2、工具类

import org.dom4j.DocumentHelper;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

import java.io.ByteArrayOutputStream;
import java.util.*;

public class XMLFormatUtil {
    /***
     *XML格式字符串转换成MAP,不包括List
     * @param xml
     * @return
     */
    public static Map xmlToMap(String xml) {
        try {
            Map map = new HashMap();
            org.dom4j.Document document = DocumentHelper.parseText(xml);
            org.dom4j.Element nodeElement = document.getRootElement();
            List node = nodeElement.elements();
            for (Iterator it = node.iterator(); it.hasNext(); ) {
                org.dom4j.Element elm = (org.dom4j.Element) it.next();
                map.put(elm.getName(), elm.getText());
                elm = null;
            }
            node = null;
            nodeElement = null;
            document = null;
            return map;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /***
     * XML格式字符串转换成list
     * @param xml
     * @return
     */
    public static List xmlToList(String xml) {
        try {
            List<Map> list = new ArrayList<Map>();
            org.dom4j.Document document = DocumentHelper.parseText(xml);
            org.dom4j.Element nodesElement = document.getRootElement();
            List nodes = nodesElement.elements();
            for (Iterator its = nodes.iterator(); its.hasNext(); ) {
                org.dom4j.Element nodeElement = (org.dom4j.Element) its.next();
                Map map = xmlToMap(nodeElement.asXML());
                list.add(map);
                map = null;
            }
            nodes = null;
            nodesElement = null;
            document = null;
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /***
     * XML格式字符串转换成map,包括List
     * @param xml
     * @return
     */
    public static Map xmlToListMap(String xml) {
        try {
            Map reMap = new HashMap();
            org.dom4j.Document document = DocumentHelper.parseText(xml);
            org.dom4j.Element nodesElement = document.getRootElement();
            List nodes = nodesElement.elements();
            for (Iterator its = nodes.iterator(); its.hasNext(); ) {
                org.dom4j.Element nodeElement = (org.dom4j.Element) its.next();
                if (nodeElement.isTextOnly()) {
                    reMap.put(nodeElement.getName(), nodeElement.getText());
                } else {
                    List<Map> reList = xmlToList(nodeElement.asXML());
                    reMap.put(nodeElement.getName(), reList);
                    reList = null;
                }
            }
            nodes = null;
            nodesElement = null;
            document = null;
            return reMap;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /***
     * List<Map>转xml格式String
     * @param list
     * @param rootName
     * @return
     */
    public static String list2xml(List<?> list, String rootName) {
        org.dom4j.Document document = org.dom4j.DocumentHelper.createDocument();
        org.dom4j.Element nodesElement = document.addElement(rootName);
        list2xml(list, nodesElement);
        return doc2String(document);
    }

    /***
     * list的element转xml格式String
     * @param list
     * @param element
     * @return
     */
    public static org.dom4j.Element list2xml(List list, org.dom4j.Element element) {
        int i = 0;
        for (Object o : list) {
            org.dom4j.Element nodeElement = element.addElement("Map");
            if (o instanceof Map) {
                //nodeElement.addAttribute("type", "o");
                Map m = (Map) o;
                for (Iterator iterator = m.entrySet().iterator(); iterator.hasNext(); ) {
                    Map.Entry entry = (Map.Entry) iterator.next();
                    org.dom4j.Element keyElement = nodeElement.addElement(entry.getKey().toString());
                    if (entry.getValue() instanceof List) {
                        //keyElement.addAttribute("type", "l");
                        list2xml((List) entry.getValue(), keyElement);
                    } else {
                        //keyElement.addAttribute("type", "s");
                        keyElement.setText(entry.getValue().toString());
                    }
                }
            } else if (o instanceof List) {
                //nodeElement.addAttribute("type", "l");
                list2xml((List) o, nodeElement);
            } else {
                org.dom4j.Element keyElement = nodeElement.addElement("value");
                keyElement.addAttribute("num", String.valueOf(i));
                keyElement.setText(String.valueOf(o));
            }
            i++;
        }
        return element;
    }

    /***
     * 文本转换String
     * @param document
     * @return
     */
    public static String doc2String(org.dom4j.Document document) {
        String s = "";
        try {
            // 使用输出流来进行转化
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            // 使用UTF-8编码
            OutputFormat format = new OutputFormat();
            format.setSuppressDeclaration(true);
            XMLWriter writer = new XMLWriter(out, format);
            writer.write(document);
            s = out.toString("UTF-8");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return s;
    }
}

参考：https://blog.csdn.net/m0_37499059/article/details/80505567