精华内容
下载资源
问答
  • dom4j解析xml文件的压缩包,完整版。对jdom进行了封装。包含源码,jar包以及所需的全部内容。
  • 使用dom4jxml文件中的数据导入到数据库中,包含xml文件和连接数据库文件,能够运行。 (1)用eclipse创建一个简单的java project (2)导入所需要的包 (3)编写DBUtil.java 连接数据库 (4)编写xml文件 ...
  • 本篇文章主要介绍了java中利用Dom4j解析和生成XML文档dom4j是一套非常优秀的Java开源api,主要用于读写xml文档,具有性能优异、功能强大、和非常方便使用的特点。有兴趣的可以了解一下。
  • dom4j解析xml和soap报文

    2017-09-14 17:48:27
    通过dom4j解析xml文件或xml字符串,同时利用dom4j解析soap报文,解析出所需要的字段,使用的相对比较基础,有需要的可以参考一下。
  • java中采用dom4j解析xml文件

    万次阅读 2019-05-22 11:18:55
    但是从来的没有应用过来,所以可以在google中搜索dmo4j解析xml文件的方式,学习一下dom4j解析xml的具体操作。 二.代码详情 dom4j是一个第三方开发组开发出的插件,所以在我们使用dom4jf的时候我们要去下载一下dom...

    一.前言

       在最近的开发中用到了dom4j来解析xml文件,以前听说过来解析xml文件的几种标准方式;但是从来的没有应用过来,所以可以在google中搜索dmo4j解析xml文件的方式,学习一下dom4j解析xml的具体操作。

    二.代码详情

       dom4j是一个第三方开发组开发出的插件,所以在我们使用dom4jf的时候我们要去下载一下dom4j对应版本的jar导入在我们项目中。

     1)xml文件:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    <?xml version="1.0" encoding="UTF-8"?>

    <books>

       <book id="001">

          <title>Harry Potter</title>

          <author>J K. Rowling</author>

       </book>

       <book id="002">

          <title>Learning XML</title>

          <author>Erik T. Ray</author>

       </book>

    </books>

    示例一:用List列表的方式来解析xml

    SAXReader就是一个管道,用一个流的方式,把xml文件读出来

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    import java.io.File;

    import java.util.List;

      

    import org.dom4j.Attribute;

    import org.dom4j.Document;

    import org.dom4j.Element;

    import org.dom4j.io.SAXReader;

      

      

      

    public class Demo {

      

        public static void main(String[] args) throws Exception {

            SAXReader reader = new SAXReader();

            File file = new File("books.xml");

            Document document = reader.read(file);

            Element root = document.getRootElement();

            List<Element> childElements = root.elements();

            for (Element child : childElements) {

                //未知属性名情况下

                /*List<Attribute> attributeList = child.attributes();

                for (Attribute attr : attributeList) {

                    System.out.println(attr.getName() + ": " + attr.getValue());

                }*/

                  

                //已知属性名情况下

                System.out.println("id: " + child.attributeValue("id"));

                  

                //未知子元素名情况下

                /*List<Element> elementList = child.elements();

                for (Element ele : elementList) {

                    System.out.println(ele.getName() + ": " + ele.getText());

                }

                System.out.println();*/

                  

                //已知子元素名的情况下

                System.out.println("title" + child.elementText("title"));

                System.out.println("author" + child.elementText("author"));

                //这行是为了格式化美观而存在

                System.out.println();

            }

        }

      

    }

    示例二:使用Iterator迭代器的方式来解析xml

     

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    import java.io.File;

    import java.util.Iterator;

      

    import org.dom4j.Attribute;

    import org.dom4j.Document;

    import org.dom4j.Element;

    import org.dom4j.io.SAXReader;

      

      

      

    public class Demo {

        public static void main(String[] args) throws Exception {

            SAXReader reader = new SAXReader();

            Document document = reader.read(new File("books.xml"));

            Element root = document.getRootElement();

              

            Iterator it = root.elementIterator();

            while (it.hasNext()) {

                Element element = (Element) it.next();

                  

                //未知属性名称情况下

                /*Iterator attrIt = element.attributeIterator();

                while (attrIt.hasNext()) {

                    Attribute a  = (Attribute) attrIt.next();

                    System.out.println(a.getValue());

                }*/

                  

                //已知属性名称情况下

                System.out.println("id: " + element.attributeValue("id"));

                  

                //未知元素名情况下

                /*Iterator eleIt = element.elementIterator();

                while (eleIt.hasNext()) {

                    Element e = (Element) eleIt.next();

                    System.out.println(e.getName() + ": " + e.getText());

                }

                System.out.println();*/

                  

                //已知元素名情况下

                System.out.println("title: " + element.elementText("title"));

                System.out.println("author: " + element.elementText("author"));

                System.out.println();

            }

        }

    }

    运行结果:

     示例三:创建xml文档并输出到文件

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    import java.io.File;

    import java.io.FileOutputStream;

      

    import org.dom4j.Document;

    import org.dom4j.DocumentHelper;

    import org.dom4j.Element;

    import org.dom4j.io.OutputFormat;

    import org.dom4j.io.XMLWriter;

      

      

    public class Demo {

        public static void main(String[] args) throws Exception {

            Document doc = DocumentHelper.createDocument();

            //增加根节点

            Element books = doc.addElement("books");

            //增加子元素

            Element book1 = books.addElement("book");

            Element title1 = book1.addElement("title");

            Element author1 = book1.addElement("author");

              

            Element book2 = books.addElement("book");

            Element title2 = book2.addElement("title");

            Element author2 = book2.addElement("author");

              

            //为子节点添加属性

            book1.addAttribute("id", "001");

            //为元素添加内容

            title1.setText("Harry Potter");

            author1.setText("J K. Rowling");

              

            book2.addAttribute("id", "002");

            title2.setText("Learning XML");

            author2.setText("Erik T. Ray");

              

            //实例化输出格式对象

            OutputFormat format = OutputFormat.createPrettyPrint();

            //设置输出编码

            format.setEncoding("UTF-8");

            //创建需要写入的File对象

            File file = new File("D:" + File.separator + "books.xml");

            //生成XMLWriter对象,构造函数中的参数为需要输出的文件流和格式

            XMLWriter writer = new XMLWriter(new FileOutputStream(file), format);

            //开始写入,write方法中包含上面创建的Document对象

            writer.write(doc);

        }

    }

    运行结果:

     

    展开全文
  • NULL 博文链接:https://javastudyeye.iteye.com/blog/794787
  • DOM4J具有性能优异、功能强大和极端易用使用的特点,只要懂得DOM基本概念,就可以通过dom4j的api文档解析xml,dom4j是一套开源的api。实际项目中,往往选择dom4j来作为解析xml的利器
  • 在xml中存储了过滤器的的初始化参数,需要解析xml文件,拿到初始化参数,过滤器配置文件web.xml文件如下: <?xml version="1.0"?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web ...

    1.需求分析

    关于dom4j的详细使用方法请参考:https://blog.csdn.net/qq_41860497/article/details/84339091

    • 在xml中存储了过滤器的的初始化参数,需要解析该xml文件,拿到初始化参数,过滤器配置文件web.xml文件如下:
    <?xml version="1.0"?>
    <!DOCTYPE web-app PUBLIC
     "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
     "http://java.sun.com/dtd/web-app_2_3.dtd" >
    <web-app>
    	<!--权限过滤器-->
        <filter>
            <filter-name>SecurityFilter</filter-name>
            <filter-class>com.szz.security.SecurityFilter</filter-class>
            <init-param>
                <param-name>SecurityConfigLocation</param-name>
                <param-value>/security.xml</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>SecurityFilter</filter-name>
            <url-pattern>/*</url-pattern>   <!--对所有资源做过滤-->
        </filter-mapping>
    </web-app>
    
    • 可以看到过滤器的初始化参数在security.xml中,而<param-value>/security.xml</param-value>这段代码加/代表在resource根目录下。待解析的security.xml文件如下所示:
    <?xml version="1.0" encoding="UTF-8"?>
    <beans>
        <!--授权列表-->
        <security pattern="/pages/index.html"
                  has_role="ROLE_ADMIN,ROLE_QUESTION_RECORDER"/>
        <security pattern="/pages/questionBasicList.html"
                  has_role="ROLE_ADMIN,ROLE_QUESTION_RECORDER"/>
        <security pattern="/pages/questionClassicList.html" has_role="ROLE_ADMIN"/>
        <security pattern="/pages/userList.html" has_role="ROLE_ADMIN"/>
    </beans>
    
    • 现在要做的就是将patternhas_role对应的内容读取出来。

    2.步骤分析与代码实现

    根据1中描述,可将实现步骤分解为:

    1. 读取过滤器初始化参数,即读取待xml文件的路径/security.xml
    2. 根据路径,利用dom4j解析xml文档

    Java实现代码如下所示:

    import lombok.extern.slf4j.Slf4j;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.Node;
    import org.dom4j.io.SAXReader;
    
    import javax.servlet.*;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    
    /**
     * @author: szz
     * @date: Created in 2021/1/6
     * @description: 权限过滤器
     * @version: 1.0
     */
    
    @Slf4j
    public class SecurityFilter implements Filter {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            // 初始化配置
            log.debug("SecurityFilter init...");
            // 读取过滤器初始化参数
            String filePath = filterConfig.getInitParameter("SecurityConfigLocation");
            // 初始化工作,解析xml,提取资源映射关系
            parseSecurityXML(filePath);
    
        }
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
            // 过滤
            log.debug("SecurityFilter doFilter...");
            HttpServletRequest request1 = (HttpServletRequest) request;
            HttpServletResponse response1 = (HttpServletResponse) response;
    
            // 允许通过,继续执行
            chain.doFilter(request1,response1);
    
        }
    
        @Override
        public void destroy() {
            log.debug("SecurityFilter destroy...");
            // 释放资源
        }
    
        // 解析xml文件
        private void parseSecurityXML(String filePath){
            log.debug("SecurityFilter init...解析XML...");
            // xml解析
            try{
                // 加载XML文件输入流
                InputStream resourceAsStream = this.getClass().getResourceAsStream(filePath);// 必须是
                // 构建document对象
                SAXReader saxReader = new SAXReader();
                Document document = saxReader.read(resourceAsStream);
                // 利用XPath表达式搜索Node,通过Node获取元素Element
                // 获取页面中所有的Security节点
                // "//"表示选择后代元素,即不管层次结构, "security"表示标签名称
                List<Node> listNodes = document.selectNodes("//"+ "security");
                // 遍历节点
                for(Node node : listNodes){
                    Element element = (Element) node;
                    // 获取元素的属性和值
                    String accessRole = element.attribute(SecurityConst.TAG_SECURITY_ATTR_HAS_ROLE).getStringValue();
                    String accessPath = element.attribute(SecurityConst.TAG_SECURITY_ATTR_PATTERN).getStringValue();
                    log.debug("accessRole:{}",accessRole);
                    log.debug("accessPath:{}",accessPath);
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    
    
    • 执行结果如下图所示:
      在这里插入图片描述
    展开全文
  • XPath是一门在XML文档中查找信息的语言,下面介绍一下java使用xpath和dom4j解析xml的示例,大家参考使用吧
  • 采用DOMDOM4j两种方式针对XML文档进行增、删、改查的操作,转换方式在Test测试类中实现另一个管理类就可以了!
  • 利用dom4j--读取xml文件

    2016-07-29 11:29:23
    利用dom4j--读取xml文件。 代码简洁易懂。
  • NULL 博文链接:https://even2012.iteye.com/blog/1832068
  • 在最近的开发中用到了dom4j来解析xml文件,所以便有了这篇文章,本文主要给大家介绍了关于java中使用dom4j解析XML文件的方法教程,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
  • 首先建立一个maven项目,在pom.xml中引入相应的dom4j的maven依赖 <dependency> <groupId>org.dom4j</groupId> <artifactId>dom4j</artifactId> <version>2.0.1</version&...

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

    <dependency>
          <groupId>org.dom4j</groupId>
          <artifactId>dom4j</artifactId>
          <version>2.0.1</version>
        </dependency>
    

    引入成功后,来简单了解该包提供的API
    在这里插入图片描述
    下面使用上述方法来解析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下面找

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

    可以看到上面使用了反射。利用反射可以动态的为每一个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

    展开全文
  • 主要介绍了java dom4j解析xml文件的方法,分享给大家参考
  • 完整的讲解一个dom4jxml的增删改查
  • 本文主要介绍了java使用dom4j读取配置文件实现抽象工厂和反射的示例,在Java中也可以同Donet一样,将差异配置在配置文件里面。另外,我们采用下面的方式实现,将会更加便捷
  • 今天小编就为大家分享一篇用dom4j生成xml,去掉xml头的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • DOM4J 读取xml字符串

    2019-03-19 01:59:06
    NULL 博文链接:https://navylee.iteye.com/blog/727103
  • 首先建项目这些基础过程就省略了 这里用的是springboot搭建的项目 在pom.xml里面添加所需依赖 &lt;!-- ...dom4j&lt;/groupId&gt; &lt;artifactId&gt;do...

    首先建项目这些基础过程就省略了
    这里用的是springboot搭建的项目
    在pom.xml里面添加所需依赖

    <!-- https://mvnrepository.com/artifact/dom4j/dom4j -->
    		<dependency>
    			<groupId>dom4j</groupId>
    			<artifactId>dom4j</artifactId>
    			<version>1.6.1</version>
    		</dependency>
    

    先看一下我们的xml文件是什么结构的,可以清楚的看出来根节点port,子节点dti,以及孙子节点dti,接下来就根据这个xml建数据库表【四个字段,名字随意了】

    <?xml version="1.0" encoding="UTF-8"?>
    <report generated_time="Thu Nov 15 11:40:33 2018">
    	<dti type="company" inst="0" desc="用户0" op="op_new">
    		<dti name="名称">nan有限公司</dti>
    		<dti name="地址">nan市</dti>
    		<dti name="电话">111111</dti>
    		<dti name="上级公司">aaa集团</dti>
    	</dti>
    	
    	<dti type="company" inst="1" desc="用户1" op="op_new">
    		<dti name="名称">wu供电公司</dti>
    		<dti name="地址">wu市</dti>
    		<dti name="电话">22222</dti>
    		<dti name="上级公司">xxx有限公司</dti>
    	</dti>
    </report>
    

    建表:
    在这里插入图片描述然后建实体类pojo:
    这里我建的实体类没有写get/set方法是因为我用了lombok这个插件,可以在idea里的plugins里搜索lombok,以后建实体类就不需要get/set方法了,一个注解就搞定。当然不熟悉的还是可以继续使用,快捷键生成get/set也花不了多久时间:

    pojo

    DemoEntity.java
    package com.example.demo.pojo;
    
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class DemoEntity {
    
        private String company;
        private String address;
        private String phone;
        private String parent_company;
    }
    

    model类

    DemoModel.java
    package com.example.demo.model;
    import com.example.demo.pojo.DemoEntity;
    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Select;
    import org.springframework.stereotype.Repository;
    import java.util.List;
    @Repository
    public interface DemoModel {
      // @Insert("insert into demo values(#{name},{address},#{phone},#{parent_company})")
         int addJsAsset(List<DemoEntity> list);
    }
    
    

    service类

    DemoService

    这里可以把new File括号里面的具体文件路径改为传的参数xmlFile

    package com.example.demo.service;
    
    
    import com.example.demo.model.DemoModel;
    import com.example.demo.pojo.DemoEntity;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.io.File;
    import java.util.ArrayList;
    import java.util.Iterator;
    
    @Service
    public class DemoService {
        @Autowired
        private DemoModel demoModel;
    
        public int addDemo(String XmlFile) {
            ArrayList<DemoEntity> list = new ArrayList<DemoEntity>();
            try {
                SAXReader reader = new SAXReader();//创建一个读取XML文件的对象
                Document document = reader.read(new File("/Users/Desktop/user.xml"));
                Element root = document.getRootElement();//获取根节点
                for (Iterator<Element> reRoot = root.elementIterator(); reRoot.hasNext(); ) {
                    Element childElement = reRoot.next();//获取子节点
                    DemoEntity demoEntity = new DemoEntity();
                    for (Iterator<Element> reChildElement = childElement.elementIterator(); reChildElement.hasNext(); ) {
                        Element dom = reChildElement.next();//获取子节点的下一节点
                        switch (dom.attribute("name").getValue()) { //匹配,当标签里的name与case后的字符串匹配执行相应的数据插入
                            case "名称":
                                demoEntity.setName(dom.getText());
                                break;
                            case "地址":
                                demoEntity.setAddress(dom.getText());
                                break;
                            case "电话":
                                demoEntity.setPhone(dom.getText());
                                break;
                            case "上级公司":
                                demoEntity.setParent_company(dom.getText());
                                break;
                        }
                    }
                    list.add(demoEntity);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
            }
            return  demoModel.addJsAsset(list);//将读取出的数据插入数据库
        }
    
    }
    
    

    Impl

    DemoServiceImpl

    里面的path是我们待会测试要用的,这里是/addDemo

    package com.example.demo.service.impl;
    
    import com.example.demo.pojo.DemoEntity;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    
    public interface DemoServiceImpl {
    
        @RequestMapping(path = "/addDemo", method = RequestMethod.POST)
        public int addDemo(@RequestBody DemoEntity demoEntity);
    
    }
    
    

    controller

    DemoController
    package com.example.demo.controller;
    
    
    import com.example.demo.pojo.DemoEntity;
    import com.example.demo.service.DemoService;
    import com.example.demo.service.impl.DemoServiceImpl;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class DemoController implements DemoServiceImpl{
    
        @Autowired
        private DemoService demoService;
    
        @Override
        public int addDemo(DemoEntity demoEntity) {
            return demoService.addDemo(demoEntity.toString());
        }
    }
    
    

    mapper.xml

    demoMapper.xml

    说明一下这里的mapper文件可以没有,如果在model里面用了注解@insert,我这里把demoModel.java类里面的那句注释掉了,两种都一样

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    <mapper namespace="com.example.demo.model.DemoModel">
        <insert id="addJsAsset" parameterType="com.example.demo.pojo.DemoEntity">
            INSERT into `demo`
            (`name`, `address`, `phone`, `parent_company`)
            VALUES
            <foreach collection="list" item="demo" separator=",">
                (#{demo.name},
                #{demo.address},
                #{demo.phone},
                #{demo.parent_company})
            </foreach>
        </insert>
    
    </mapper>
    

    application.yml

    这里面是配置的端口号和数据库连接信息

    server:
      port: 8015
    spring:
      application:
        name: demo
      datasource:
        url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=utf8
        username: root
        password: 123456
    
    

    最后运行然后测试一下,这里使用了postman,看看效果图,图中标出来的地方分别是需要注意的,具体使用这里不赘述了,简单说就是根据你的代码,里面使用了get还是post方法就选择什么,然后地址栏就是你的端口号加你的方法,下面测试的两条数据是你数据库里的字段根据它的类型随便写两个就行,返回值是int ,所以可以看到最下面是数字2,表示有两条数据插入数据库里了。
    在这里插入图片描述然后看看数据库插入情况:
    插入前:在这里插入图片描述运行代码插入后:在这里插入图片描述到这里dom4j解析xml文件并把数据插入数据库就已经完成了,还可以自行添加一些删除修改查看所有等功能。

    展开全文
  • 使用DOM4J解析XML文件

    千次阅读 2018-05-30 23:27:12
    DOM解析器在解析XML文档时,会把文档中的所有元素,按照其出现的层次关系,解析成一个个Node对象(节点)。 DOM结构把整个xml文档加载到计算机内存中,此时的内存中存放的xml文档是一个树状结构 在DOM中,节点之间...
  • 使用DOM4J解析XML的大致步骤 1:创建SAXReader 2:使用SAXReader读取XML文档并生成Document对象 Document对象内部就保存了XML文档描述的整棵树结构 3:通过Document获取根元素 4:从根元素开始逐级获取子元素已达到遍历...
  • 使用DOM4j解析XML文件

    2011-12-17 16:36:00
    使用DOM4j技术快速解析XML文件,提高开发效率
  • DOM4j解析xml文件

    2017-11-30 17:21:20
    对于DOM4j的浅显的感知:解析xml文件,在对于子节点中有子节点的情况,则要提前知道该节点的名称 dom4j将返回对象封装成 list 对象 或者 迭代的对象,方便获取相关的值
  • dom4j解析XML文档.ppt

    2021-11-20 18:24:24
    dom4j解析XML文档.ppt
  • Java利用dom4j解析XML任意节点和属性

    千次阅读 2020-03-22 15:59:25
    分享一个Java解析XML字符串的方法,利用了dom4j,递归。可解析任意节点及节点属性值。 package test; import java.io.IOException; import java.io.StringWriter; import java.util.HashMap; import java.util....
  • dom4j解析xml

    2017-06-28 18:10:53
    使用dom4jxml文档进行增删改. 查询就不用说了,使用elements(....)/element(...)/attributeValue()/getText()等方法
  • 自己写的一个dom4j解析xml文件工具类
  • NULL 博文链接:https://lancijk.iteye.com/blog/972592

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,731
精华内容 17,892
关键字:

dom4j解析xml文件