XML读取和生成（总结）

在Java应用开发里面，xml文件的读写相当重要和频繁，因此抱着将代码通用化的思路，遂成下文。第一次写原创，或多或少存在某些不足，希望能得到你的宝贵意见，以将代码更加通用化，更加健壮，更加能适应变化需求！

 

person.xml:

 

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<persons>
   <person id="1">
    <name>qjq</name>
    <age>20</age>
    <sex>male</sex>
 </person>
 <person id="2">
    <name>hqx</name>
    <age>19</age>
    <sex>female</sex>
   </person>
</persons>

 

 

Person.java

 

public class Person
{
    private int    id;
    private String name;
    private int    age;
    private String sex;

    public int getId()
    {
        return id;
    }
   
    public void setId(int id)
    {
        this.id = id;
    }
   
    public String getName()
    {
        return name;
    }
   
    public void setName(String name)
    {
        this.name = name;
    }
   
    public int getAge()
    {
        return age;
    }
   
    public void setAge(int age)
    {
        this.age = age;
    }
   
    public String getSex()
    {
        return sex;
    }
   
    public void setSex(String sex)
    {
        this.sex = sex;
    }
   
}

 

 

ParsePeron.java

package aa;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/////////////////  使用方法：直接Ctrl+F全部代替,用自己的类代替Person类就行了

/**
 * 解释xml文件的通用类 对xml文件的格式要求：所有属性均是小写 对实体类的要求：所有属性必须为小写
 *
 * @author Administrator
 *
 */
public class ParsePeron
{
   
    private Person                 currentPerson = null; // ////////////////
    // 需要修改object的类型，以跟XML里面的内容相符//////////////
    private List                   personsList   = null;
    private DocumentBuilderFactory dbf           = null;
    private DocumentBuilder        docBuilder    = null;
    private Document               document      = null;
   
    public ParsePeron(InputStream is)
    {
        this.currentPerson = new Person(); // /////// 这里也需要修改///////////
        personsList = new ArrayList();
        try
        {
            dbf = DocumentBuilderFactory.newInstance();
            docBuilder = dbf.newDocumentBuilder();
            document = docBuilder.parse(is);
        }
        catch (IOException e)
        {
            System.out.println("IO错误！");
            e.printStackTrace();
        }
        catch (SAXException e)
        {
            System.out.println("simple api for xml错误！");
            e.printStackTrace();
        }
        catch (ParserConfigurationException e)
        {
            System.out.println("xml解释配置错误！");
            e.printStackTrace();
        }
    }
   
    public ParsePeron(File file)
    {
        this.currentPerson = new Person(); // ////// 这里也需要修改/////////////
        personsList = new ArrayList();
        Document document = null;
        try
        {
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            DocumentBuilder docBuilder = dbf.newDocumentBuilder();
            document = docBuilder.parse(file);
        }
        catch (IOException e)
        {
            System.out.println("IO错误！");
            e.printStackTrace();
        }
        catch (SAXException e)
        {
            System.out.println("simple api for xml错误！");
            e.printStackTrace();
        }
        catch (ParserConfigurationException e)
        {
            System.out.println("xml解释配置错误！");
            e.printStackTrace();
        }
    }
   
    public List getPersons()
    {
        generate();
        return personsList;
    }
   
    public Person getPersonByIndex(int index)
    {
        return (Person) (getPersons().get(index)); // 保证取得的是最新的
    }
   
    private void generate()
    {
        NodeList root = document.getChildNodes(); // 根节点
        for (int i = 0; i < root.getLength(); i++)
        {
            Node persons = root.item(i); // persons节点
            NodeList personList = persons.getChildNodes(); // persons下的所有子节点
            for (int j = 0; j < personList.getLength(); j++)
            {
                Node node = personList.item(j); //
                if (node.getNodeType() == Node.ELEMENT_NODE) // 是一个元素节点，在这里也就是person节点
                {
                    try
                    {
                        currentPerson = new Person(); ////////////////这里也需要更改类型/////////////////
                        setDirectProperties(currentPerson, node);
                        setIndirectProperties(currentPerson, node);
                        personsList.add(currentPerson);
                    }
                    catch (Exception e)
                    {
                        System.out.println("不合法的类访问！");
                        e.printStackTrace();
                    }
                }
            }
        }
    }
   
    /**
     * 设置属性，属性相对xml文件中的节点来说是直接属性
     * @param person
     * 接收属性的类实例
     * @param node
     * 直接属性节点
     */
    private void setDirectProperties(Person person, Node node)
    {
        NamedNodeMap attributes = node.getAttributes(); // 这部分获得person的属性
        for (int k = 0; k < attributes.getLength(); k++)
        {
            Node attrNode = attributes.item(k);
            setProperties(person, attrNode);
        }
    }
   
    /**
     * 设置属性，属性相对xml文件中的节点来说是间接属性
     * @param person
     * 接收属性的类实例
     * @param node
     * 间接属性节点
     */
    private void setIndirectProperties(Person person, Node node)
    {
        NodeList subNodes = node.getChildNodes();// 子属性
        for (int k = 0; k < subNodes.getLength(); k++)
        {
            Node attribNode = subNodes.item(k);
            if (attribNode.getNodeType() == Node.ELEMENT_NODE)
            {
                setProperties(person, attribNode);
            }
        }
    }
   
    /**
     *  从xml文件得到数据，设置person的属性
     * @param person
     * 接收数据的Person类实例
     * @param attrNode
     * 直接或间接属性节点
     */
    private void setProperties(Person person, Node attrNode)
    {
       
        Field[] propeties = Person.class.getDeclaredFields();
        for (int i = 0; i < propeties.length; i++)
        {
            String datatypeString = propeties[i].getType().getSimpleName();
            String propertyName = propeties[i].getName();
            if (attrNode.getNodeName().equals(propertyName)) // 对照person.xml理解！！这里指id属性
            {
                Method[] methods = Person.class.getDeclaredMethods(); // //////////////这里的Person也需要改////////////////////
                for (Method method : methods)
                {
                    String methodString = method.getName();
                    if (methodString.indexOf("set") != -1 && methodString.toLowerCase().lastIndexOf(propeties[i].getName()) != -1)
                    {
                        try   //原生类型的转换
                        {
                            Object[] params = null;
                            if (datatypeString.equals("int"))
                            {
                                params = new Object[] { Integer.parseInt(attrNode.getTextContent()) };
                            }
                            if (datatypeString.equals("float"))
                            {
                                params = new Object[] { Float.parseFloat(attrNode.getTextContent()) };
                            }
                            if (datatypeString.equals("double"))
                            {
                                params = new Object[] { Double.parseDouble(attrNode.getTextContent()) };
                            }
                            if (datatypeString.equals("byte"))
                            {
                                params = new Object[] { Byte.parseByte(attrNode.getTextContent()) };
                            }
                            if (datatypeString.equals("short"))
                            {
                                params = new Object[] { Short.parseShort(attrNode.getTextContent()) };
                            }
                            if (datatypeString.equals("long"))
                            {
                                params = new Object[] { Long.parseLong(attrNode.getTextContent()) };
                            }
                            if (datatypeString.equals("char"))
                            {
                                params = new Object[] { Character.valueOf(attrNode.getTextContent().charAt(0)) };
                            }
                            if (datatypeString.equals("boolean"))
                            {
                                params = new Object[] { Boolean.valueOf(attrNode.getTextContent()) };
                            }
                            else if (datatypeString.equals("String"))
                            {
                                params = new Object[] { attrNode.getTextContent() };
                            }
                            method.invoke(person, params);
                            break;
                        }
                        catch (IllegalArgumentException e)
                        {
                            System.out.println("参数不合法！");
                            e.printStackTrace();
                        }
                        catch (IllegalAccessException e)
                        {
                            System.out.println("不合法的访问！");
                            e.printStackTrace();
                        }
                        catch (InvocationTargetException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
   
    /**
     *
     * @param node
     *            要写入数据的节点
     * @param person
     *            包含数据的类实例
     * @param directProperties
     *            包含类中属性的字符串数组，这个数组将被设置为XML节点中的直接属性
     */
    private void writeDirectProperties(Element node, Person person, String[] directProperties)
    {
        Method[] methods = person.getClass().getDeclaredMethods();
        for (int i = 0; i < directProperties.length; i++)
        {
            for (int j = 0; j < methods.length; j++)
            {
                String temp = methods[j].getName().toLowerCase();
                if (temp.indexOf("get") != -1 && temp.lastIndexOf(directProperties[i]) != -1)
                {
                    try
                    {
                        node.setAttribute(directProperties[i], methods[j].invoke(person, null).toString());
                    }
                    catch (IllegalArgumentException e)
                    {
                        e.printStackTrace();
                    }
                    catch (IllegalAccessException e)
                    {
                        e.printStackTrace();
                    }
                    catch (InvocationTargetException e)
                    {
                        e.printStackTrace();
                    }
                    break;
                }
            }
        }
    }
   
    /**
     *
     * @param node
     *            要写入数据的节点
     * @param person
     *            包含数据的类实例
     * @param directProperties
     *            包含类中属性的字符串数组，这个数组将被设置为XML节点中的间接属性
     */
    private void writeIndirectProperties(Element node, Person person, String[] indirectProperties)
    {
        Method[] methods = person.getClass().getDeclaredMethods();
        for (int i = 0; i < indirectProperties.length; i++)
        {
            for (int j = 0; j < methods.length; j++)
            {
                String temp = methods[j].getName().toLowerCase();
                if (temp.indexOf("get") != -1 && temp.lastIndexOf(indirectProperties[i]) != -1)
                {
                    try
                    {
                        Node subNode = (Node) (document.createElement(indirectProperties[i]));
                        subNode.setTextContent(methods[j].invoke(person, null).toString());
                        node.appendChild(subNode);
                    }
                    catch (IllegalArgumentException e)
                    {
                        e.printStackTrace();
                    }
                    catch (IllegalAccessException e)
                    {
                        e.printStackTrace();
                    }
                    catch (InvocationTargetException e)
                    {
                        e.printStackTrace();
                    }
                    break;
                }
            }
        }
    }
   
    /**
     *
     * @param person
     *            要往XML文件中写入数据的类实例
     * @param directProperties
     *            类实例中的直接属性
     * @param IndirectProperties
     *            类实例中的间接属性
     */
    public void writeNode(Person person, String[] directProperties, String[] indirectProperties)
    {
        Element root = (Element) document.getFirstChild();
       
        Element personElement = document.createElement(person.getClass().getSimpleName().toLowerCase());
        writeDirectProperties(personElement, person, directProperties);
        writeIndirectProperties(personElement, person, indirectProperties);
       
        root.appendChild((Node) personElement);
    }
   
    public void writerToFile(OutputStream outputStream)
    {
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer tr;
        try
        {
            tr = transformerFactory.newTransformer();
            tr.setOutputProperty(OutputKeys.INDENT, "yes");
            tr.transform(new DOMSource(document), new StreamResult(outputStream));
        }
        catch (TransformerConfigurationException e)
        {
            System.out.println("转换配置异常！");
            e.printStackTrace();
        }
        catch (TransformerException e)
        {
            System.out.println("转换异常！");
            e.printStackTrace();
        }
    }
}

 

 

 

Test.java

package aa;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.List;

public class Test
{
   
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        File file = new File("F:/person.xml");
        InputStream iStream = null;
        try
        {
            iStream = new FileInputStream(file);
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }

        ParsePeron pp = new ParsePeron(iStream);
        List persons = pp.getPersons();
        for (Object object : persons)
        {
            Person person2 = (Person)object;
            System.out.println("name: " + person2.getName() + "/nage:" + person2.getAge() + "/nid:" +  person2.getId() + "/nsex:" + person2.getSex());
            System.out.println();
        }

        String []direct ={"id"};
        String []indirect = {"name","age","sex"};
        Person person = new Person();
        person.setAge(22);
        person.setName("cxj");
        person.setId(324);
        person.setSex("男");
       
        pp.writeNode(person, direct, indirect);   
        try
        {
            pp.writerToFile(new FileOutputStream(file));
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
    }
}

 

希望对诸位有用~~