dom4j操作xml基础--Visitor访问模式解析XML

最新推荐文章于 2022-02-25 18:19:43 发布
最新推荐文章于 2022-02-25 18:19:43 发布
阅读量183 收藏
点赞数
分类专栏： J2SE 文章标签： XML Gmail C# C C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ab654321ab/article/details/83426572
版权

http://www.blogjava.net/bulktree/archive/2008/08/10/221122.html

 

[IT科技]dom4j操作xml基础--Visitor访问模式解析XML

旧一篇: Thinking XML: Firefox 3.0 和 XML  新一篇: JSON辅助类，可以把一些对象和集合转化为标准的JSON格式 

http://www.blogjava.net/bulktree/archive/2008/08/10/221122.html

dom4j遍历xml文档树有种很特别的方式就是访问者(Visitor)模式,初次接触Visitor模式，写出个人理解大家交流！
Visitor访问者模式定义：作用于某个对象树中各个对象的操作. 它可以使你在不改变这些对象树本身的情况下,定义作用于这些对象树各个节点的新操作。
先看以下代码：Person为简单的vo类
查看 复制到剪切板 打印
  1. package org.bulktree.visitor;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.Collection;   
  5. import java.util.Iterator;   
  6. import java.util.List;   
  7.   
  8. /**  
  9.  *   
  10.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  11.  * @date Aug 10, 2008  
  12.  */  
  13. public class ReadCollection {   
  14.   
  15.     private Collection c = null;   
  16.   
  17.     ReadCollection() {   
  18.   
  19.         /*  
  20.          * 准备数据-String对象-Person对象-Integer对象-List对象  
  21.          */  
  22.         String str = "bulktree.laoshulin";   
  23.         Person person = new Person("bulktree", "22", "M");   
  24.         Integer a = new Integer(99);   
  25.         /*  
  26.          * 使用范型  
  27.          */  
  28.         List<String> list = new ArrayList<String>();   
  29.         list.add("BULKTREE");   
  30.         list.add("LAOSHULIN");   
  31.         list.add("OAKERTREE");   
  32.   
  33.         c = new ArrayList();   
  34.         c.add(str);   
  35.         c.add(person);   
  36.         c.add(a);   
  37.         c.add(list);   
  38.   
  39.     }   
  40.   
  41.     /**  
  42.      * 遍历Collection中的每一个对象并打印  
  43.      */  
  44.     public void testCollection() {   
  45.         Iterator iter = getCollection().iterator();   
  46.   
  47.         while (iter.hasNext()) {   
  48.             Object o = iter.next();   
  49.   
  50.             if (o instanceof String) {   
  51.                 System.out.println("String-->  " + o.toString());   
  52.             } else if (o instanceof Person) {   
  53.                 readPerson((Person) o);   
  54.             } else if (o instanceof Integer) {   
  55.                 Integer inta = (Integer) o;   
  56.                 System.out.println(inta.intValue());   
  57.             } else if (o instanceof List) {   
  58.                 readList((List) o);   
  59.             }   
  60.         }   
  61.   
  62.     }   
  63.   
  64.     public Collection getCollection() {   
  65.         return c;   
  66.     }   
  67.   
  68.     private void readPerson(Person person) {   
  69.         System.out.println("person-name-> " + person.getName());   
  70.         System.out.println("person-age-> " + person.getAge());   
  71.         System.out.println("person-sex-> " + person.getSex());   
  72.     }   
  73.   
  74.     private void readList(List<String> list) {   
  75.         /*  
  76.          * 增强的for循环  
  77.          */  
  78.         for (String s : list) {   
  79.             System.out.println(s);   
  80.         }   
  81.     }   
  82.   
  83.     public static void main(String[] args) {   
  84.         new ReadCollection().testCollection();   
  85.     }   
  86. }  
package org.bulktree.visitor;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/**
 * 
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public class ReadCollection {

    private Collection c = null;

    ReadCollection() {

        /*
         * 准备数据-String对象-Person对象-Integer对象-List对象
         */
        String str = "bulktree.laoshulin";
        Person person = new Person("bulktree", "22", "M");
        Integer a = new Integer(99);
        /*
         * 使用范型
         */
        List<String> list = new ArrayList<String>();
        list.add("BULKTREE");
        list.add("LAOSHULIN");
        list.add("OAKERTREE");

        c = new ArrayList();
        c.add(str);
        c.add(person);
        c.add(a);
        c.add(list);

    }

    /**
     * 遍历Collection中的每一个对象并打印
     */
    public void testCollection() {
        Iterator iter = getCollection().iterator();

        while (iter.hasNext()) {
            Object o = iter.next();

            if (o instanceof String) {
                System.out.println("String-->  " + o.toString());
            } else if (o instanceof Person) {
                readPerson((Person) o);
            } else if (o instanceof Integer) {
                Integer inta = (Integer) o;
                System.out.println(inta.intValue());
            } else if (o instanceof List) {
                readList((List) o);
            }
        }

    }

    public Collection getCollection() {
        return c;
    }

    private void readPerson(Person person) {
        System.out.println("person-name-> " + person.getName());
        System.out.println("person-age-> " + person.getAge());
        System.out.println("person-sex-> " + person.getSex());
    }

    private void readList(List<String> list) {
        /*
         * 增强的for循环
         */
        for (String s : list) {
            System.out.println(s);
        }
    }

    public static void main(String[] args) {
        new ReadCollection().testCollection();
    }
}


我们使用了 instanceof来判断 Object对象 o 的类型，这样做的缺点是代码中If/else if 很繁琐，而JDK中的范型又限制了只能使用相同的类型，这时Vistor访问模式派上用场了。

当我们要访问Collection的每一个Element(被访问者)时，定义一个accept操作使其具有可被访问性，我们定义一个Visiable接口，使Collection的每一个Element继承这个接口，实现自身的访问操作

package org.bulktree.visitor;

查看 复制到剪切板 打印
  1. /**  
  2.  * 可访问性--接收一个访问者  
  3.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  4.  * @date Aug 10, 2008  
  5.  */  
  6. public interface Visitable {   
  7.     public void accept(Visitor visitor);   
  8. }  
/**
 * 可访问性--接收一个访问者
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public interface Visitable {
    public void accept(Visitor visitor);
}


下来是四个被访问的类型String,Integer,Person,Collection的实现类
查看 复制到剪切板 打印
  1. package org.bulktree.visitor;   
  2.   
  3. /**  
  4.  * 被访问者--String对象  
  5.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  6.  * @date Aug 10, 2008  
  7.  */  
  8. public class StringElement implements Visitable {   
  9.   
  10.     private String str;   
  11.   
  12.     public StringElement(String str) {   
  13.         this.str = str;   
  14.     }   
  15.   
  16.     public String getStr() {   
  17.         return str;   
  18.     }   
  19.   
  20.     public void accept(Visitor visitor) {   
  21.         visitor.visitString(this);   
  22.     }   
  23. }  
package org.bulktree.visitor;

/**
 * 被访问者--String对象
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public class StringElement implements Visitable {

    private String str;

    public StringElement(String str) {
        this.str = str;
    }

    public String getStr() {
        return str;
    }

    public void accept(Visitor visitor) {
        visitor.visitString(this);
    }
}


查看 复制到剪切板 打印
  1. package org.bulktree.visitor;   
  2.   
  3. /**  
  4.  * 被访问者--Integer对象  
  5.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  6.  * @date Aug 10, 2008  
  7.  */  
  8. public class IntegerElement implements Visitable {   
  9.   
  10.     private Integer i;   
  11.        
  12.     public IntegerElement(Integer i) {   
  13.         this.i = i;   
  14.     }   
  15.        
  16.     public Integer getI() {   
  17.         return i;   
  18.     }   
  19.        
  20.     public void accept(Visitor visitor) {   
  21.         visitor.visitInteger(this);   
  22.   
  23.     }   
  24. }  
package org.bulktree.visitor;

/**
 * 被访问者--Integer对象
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public class IntegerElement implements Visitable {

    private Integer i;
    
    public IntegerElement(Integer i) {
        this.i = i;
    }
    
    public Integer getI() {
        return i;
    }
    
    public void accept(Visitor visitor) {
        visitor.visitInteger(this);

    }
}


查看 复制到剪切板 打印
  1. package org.bulktree.visitor;   
  2.   
  3. import java.util.Collection;   
  4.   
  5. /**  
  6.  * 被访问者--Person对象  
  7.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  8.  * @date Aug 10, 2008  
  9.  */  
  10. public class PersonElement implements Visitable{   
  11.     private Person p;   
  12.        
  13.     public PersonElement(Person p) {   
  14.         this.p = p;   
  15.     }   
  16.        
  17.     public Person getP() {   
  18.         return p;   
  19.     }   
  20.   
  21.     public void accept(Visitor visitor) {   
  22.         visitor.visitPerson(this);   
  23.     }   
  24. }  
package org.bulktree.visitor;

import java.util.Collection;

/**
 * 被访问者--Person对象
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public class PersonElement implements Visitable{
    private Person p;
    
    public PersonElement(Person p) {
        this.p = p;
    }
    
    public Person getP() {
        return p;
    }

    public void accept(Visitor visitor) {
        visitor.visitPerson(this);
    }
}


查看 复制到剪切板 打印
  1. package org.bulktree.visitor;   
  2.   
  3. import java.util.Collection;   
  4. import java.util.List;   
  5.   
  6. /**  
  7.  * 被访问者--Collection对象  
  8.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  9.  * @date Aug 10, 2008  
  10.  */  
  11. public class CollectionElement implements Visitable {   
  12.   
  13.     private Collection collection;   
  14.   
  15.     public CollectionElement(Collection collection) {   
  16.         this.collection = collection;   
  17.     }   
  18.   
  19.     public Collection getCollection() {   
  20.         return collection;   
  21.     }   
  22.   
  23.     public void accept(Visitor visitor) {   
  24.         visitor.visitCollection(collection);   
  25.     }   
  26. }  
package org.bulktree.visitor;

import java.util.Collection;
import java.util.List;

/**
 * 被访问者--Collection对象
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public class CollectionElement implements Visitable {

    private Collection collection;

    public CollectionElement(Collection collection) {
        this.collection = collection;
    }

    public Collection getCollection() {
        return collection;
    }

    public void accept(Visitor visitor) {
        visitor.visitCollection(collection);
    }
}


下来定义一个访问者Visitor接口，它可以访问Integer,String,Person(VO对象),Collection类型
查看 复制到剪切板 打印
  1. package org.bulktree.visitor;   
  2.   
  3. import java.util.Collection;   
  4.   
  5. /**  
  6.  * 访问者接口  
  7.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  8.  * @date Aug 10, 2008  
  9.  */  
  10. public interface Visitor {   
  11.     public void visitString(StringElement str);   
  12.     public void visitInteger(IntegerElement i);   
  13.     public void visitCollection(Collection collection);   
  14.     public void visitPerson(PersonElement perE);   
  15. }  
package org.bulktree.visitor;

import java.util.Collection;

/**
 * 访问者接口
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public interface Visitor {
    public void visitString(StringElement str);
    public void visitInteger(IntegerElement i);
    public void visitCollection(Collection collection);
    public void visitPerson(PersonElement perE);
}


关键的Visitor实现类
查看 复制到剪切板 打印
  1. package org.bulktree.visitor;   
  2.   
  3. import java.util.Collection;   
  4. import java.util.Iterator;   
  5.   
  6. /**  
  7.  * 访问者实现类  
  8.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  9.  * @date Aug 10, 2008  
  10.  */  
  11. public class VisitorImpl implements Visitor {   
  12.   
  13.     /*  
  14.      *访问字符串，仅对字符串输出   
  15.      */  
  16.     public void visitString(StringElement str) {   
  17.         System.out.println("*******************字符串输出*************************");   
  18.         System.out.println(str.getStr());   
  19.     }   
  20.   
  21.     /**  
  22.      * 访问Integer类型  
  23.      */  
  24.     public void visitInteger(IntegerElement i) {   
  25.         System.out.println("*******************整型输出*************************");   
  26.         System.out.println(i.getI());   
  27.     }   
  28.   
  29.     /**  
  30.      * 访问Collection对象，遍历每一个元素  
  31.      * 使用了一个if语句判断属于Visitable哪一个被访问对象，然后调用相应的accept方法  
  32.      * 实现递归调用  
  33.      */  
  34.     public void visitCollection(Collection collection) {   
  35.         Iterator iter = collection.iterator();   
  36.         while (iter.hasNext()) {   
  37.             Object o = iter.next();   
  38.             if (o instanceof Visitable) {   
  39.                 ((Visitable) o).accept(this);   
  40.             }   
  41.         }   
  42.     }   
  43.   
  44.     /**  
  45.      * 访问单个Person对象  
  46.      */  
  47.     public void visitPerson(PersonElement perE) {   
  48.         System.out.println("*******************Person对象输出*************************");   
  49.         Person person = perE.getP();   
  50.         System.out.println("person-name-> " + person.getName());   
  51.         System.out.println("person-age-> " + person.getAge());   
  52.         System.out.println("person-sex-> " + person.getSex());   
  53.     }   
  54.   
  55. }  
package org.bulktree.visitor;

import java.util.Collection;
import java.util.Iterator;

/**
 * 访问者实现类
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public class VisitorImpl implements Visitor {

    /*
     *访问字符串，仅对字符串输出 
     */
    public void visitString(StringElement str) {
        System.out.println("*******************字符串输出*************************");
        System.out.println(str.getStr());
    }

    /**
     * 访问Integer类型
     */
    public void visitInteger(IntegerElement i) {
        System.out.println("*******************整型输出*************************");
        System.out.println(i.getI());
    }

    /**
     * 访问Collection对象，遍历每一个元素
     * 使用了一个if语句判断属于Visitable哪一个被访问对象，然后调用相应的accept方法
     * 实现递归调用
     */
    public void visitCollection(Collection collection) {
        Iterator iter = collection.iterator();
        while (iter.hasNext()) {
            Object o = iter.next();
            if (o instanceof Visitable) {
                ((Visitable) o).accept(this);
            }
        }
    }

    /**
     * 访问单个Person对象
     */
    public void visitPerson(PersonElement perE) {
        System.out.println("*******************Person对象输出*************************");
        Person person = perE.getP();
        System.out.println("person-name-> " + person.getName());
        System.out.println("person-age-> " + person.getAge());
        System.out.println("person-sex-> " + person.getSex());
    }

}


客户端测试：
查看 复制到剪切板 打印
  1. package org.bulktree.visitor;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.Collection;   
  5.   
  6. /**  
  7.  * Visitor模式客户端  
  8.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  9.  * @date Aug 10, 2008  
  10.  */  
  11. public class VisitorMain {   
  12.   
  13.     public static void main(String[] args) {   
  14.         Visitor visitor = new VisitorImpl();   
  15.   
  16.            
  17.         /*  
  18.          * 访问字符串  
  19.          */  
  20.         System.out.println("======================访问字符串=========================");   
  21.         StringElement stringE = new StringElement(   
  22.                 "bulktree.laoshulin.oakertree");   
  23.         visitor.visitString(stringE);   
  24.   
  25.         /*  
  26.          * 访问集合  
  27.          */  
  28.         System.out.println("=======================访问集合========================");   
  29.         Collection list = new ArrayList();   
  30.   
  31.         StringElement str1 = new StringElement("aaa");   
  32.         StringElement str2 = new StringElement("bbb");   
  33.         list.add(str1);   
  34.         list.add(str2);   
  35.            
  36.         PersonElement perE1 = new PersonElement(new Person("LAOSHULIN", "22", "M"));   
  37.         PersonElement perE2 = new PersonElement(new Person("BULKTREE", "21", "W"));   
  38.         list.add(perE1);   
  39.         list.add(perE2);   
  40.            
  41.         IntegerElement intE1 = new IntegerElement(new Integer(99));   
  42.         IntegerElement intE2 = new IntegerElement(new Integer(100));   
  43.         list.add(intE1);   
  44.         list.add(intE2);   
  45.            
  46.         visitor.visitCollection(list);   
  47.   
  48.         /*  
  49.          * 访问Person  
  50.          */  
  51.         System.out.println("======================访问Person=========================");   
  52.         Person p = new Person("BULKTREE", "22", "M");   
  53.         PersonElement perE = new PersonElement(p);   
  54.         visitor.visitPerson(perE);   
  55.            
  56.         /*  
  57.          * 访问Integer  
  58.          */  
  59.         System.out.println("=====================访问Integer==========================");   
  60.         IntegerElement intE = new IntegerElement(new Integer(77));   
  61.         visitor.visitInteger(intE);   
  62.     }   
  63. }  
package org.bulktree.visitor;

import java.util.ArrayList;
import java.util.Collection;

/**
 * Visitor模式客户端
 * @author bulktree Email: laoshulin@gmail.com
 * @date Aug 10, 2008
 */
public class VisitorMain {

    public static void main(String[] args) {
        Visitor visitor = new VisitorImpl();

        
        /*
         * 访问字符串
         */
        System.out.println("======================访问字符串=========================");
        StringElement stringE = new StringElement(
                "bulktree.laoshulin.oakertree");
        visitor.visitString(stringE);

        /*
         * 访问集合
         */
        System.out.println("=======================访问集合========================");
        Collection list = new ArrayList();

        StringElement str1 = new StringElement("aaa");
        StringElement str2 = new StringElement("bbb");
        list.add(str1);
        list.add(str2);
        
        PersonElement perE1 = new PersonElement(new Person("LAOSHULIN", "22", "M"));
        PersonElement perE2 = new PersonElement(new Person("BULKTREE", "21", "W"));
        list.add(perE1);
        list.add(perE2);
        
        IntegerElement intE1 = new IntegerElement(new Integer(99));
        IntegerElement intE2 = new IntegerElement(new Integer(100));
        list.add(intE1);
        list.add(intE2);
        
        visitor.visitCollection(list);

        /*
         * 访问Person
         */
        System.out.println("======================访问Person=========================");
        Person p = new Person("BULKTREE", "22", "M");
        PersonElement perE = new PersonElement(p);
        visitor.visitPerson(perE);
        
        /*
         * 访问Integer
         */
        System.out.println("=====================访问Integer==========================");
        IntegerElement intE = new IntegerElement(new Integer(77));
        visitor.visitInteger(intE);
    }
}

使用访问者模式的前提是对象群结构中(Collection) 中的对象类型很少改变，在两个接口Visitor(访问)和Visitable（可访问）中,确保Visitable很少变化,也就是说，确保不能有新的元素类型加进来，可以变化的是访问者行为或操作，也就是Visitor的不同子类可以有多种,这样使用访问者模式最方便,当系统中存在着固定的数据结构,且有着不同的行为，访问者模式也许是个不错的选择

查看 复制到剪切板 打印
  1. package org.bulktree.xml;   
  2.   
  3. import java.io.File;   
  4.   
  5. import org.dom4j.Attribute;   
  6. import org.dom4j.Document;   
  7. import org.dom4j.DocumentException;   
  8. import org.dom4j.Element;   
  9. import org.dom4j.VisitorSupport;   
  10. import org.dom4j.io.SAXReader;   
  11.   
  12. /**  
  13.  * dom4j访问者模式解析xml文档  
  14.  * @author bulktree Email: <A href="mailto:laoshulin@gmail.com">laoshulin@gmail.com</A>  
  15.  * @date Aug 10, 2008  
  16.  */  
  17. public class ReadXmlVisitor {   
  18.   
  19.     ReadXmlVisitor() {   
  20.   
  21.         File file = new File("student.xml");   
  22.         SAXReader saxReader = new SAXReader();   
  23.   
  24.         try {   
  25.             Document doc = saxReader.read(file);   
  26.             doc.accept(new MyVisitor());   
  27.         } catch (DocumentException e) {   
  28.             e.printStackTrace();   
  29.         }   
  30.     }   
  31.        
  32.     public static void main(String[] args) {   
  33.         new ReadXmlVisitor();   
  34.     }   
  35.   
  36. }   
  37.   
  38. /*  
  39.  * org.dom4j 包里有Visitor接口，VisitorSupport是它的实现类，定义了多个重载的visit方法  
  40.  */  
  41. class MyVisitor extends VisitorSupport {   
  42.     public void visit(Attribute attr) {   
  43.         String name = attr.getName();   
  44.         String value = attr.getValue();   
  45.   
  46.         System.out.println("Attribute--> " + name + " : " + value);   
  47.     }   
  48.   
  49.     public void visit(Element element) {   
  50.         String name = element.getName();   
  51.         if (element.isTextOnly()) {   
  52.             System.out   
  53.                     .println("Element--> " + name + " : " + element.getText());   
  54.         } else {   
  55.             System.out.println("Element-->" + name);   
  56.         }   
  57.     }   
  58. }  
 
haorui_v
关注
专栏目录
Dom4j解析xml
ZzzzjQqqq的博客
05-23 1094
1 dom4j介绍 　　dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。dom4j是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM developerWorks上面可以找到一篇文章，对主流的Java XML API进行的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别
Dom4j 解析XML
05-27
在实际操作XML文档时，DOM4J提供了一些关键的类和方法。例如，要读取XML文档，可以使用`SAXReader`类。以下代码展示了如何加载XML文件并获取`Document`对象： ```java import org.dom4j.Document; import org.dom4j...
Dom4j读文件1---Visitor模式
beckham
01-29 3019
Visitor 接口提供多种Visit()的重载，根据XML不同的对象，将采用不同的方式来访问。上面是给出的Element 和Attribute 的简单实现，一般比较常用的就是这两个。VisitorSupport是DOM4J提供的默认适配器，Visitor 接口的Default Adapter模式，这个模式给出了各种visit(*)的空实现，以便简化代码 定义自己的visitorpac
visitor访问者模式及dom4j中使用（一）
yxiaozi的专栏
03-15 851
dom4j遍历xml树的方法中有一种visitor模式，写一下自己对isitor模式的理解。拿城管来打个比方吧，市场是一个很大的collection，里面有卖煎饼果子的（pizza），有卖铁板鱿鱼的（BBQ），有卖包包的（bag）......public class MarkCollection{      Collection c=null;      MarkCollectio
dom4j解析xml的访问者visitor模式
aliahhqcheng的专栏
01-04 551
package org.dom4j; import java.io.IOException; import java.io.Writer; import java.util.List; public interface Node extends Cloneable { . . ...
dom4j解析xml详解
03-27
16. **Visitor**: 实现了访问者模式，允许对DOM4J树进行深度遍历，并在每个节点上执行特定的操作。 17. **XPath**: 提供了XPath表达式的查询能力，使得在复杂的数据结构中定位和提取数据变得更加容易。 #### 三、...
java_Dom4j解析XML详解.docx
02-07
DOM4J的灵活性还体现在支持Visitor模式，通过实现`Visitor`接口，可以遍历XML树并执行特定操作。此外，XPath的使用使得定位XML节点变得极其方便，可以快速访问和修改XML文档的任意部分。 总之，DOM4J是Java开发者...
java_Dom4j解析XML详解.doc
04-20
由于DOM4J的设计简洁易用，对于熟悉XML-DOM模型的开发者来说，上手非常快。 #### 二、DOM4J的核心接口 DOM4J的核心接口定义在`org.dom4j`包内，这些接口提供了对XML文档进行操作的能力。下面详细介绍这些接口及其...
利用dom4j的visitor模式对xml文件的“反射”
IT民工的小窝
08-20 2313
给定一个xml文件，由于dom4j支持visitor模式，可以得到生成该xml文件内容的java代码（dom4j的API），在某些时候，可能会有用处。比如给定一个行数超过50行的范例xml文件，其内容需要用java代码生成。若使用该工具，则可以极大地减轻敲代码的工作量，执行该工具，即可输出该范例xm文件所l对应的java生成代码，值得一试。附：程序代码（需要dom4j的jar文件）packag
DOM4J_VisitorSupport
rongrong_love_lc的专栏
06-08 1220
DOM4J解析XML利用访问者（VisitorSupport）解析XML文件。通过复写各种类型的visit（）方法解析各种节点，文本内容。 1、解析： `SAXReader saxReader = new SAXReader(); Document doc = saxReader.read(new File("students.xml")); doc.accept(new MyVisito
visitor访问者模式及dom4j中使用（二）
yxiaozi的专栏
03-16 1313
在这使用visitor模式解析订购关系同步SyncOrderRelationReq的xml文件import org.dom4j.Attribute;import org.dom4j.Element;import org.dom4j.VisitorSupport; public class MyVisitor extends VisitorSupport { HashMap hm=new
设计模式-访问者模式(Visitor)-Java
gaogzhen的博客
06-14 414
设计模式-访问者模式(Visitor)-Java 目录 文章目录1、前言2、示例案例-OA系统中员工数据汇总3、访问者模式概述3.1、访问者模式定义3.2、访问者模式结构3.3、访问者模式结构图中角色3.4、访问者模式典型实现4、访问者模式完整解决方案5、访问者模式与组合模式联用6、总结6.1、优缺点6.2、适用场景***后记*** ： 内容 1、前言   想必大家都去过医院，虽然没有人喜欢去医院（爱岗敬业的医务工作人员除外，微笑）。在医生开具处方单（药单）后，很多医院都存在如下处理流程：划价人员
xml解析汇总
Mustang's Note
09-02 2679
说明：笔者最近搞点东西需要用到xml技术，上网找到点资料感觉受益匪浅总结一下与大家分享，这里很多是对原资料的引用，希望原作者看见不要介意＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝XML 技术是随着 Java 的发展而发展起来的。在 XML 出现之前对于简单的数据格式通常是存储在 ini 配置文件等文本文件中，复杂的格式则采用自定义的文件格式，因
软件设计模式与体系结构 实验十 访问者模式
abc1498880402的博客
04-03 2355
【实验内容和要求】 某公司OA系统中包含一个员工信息管理子系统，该公司员工包括正式员工和临时工，每周人力资源部和财务部等部门需要对员工数据进行汇总，汇总数据包括员工工作时间、员工工资等。该公司基本制度如下： (1) 正式员工每周工作时间为40小时，不同级别、不同部门的员工每周基本工资不同；如果超过40小时，超出部分按照100元/小时作为加班费；如果少于40小时，所缺时间按照请假处理，请假所扣工...
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 5761
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
dom4j详解：XML解析与操作指南
"dom4j是Java中用于处理XML的一个库，提供了解析、创建和修改XML文件的功能。它以其高效性、强大特性和易于使用而著名，并且是开源的。在许多Java项目中，包括Hibernate的配置文件处理，都广泛使用了dom4j。其主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值