java -基于反射和XML，将XML内的数据输出-java黑洞网

本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

java战神

2668

文章

1353043

访问

+关注

分类

暂无分类

日期归档

2024-11(3)

java -基于反射和XML，将XML内的数据输出

发布于2020-11-19 20:35 阅读(583) 评论(0) 点赞(24) 收藏(1)

我们的实验目的

我们将在使用dom4j解析XML和反射的基础上，将XML文件内的数据准确，完整的输出

开始实现

建立Employee类，属性包含上面表格的列。并将上题中的表格对应的XML数据进行解析，通过反射机制在程序中创建代表3行数据的3个Employee对象
创建一个实体类Employee:

package test;

/**
 * 创建一个员工类
 */
public class Employee {
    private int id; //编号
    private String name; //姓名
    private int age;//年龄
    private String job;//岗位
    private int salay;//工资
    private int subsidies;//奖金

    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 getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public int getSalay() {
        return salay;
    }

    public void setSalay(int salay) {
        this.salay = salay;
    }

    public int getSubsidies() {
        return subsidies;
    }

    public void setSubsidies(int subsidies) {
        this.subsidies = subsidies;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", job='" + job + '\'' +
                ", salay=" + salay +
                ", subsidies=" + subsidies +
                '}';
    }

    public Employee(int id, String name, int age, String job, int salay, int subsidies) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.job = job;
        this.salay = salay;
        this.subsidies = subsidies;
    }

    public Employee() {
        super();
        // TODO Auto-generated constructor stub
    }

}

创建一个XML文件

<?xml version="1.0" encoding="UTF-8" ?>
<employees>
    <employee id="1001">
        <name>张三</name>
        <age>18</age>
        <jobs>程序员</jobs>
        <salay>30000</salay>
        <subsidies>5000</subsidies>
    </employee>
    <employee id="1002">
        <name>李四</name>
        <age>19</age>
        <jobs>讲师</jobs>
        <salay>35000</salay>
        <subsidies>2000</subsidies>
    </employee>
    <employee id="1003">
        <name>王五</name>
        <age>20</age>
        <jobs>教授</jobs>
        <salay>10000</salay>
        <subsidies>2000</subsidies>
    </employee>
</employees>

创建一个测试类：

package test;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) throws Exception {
        /**
         * 我们先解析XML文件 (使用DOM4J方式进行)
         * 1. 创建SAXReader对象
         * 2. 调用read方式
         * 3. 获取根元素
         * 4. 通过迭代器遍历直接节点
         */
        //创建容器，存储类
        ArrayList<Employee> empList = new ArrayList<Employee>();
        // 1. 创建SAXReader对象
        SAXReader reader = new SAXReader();
        //2. 调用read方法
        Document doc = reader.read(new File("src/test/emp.xml"));
        //3. 获取根节点
        Element root = doc.getRootElement();
        //	4. 通过迭代器遍历直接节点
        for(Iterator<Element> iteEmployee = root.elementIterator(); iteEmployee.hasNext();){
            //获取下一个子节点
            Element employeeEle=iteEmployee.next();
            //创建Employee类Class对象
            Class c = Employee.class;
            //获取构造方法创建Employee
            Constructor constructor = c.getDeclaredConstructor(null);
            Employee employee = (Employee) constructor.newInstance();
            //根据子节点，去遍历子节点的属性
            for(Iterator<Attribute> iteAtt = employeeEle.attributeIterator(); iteAtt.hasNext();){
                //获取子节点属性
                Attribute attribute=iteAtt.next();
                System.out.println(attribute.getName()+"\t"+attribute.getText());
            }
        }
        //通过迭代器遍历元素
        for (Iterator<Employee>iteEmployee = root.elementIterator();iteEmployee.hasNext();){
            /**
             * 创建employee对象(通过反射机制)
             */
            Class c = Class.forName("test.Employee");
            //1. 得到无参构造方法的对象
            Constructor<Employee> cons = c.getConstructor(null);
            //2. 通过无参构造方法的对象，创建employee对象
            Employee employee = cons.newInstance();
            //得到每一个节点
            Element employeeEle = (Element) iteEmployee.next();
            //使用for循环继续遍历
            for (Iterator<Element>subEmployeeEle=employeeEle.elementIterator(); subEmployeeEle.hasNext();){
                //得到每一个元素
                Element subEle = subEmployeeEle.next();
                /**
                 * 再通过反射机制去封装employee对象
                 */
                //获取节点的名称
                String nodeName = subEle.getName();
                //使用switch进行判断
                switch (nodeName) {
                    case "name":
                        employee.setName(subEle.getText());
                        break;
                    case "age":
                        employee.setAge(Integer.parseInt(subEle.getText()));
                        break;
                    case "jobs":
                        employee.setJob(subEle.getText());
                        break;
                    case "salay":
                        employee.setSalay(Integer.parseInt(subEle.getText()));
                        break;
                    case "subsidies":
                        employee.setSubsidies(Integer.parseInt(subEle.getText()));
                        break;
                }
            }
            //添加到集合内
            empList.add(employee);
        }
        //将集合遍历
        System.out.println("-------遍历集合------");
        for (Employee em:empList){
//            System.out.println(em.getName()+"\t"+em.getAge()+"\t"+em.getJob()+"\t"+em.getSalay()+"\t"+em.getSubsidies());
            System.out.println(em);
        }
    }
}

这个测试类运行结果：
在这里插入图片描述
我们需要将id也放入到集合容器内，所以，我们将上面测试类的代码进行改造
改造结果如下：

package test;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test {
    public static void main(String[] args) throws Exception {
        /**
         * 我们先解析XML文件 (使用DOM4J方式进行)
         * 1. 创建SAXReader对象
         * 2. 调用read方式
         * 3. 获取根元素
         * 4. 通过迭代器遍历直接节点
         */
        //创建容器，存储类
        ArrayList<Employee> empList = new ArrayList<Employee>();
        // 1. 创建SAXReader对象
        SAXReader reader = new SAXReader();
        //2. 调用read方法
        Document doc = reader.read(new File("src/test/emp.xml"));
        //3. 获取根节点
        Element root = doc.getRootElement();
        //	4. 通过迭代器遍历直接节点
        for(Iterator<Element> iteEmployee = root.elementIterator(); iteEmployee.hasNext();){
            //获取下一个子节点
            Element employeeEle=iteEmployee.next();
            //创建Employee类Class对象
            Class c = Employee.class;
            //获取构造方法创建Employee
            Constructor constructor = c.getDeclaredConstructor(null);
            Employee employee = (Employee) constructor.newInstance();
            //根据子节点，去遍历子节点的属性
            for(Iterator<Attribute> iteAtt = employeeEle.attributeIterator(); iteAtt.hasNext();){
                //获取子节点属性
                Attribute attribute=iteAtt.next();
                System.out.println(attribute.getName()+"\t"+attribute.getText());
                //获取添加id属性的方法
                Method method = c.getDeclaredMethod("setId", int.class);
                method.invoke(employee, Integer.parseInt(attribute.getValue()));
            }
            /**
             * 创建employee对象(通过反射机制)
             */
            Class c2 = Class.forName("test.Employee");
            //1. 得到无参构造方法的对象
            Constructor<Employee> cons = c.getConstructor(null);
            //2. 通过无参构造方法的对象，创建employee对象
            Employee employee2 = cons.newInstance();
            //使用for循环继续遍历
            for (Iterator<Element>subEmployeeEle=employeeEle.elementIterator(); subEmployeeEle.hasNext();){
                //得到每一个元素
                Element subEle = subEmployeeEle.next();
                /**
                 * 再通过反射机制去封装employee对象
                 */
                //获取节点的名称
                String nodeName = subEle.getName();
                //使用switch进行判断
                switch (nodeName) {
                    case "name":
                        employee.setName(subEle.getText());
                        break;
                    case "age":
                        employee.setAge(Integer.parseInt(subEle.getText()));
                        break;
                    case "jobs":
                        employee.setJob(subEle.getText());
                        break;
                    case "salay":
                        employee.setSalay(Integer.parseInt(subEle.getText()));
                        break;
                    case "subsidies":
                        employee.setSubsidies(Integer.parseInt(subEle.getText()));
                        break;
                }
            }
            //添加到集合内
            empList.add(employee);
        }
        //将集合遍历
        System.out.println("-------遍历集合------");
        for (Employee em:empList){
  //           System.out.println(em.getId()+"\t"+em.getName()+"\t"+em.getAge()+"\t"+em.getJob()+"\t"+em.getSalay()+"\t"+em.getSubsidies());
            System.out.println(em);
        }
    }
}