用dom4j解析xml文件，并通过反射封装到一个实体类中

￡神魔★判官ぃ 2021-11-09 17:56 267阅读 0赞

首先建立一个maven项目，在pom.xml中引入相应的dom4j的maven依赖

引入成功后，来简单了解该包提供的API  
![在这里插入图片描述][20190801165650464.png]  
下面使用上述方法来解析XML文件。

一：新建或者自己导如XML文件。作者为了方便演示，新建一个新的XML文件，如下。

<?xml version="1.0" encoding="UTF-8"?>
    
    <students>
        <student id="1">
            <name>Claire</name>
            <age>18</age>
            <gender>女</gender>
        </student>
        <student id="2">
            <name>Leafly</name>
            <age>18</age>
            <gender>男</gender>
        </student>
        <student id="3">
            <name>Dingdang</name>
            <age>18</age>
            <gender>男</gender>
        </student>
        <student id="4">
            <name>DingDing</name>
            <age>18</age>
            <gender>男</gender>
        </student>
        <student id="5">
            <name>DangDang</name>
            <age>18</age>
            <gender>女</gender>
        </student>
    
    </students>

2.将上述xml文件放到src下面。

3.创建一个Student类，其属性与上述xml中的元素一致。

public class Student {
        //private static final int AAA = 1;
        private String id;
        private String name;
        private String age;
        private String gender;
        
        
        //构造
        
        public Student() {
            
        }
        
        public Student(String id, String name, String age, String gender) {
            super();
            this.id = id;
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
        
        
    
    
    
        //getter setter
        public String getId() {
            return id;
        }
        
        public void setId(String id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getAge() {
            return age;
        }
        public void setAge(String age) {
            this.age = age;
        }
        public String getGender() {
            return gender;
        }
        public void setGender(String gender) {
            this.gender = gender;
        }
    
    
        
        
        //toString
        @Override
        public String toString() {
            return "Student [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + "]";
        }
    }

4.创建新类ReadXMl,在该类中创建方法来解析XML文件。

private static void readXmlFun() throws DocumentException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
            
            
            //1.反射，得到类的引用
            Class student = Class.forName("readXmlAndReflect.Student");
            //通过类的引用，得到类的对象
            Object stuInstance = student.newInstance();
            //创建一个list 来放多个student的对象
            List<Student> students = new ArrayList<Student>();
            
            SAXReader reader = new SAXReader();
            //将XML文件读取为一份document对象
            Document document = reader.read(readXmlFun.class.getResourceAsStream("/StudentDate.xml"));
            //利用Document类中的方法，获取根节点.返回的是Element
            Element rootElement = document.getRootElement();
            
            //利用Element中的方法，获取根节点下的全部子节点.返回一个List<element>
            List<Element> elements = rootElement.elements();
            
            //利用Element中的方法，获取子 节点中的属性（StudentData中的属性为id）
            //1.遍历list,获得每个元素
            for (Element element : elements) {
                System.out.println("---------------------------------");
                //遍历并得到每个元素标签中某个属性名称的属性值
                String stuId = element.attributeValue("id");
                System.out.println("学生id为"+ stuId);
                //遍历并获得每个元素的全部子节点，返回一个List<element>
                List<Element> subElement = element.elements();
                
            
                //通过方法名反射出方法对象
                Method method2 = student.getDeclaredMethod("setId", String.class);
                //通过反射调用方法，stuInstance对象调用method，参数为stuData---相当于给各参数赋值
                method2.invoke(stuInstance, stuId);
                
                for (Element subElementData : subElement) {
                    //得到每个子节点的名字
                    String elementName = subElementData.getName();
                    //遍历并获得每个子元素的文本内容,如得到name子节点的文本值为Claire
                    String stuData = subElementData.getStringValue();
                    System.out.println(elementName +"为" + stuData);
                    
                    
                    //通过elemetname得到对应的get set方法，先拼接出方法名，比如 name就要拼接成setName
                    String funName = "set" + (elementName.charAt(0)+"").toUpperCase()+elementName.substring(1);
                
                    //通过方法名反射出方法对象
                    Method method1 = student.getDeclaredMethod(funName, String.class);
                    //通过反射调用方法，调用stuInstance对象的method方法，参数为stuData---给各属性赋值
                    method1.invoke(stuInstance, stuData);
                }
                //将每个学生对象添加到list列表中
                students.add((Student)stuInstance);
                System.out.println(students);
            
            }
        }

这里解释下，上面使用的

Document document = reader.read(readXmlFun.class.getResourceAsStream("/StudentDate.xml"));

前面加上/------------代表在当前类的src下面找

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjQxOTU3_size_16_color_FFFFFF_t_70]  
如果没有/--------------代表在跟类同级的目录下找。

可以看到上面使用了反射。利用反射可以动态的为每一个Student对象赋值。当我们的XML文件改变，添加或删除了新的属性之后，完全不需要去修改我们的ReadXML类，只在Student类中添加或删除对应的属性即可。实现了解耦。

### 我们经常通过反射来做下面的事情： ###

**1.获取到某各类的引用**  
通常有3种方式：

1.  Class clazz = Class.forName（" 这里必须是类全名"）;
2.  我们每一个类都有一个静态的class属性：Class clazz =类名A.Class（这个与第一种方式的区别是，不会去运行类A中的静态代码块）；
3.  每个类都有一个getClass（）方法： classA a = new ClassA(); Class clazz =a.getClass();

**2.通过该类的引用获取类的对象**

object o = clazz.newInstance();

**3.通过该类的引用获取属性**

**4.通过该类的引用获取所有方法（包括普通方法和构造方法）**

下面代码详细说明了反射机制中常用的方法，有兴趣可以了解下：

package readXmlAndReflect;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.sql.Types;
    
    public class Reflect {
        public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
            Class clazz = Class.forName("readXmlAndReflect.Student");
            //创建对象
            Object o =clazz.newInstance();
            
            
            //创建一个stringBuffer
            StringBuffer buffer = new StringBuffer();
            
            //类 public class readXmlAndReflect.Student{}
            buffer.append("\n"+"-------------class-------------------"+"\n");
      
     //下面的Modifier.toString(clazz.getModifiers()) 是得到这个class的访问权限是哪个，比如public，protected，private，具体情况可以自行百度
            buffer.append(Modifier.toString(clazz.getModifiers()) + " class " + clazz.getName()+"{"+"\n");
            
            //域
            buffer.append("\n"+"-------------field-------------------"+"\n");
            //获取所有声明的属性，包括私有和常量
            Field[] fields = clazz.getDeclaredFields();
            //遍历所有的属性
            for (Field field : fields) {
                //获取属性的修饰符 如public static 
                buffer.append("\t" + Modifier.toString(field.getModifiers()));
                //获取属性的类型 如 string int getType()获取到的类全名（如java.lang.String),想要获得简单类型名如String，可以使用Class类中getSimpleName()方法
                buffer.append("\t" + field.getType().getSimpleName());
                //获取属性名称
                buffer.append("\t" + field.getName());
                buffer.append(";"+"\n");
                
                //得到域之后有什么用呢？
                //我们可以直接使用得到的域给其赋值或读取域的值,由于域都是私有的，这里需要利用反射打破类的封装
                field.setAccessible(true);//如果没有这一句，运行时会报错java.lang.IllegalAccessException:
                //给对象0的域field 赋值为"3"
                field.set(o, "3");
                //获取 对象o 的 域field 的值
                System.out.println(field.get(o));
                
            }
            
            
            
        
            
            //方法 如 public static string function（）{}
            buffer.append("\n"+"-------------function-------------------"+"\n");
            //获得所有声明的方法，包括private
            Method[] motheds = clazz.getDeclaredMethods();
            
            for (Method method : motheds) {
                //获得方法的修饰符 如 public static 
                buffer.append("\t"+Modifier.toString(method.getModifiers()) + " ");
                //获得方法的返回值类型
                buffer.append(method.getReturnType().getSimpleName()+" ");
                //获得方法名
                buffer.append(method.getName() + "(");
                //获得方法的参数类型，可能有多个参数，所以返回值为一个数组
                Class[] parameterTypes = method.getParameterTypes();
                //遍历方法的参数类型
                for (Class parameterType : parameterTypes) {
                    //遍历获得每一个参数类型
                    buffer.append(parameterType.getSimpleName()+", ");
                }
                buffer.append(") { }"+"\n");
                
            }
            
            
            //获得方法有什么用？？通常用来调用方法
            //1.先通过方法名来获得一个方法
            Method setNameFun = clazz.getMethod("setName", String.class);
            //可以直接调用，调用方法method---调用o对象的setNameFun方法，参数为“小笨蛋”
            setNameFun.invoke(o, "小笨蛋");
            
            
            //构造方法
            buffer.append("\n" + "-------------constructions-------------------"+"\n");
            Constructor[] constructors = clazz.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                
                buffer.append(Modifier.toString(constructor.getModifiers()) + " ");
                buffer.append(constructor.getName() + " (");
                Class[] parametertypes = constructor.getParameterTypes();
                for (Class parametertype : parametertypes) {
                    buffer.append(parametertype.getSimpleName() +",");
                }
                buffer.append(") { }"+"\n");
            }
            
            buffer.append("}");
            
            System.out.println(buffer);
        }
    
    }

本文转载自：[https://www.cnblogs.com/baiqiantao/p/7478523.html][https_www.cnblogs.com_baiqiantao_p_7478523.html]

[20190801165650464.png]: /images/20211109/e8be0c022b1045f290dbbe209984a74e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMjQxOTU3_size_16_color_FFFFFF_t_70]: /images/20211109/129f03bc75724129a57f15f94e0bb835.png
[https_www.cnblogs.com_baiqiantao_p_7478523.html]: https://www.cnblogs.com/baiqiantao/p/7478523.html