xml

最新推荐文章于 2018-09-26 15:42:09 发布
最新推荐文章于 2018-09-26 15:42:09 发布
阅读量557 收藏
点赞数
文章标签： vector string servlet interface servlets xml

 

Dom4J
1 Dom4J 介绍
Dom4j is an easy to use, open source library for working with XML, XPath and XSLT on the Java platform using the Java Collections Framework and with full support for DOM, SAX and JAXP.
Dom4j 是一个易用的、开源的库，用于 XML ， XPath 和 XSLT 。它应用于 Java 平台，采用了 Java 集合框架并完全支持 DOM ， SAX 和 JAXP 。
 
2 使用 Dom4J 所需的 jar 包 (dom4j-1.6.1.jar , jaxen-1.1-beta-6.jar)
 
3 Dom4J 类库的常用类介绍
 
      
1          Attribute
2          Attribute 定义了 XML 的属性
3          Branch
4          Branch 为能够包含子节点的节点如 XML 元素 (Element) 和文档 (Docuemnts) 定义了一个公共的行为，
5          CDATA
6          CDATA 定义了 XML CDATA 区域
7          CharacterData
8          CharacterData 是一个标识借口，标识基于字符的节点。如 CDATA ， Comment, Text .
9          Comment
10      Comment 定义了 XML 注释的行为
11      Document
12      定义了 XML 文档
13      DocumentType
14      DocumentType 定义 XML DOCTYPE 声明
15      Element
16      Element 定义 XML 元素
17      ElementHandler
18      ElementHandler 定义了 Element 对象的处理器
19      ElementPath
20      被 ElementHandler 使用，用于取得当前正在处理的路径层次信息
21      Entity
22      Entity 定义 XML entity
23      Node
24      Node 为所有的 dom4j 中 XML 节点 定义了多态行为
25      NodeFilter
26      NodeFilter 定义了在 dom4j 节点中产生的一个滤镜或谓词的行为（ predicate ）
27      ProcessingInstruction
28      ProcessingInstruction 定义 XML 处理指令 .
29      Text
30      Text 定义 XML 文本节点 .
31      Visitor
32      Visitor 用于实现 Visitor 模式 .
33      XPath
34      XPath 在分析一个字符串后会提供一个 XPath 表达式
 
4 Dom4J 常见用法
       创建一个 XML 文件

public Document createDocument(){
        // 创建XML文档模型
        this.document = DocumentHelper.createDocument();
        // 设置编码集
        document.setXMLEncoding("UTF-8");
       // 在创建好的XML文档模型内创建根元素
        Element root = document.addElement(" 根元素");
        // 在根元素内创建子元素a
        Element node1 = root.addElement(" 子元素a")
        // 给子元素a添加属性名和属性值
        .addAttribute(" 子元素a属性名1", "子元素a属性值1")
        .addAttribute(" 子元素a属性名2", "子元素a属性值2")
        // 在子元素a中添加文本
        .addText(" 子元素a内容");
        // 在子元素a中创建孙元素a
        node1.addElement(" 孙元素a")
        // 给孙元素a添加属性名和属性值
        .addAttribute(" 孙元素a属性名", "孙元素a属性值")
        // 在孙元素a中添加文本
        .addText(" 孙元素a内容");
        // 在跟元素下创建第二个子元素
        Element node2 = root.addElement(" 子元素b")
        // 添加注释
        .addComment(" 子元素b内容注释")
        // 添加CDATA文本
        .addCDATA("< 子元素b内容>")
        .addElement(" 孙元素b")
        .addAttribute(" 孙元素b属性名", "孙元素b属性值");
        return this.document;
    }

将 XML 文档保存（图 1 ）

public void writeXML(Document document) throws IOException{
         // 创建一个格式化输出流
        OutputFormat format =
        // 缩进字符，此处使用了四个空格
        new OutputFormat("    ",
        // 换行指令
        true,
        // 编码格式
        "UTF-8");
        // 创建Dom4J自带的输出流
        XMLWriter writer = new XMLWriter(
        // 要保存的位置
        new FileWriter("/home/zhang23.xml"),
        // 放入格式化输出流
        format);
        // 流写出
        writer.write(document);
        // 关闭流
        writer.close();
    }

 

3                         <?xml version="1.0" encoding="UTF-8"?>
4                          
5                         < 根元素 >
6                             < 子元素 a 子元素 a 属性名 1=" 子元素 a 属性值 1" 子元素 a 属性名 2=" 子元素 a 属性值 2"> 子元素 a 内容
7                                 < 孙元素 a 孙元素 a 属性名 =" 孙元素 a 属性值 "> 孙元素 a 内容 </ 孙元素 a>
8                             </ 子元素 a>
9                             < 子元素 b>
10                             <!-- 子元素 b 内容注释 --><![CDATA[< 子元素 b 内容 >]]>
11                             < 孙元素 b 孙元素 b 属性名 =" 孙元素 b 属性值 "/>
12                         </ 子元素 b>
13                     </ 根元素 >

图 1
查询某节点的值

public void getElementValue(){
         // 根据路径得到一个节点
         Node node = this.document.selectSingleNode("/ 根元素/子元素a/孙元素a");
         // 得到节点名称
         System.out.println(node.getName());
         // 得到节点类型
         System.out.println(node.getNodeTypeName());
         // 得到此元素下的文本
         System.out.println(node.getText());
         // 转换为元素
         Element element = (Element)node;
         // 得到属性值
         System.out.println(element.attributeValue(" 孙元素a属性名"));
}
以下是控制台输出信息
15                             /**
16                              * 孙元素 a
17                             * Element
18                              *  孙元素 a 内容
19                              *  孙元素 a 属性值
20                              */
 

 
增加节点（图 2 ）

public void addElement(){
        // 根据路径得到一个节点
        Node node = this.document.selectSingleNode("/ 根元素/子元素a/孙元素a");
        // 转换成元素
        Element element = (Element)node;
        // 添加元素
        element.addElement(" 添加重孙元素");
        // 添加属性
        element.addAttribute(" 添加属性名", "添加属性值");
    }

      
      

<?xml version="1.0" encoding="UTF-8"?>
    < 根元素>      
        < 子元素a 子元素a属性名1="子元素a属性值1" 子元素a属性名2="子元素a属性值2">子元素a内容           
            < 孙元素a 孙元素a属性名="孙元素a属性值" 添加属性名="添加属性值">孙元素a内容           
                < 添加重孙元素/>           
            </ 孙元素a>       
        </ 子元素a>       
        < 子元素b>          
            <!-- 子元素b内容注释--><![CDATA[<子元素b内容>]]>           
            < 孙元素b 孙元素b属性名="孙元素b属性值"/>      
        </ 子元素b>      
    </ 根元素>

图 2
修改某节点（图 3 ）

   public void updateElement(){
          // 通过路径得到一个节点
          Node node = document.selectSingleNode("/ 根元素/子元素a/修改的孙接点");
          // 转换成元素
          Element element = (Element)node;
          // 通过得到元素内属性的数量综合进行循环
          for(int i=0;i<element.attributeCount();i++){
             // 判断属性名是否符合
              if(element.attribute(i).getName().equals(" 孙元素a属性名")){
                 // 修改属性值
                  element.attribute(i).setValue(" 修改值");
              }
          }
        // 修改文本内容
        element.setText(" 修改文本内容");
        // 修改节点名
        element.setName(" 修改的孙接点");
}
 
 


删除某节点的值
 
      
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

<?xml version="1.0" encoding="UTF-8"?>
< 根元素>
    < 子元素a 子元素a属性名1="子元素a属性值1" 子元素a属性名2="子元素a属性值2">子元素a内容    
        < 修改的孙接点 孙元素a属性名="修改值" 添加属性名="添加属性值">      
            < 添加重孙元素/>修改文本内容 
        </ 修改的孙接点>
    </ 子元素a>
    < 子元素b>
        <!-- 子元素b内容注释--><![CDATA[<子元素b内容>]]>
        < 孙元素b 孙元素b属性名="孙元素b属性值"/>
    </ 子元素b>
</ 根元素>

图 3
 
       删除属性值 （图 4 ）

   public void removeElement(){
        // 通过路径得到一个节点
        Node node = this.document.selectSingleNode("/ 根元素/子元素a/修改的孙接点");
        // 转换成元素
        Element element = (Element)node;
        // 通过得到元素内属性的数量综合进行循环
        for(int i=0;i<element.attributeCount();i++){
            // 判读属性名符合
            if(element.attribute(i).getName().equals(" 孙元素a属性名")){
                // 删除属性
                element.remove(element.attribute(i));
            }
        }
    }

 
 
 
 

<?xml version="1.0" encoding="UTF-8"?>
< 根元素>
    < 子元素a 子元素a属性名1="子元素a属性值1" 子元素a属性名2="子元素a属性值2">子元素a内容
        < 修改的孙接点 添加属性名="添加属性值">
            < 添加重孙元素/>修改文本内容
        </ 修改的孙接点>
    </ 子元素a>
    < 子元素b>
        <!-- 子元素b内容注释--><![CDATA[<子元素b内容>]]>
        < 孙元素b 孙元素b属性名="孙元素b属性值"/>
    </ 子元素b>
</ 根元素>

图 4
       删除某元素（图 5 ）

    public void removeElement(Element element){
        // 定义一个节点
        Node node = null;
        // 通过元素包含的节点数进行循环
        for(int i=0;i<element.nodeCount();i++){
            // 得到一个节点
            node = element.node(i);
           // 判断是否包含子类，以便进行转换
            if(node instanceof Element){
                // 判断节点名称受否符合
                if(node.getName().equals(" 修改的孙接点")){
                    // 删除元素
                    element.remove((Element)node);
                }else{
                    // 如果不符合条件则进行递归
                    this.removeElement((Element)node);
                }
            }
        }
}
说明
     /**
     此方法也可用在不知道XML文件的结构的情况下
     （也就是无法给出要操作的元素或节点的路径）
     对元素或节点的进行增删改的操作
     **/
 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

< 根元素>
    < 子元素a 子元素a属性名1="子元素a属性值1" 子元素a属性名2="子元素a属性值2">子元素a内容
    </ 子元素a>
    < 子元素b>
        <!-- 子元素b内容注释--><![CDATA[<子元素b内容>]]>
        < 孙元素b 孙元素b属性名="孙元素b属性值"/>
    </ 子元素b>
</ 根元素〉

图 5
 
 
读取中文注意事项（在读写 XML 文件时不要用 UTF-8 编码格式，用比如 Gb2312 等就可以）
 
commons-digester
1 commons-digester 介绍
   Digester 本来仅仅是Jakarta Struts中的一个工具，用于处理struts-config.xml配置文件。显然，将XML文件转换成相应的Java对象是一项很通用的功能，这个工具理应具有更广泛的用途，所以很快它就在Jakarta Commons项目(用于提供可重用的Java组件库)中有了一席之地。
简言之，Digester由"事件"驱动，通过调用预定义的规则操作对象栈，将XML文件转换为Java对象。工作原理如下:
Digester 底层采用SAX解析XML文件，所以很自然的，对象转换由"事件"驱动，即在识别出特定XML元素时(实际被细分为begin、body、end、finish四个时点)，将执行特定的动作，比如创建特定的Java对象，或调用特定对象的方法等。此处的XML元素根据匹配模式(matching pattern)识别，而相关操作由规则(rule)定义。在转换过程中，Digester维持了一个对象栈，可以看作对象转换的工作台，用来存放转换中生成的、或是为转换临时创建的Java对象。对输入XML文件作了一趟完整的扫描后，对象栈的栈顶元素即为目标对象。由于Digester屏蔽了SAX解析的细节，使用者仅需关注转换操作本身，大大简化了转换操作。
 
2 元素匹配模板
       Digester 能自动遍历目标XML文档的元素形成的层次结构，这个过程无需程序员参与。程序员的任务是决定，在解析的过程中，当由嵌套的元素形成的一个特定序列被识别出时，如何处理它。用以描述这种序列的机制，就叫“元素匹配模板”。
　　具体说来，元素和其子元素间，用”/”相隔，如果一些元素前没有”/”则其必为根元素。如例：
<a>      --  匹配模板 "a"
  <b>       -- 匹配模板 "a/b"
    <c/>    -- 匹配模板 "a/b/c"
    <c/>    -- 匹配模板 "a/b/c"
  </b>
  <b>       -- 匹配模板 "a/b"
    <c/>    -- 匹配模板 "a/b/c"
    <c/>    -- 匹配模板 "a/b/c"
    <c/>    -- 匹配模板 "a/b/c"
  </b>
</a>

　　字符”*”表示任意级别，如”*/a”表示任意级别的<a>都可匹配(不包括根元素级的).熟悉XLST的朋友，对这种思路一定不陌生。
　　从上面的描述，可知某个元素同时满足多个匹配模板是非常可能的，在这种情况下，与各个模板相关联的处理规则（processing rule）的执行顺序如下：对begin或body方法，按照各个rule的注册顺序的先后，对end方法则是注册顺序的反序。
Digester 提供了一些编程中经常用到的规则(rule)，以下五类九个rule较为常用:
A: 对象创建
1.ObjectCreateRule  当begin()方法被调用时, 此rule创建相应Java对象, 并将其push到Digester的对象栈上。当end()方法被调用时, 栈顶对象将被pop, Digester内所有对该对象的引用都将失效。
2.FactoryCreateRule    创建Java对象的另一种选择。当待创建的Java对象没有无参构造函数，或需要在创建时需要进行额外的设置时，需要用此rule。
B: 属性设置
3.SetPropertiesRule    当begin()方法被调用时, Digester使用标准的Java反射API，将栈顶对象的属性设置为XML元素的同名属性值。
4.SetPropertyRule    当begin()方法被调用时, Digester调用栈顶对象某指定属性的设置方法，设置其值。
C: 父子关系管理
5.SetNextRule    当end()方法被调用时, Digester将栈顶元素设置进次栈顶元素中(调用相应的设置方法)。
6.SetTopRule    当end()方法被调用时, Digester将次栈顶元素设置进栈顶元素中(调用相应的设置方法)。
D: 任意方法调用
7.CallMethodRule    当end()方法被调用时, Digester将调用栈顶元素指定名称的方法。除了方法名外，此rule还需要配置参数数目，参数类型。参数值一般通过CallParamRule得到。
8.CallParamRule    此rule内嵌于CallParamRule中，按顺序(相对于0)定义了CallParamRule中参数值的来源，可选的来源包括当前XML元素的属性或内容。
E: 其它
9.NodeCreateRule    将XML文件树的一部分转换为DOM节点，并push到Digester的对象栈上。
3 简单用法介绍
       源文件 source.xml （图 6 ）
35                     <catalog library="somewhere">
36                     <book>
37                       <author>zhanglei</author>
38                       <title>think in java</title>
39                       <describe type="A">
40                           <price>15$</price>
41                           <language>English</language>
42                       </describe>
43                       <describe type="B">
44                           <price>128RMB</price>
45                           <language>chinese</language>
46                       </describe>
47                     </book>
48                     <book>
49                       <author>lele</author>
50                       <title>think in wife</title>
51                       <describe type="A">
52                           <price>127RMB</price>
53                           <language>chinese</language>
54                       </describe>
55                     </book>
56                     </catalog>
 
 
图 6
建立 javaBean 文件
public class Catalog {
    private String library;
    private Vector books;
   
    public Catalog(){
        books = new Vector();
    }
    public Vector getBooks() {
        return books;
    }
    public void setBooks(Book book) {
        books.addElement(book);
    }
    public String getLibrary() {
        return library;
    }
    public void setLibrary(String library) {
        this.library = library;
    }
   
}
 
public class Book {
    private String author;
    private String title;
    private Vector describes;
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public Vector getDescribes() {
        return describes;
    }
    public void setDescribes(Describe describe) {
        this.describes.addElement(describe);
    }
}
 
 
配置格式文件 rule.xml （图 7 ）
<digester-rules>
    <object-create-rule pattern="catalog" classname="Catalog"/>
        <set-properties-rule pattern="catalog">
           <alias attr-name="library" prop-name="library" />
       </set-properties-rule>
        <pattern value="catalog/book">
           <object-create-rule classname="Book" />
           <call-method-rule pattern="author" methodname="setAuthor" paramcount="0" />
           <call-method-rule pattern="title" methodname="setTitle" paramcount="0" />
           <pattern value="describe">
               <object-create-rule classname="Describe" />
               <set-properties-rule>
                   <alias attr-name="type" prop-name="type" />
               </set-properties-rule>
               <call-method-rule pattern="price" methodname="setPrice" paramcount="0" />
               <call-method-rule pattern="language" methodname="setLanguage" paramcount="0" />
               <set-next-rule methodname="setDescribes" />
           </pattern>
           <set-next-rule methodname="setBooks" />
       </pattern> 
</digester-rules>
 
       4 实际应用
上面例子是简单的对 digester 的理解，真正的实际应用要复杂一些，下面是 digester 读取 TSSystem 项目中的 web.xml 文件的例子。
       web .xml 文件如下：
<?xml version="1.0" ?>
<web-app>
    <display-name>Struts Blank Application</display-name>  
    <!-- Standard Action Servlet Configuration (with debugging) -->
    <servlet>
        <servlet-name>action</servlet-name>
        <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
        <init-param>
            <param-name>config</param-name>
            <param-value>/WEB-INF/struts-config.xml</param-value>
        </init-param>
        <init-param>
            <param-name>config/permit</param-name>
                  <param-value>/WEB-INF/permit/struts-config.xml</param-value>
        </init-param>
        <init-param>
            <param-name>config/msg</param-name>
            <param-value>/WEB-INF/msg/struts-config.xml</param-value>
        </init-param>
        <init-param>
            <param-name>config/screen</param-name>
            <param-value>/WEB-INF/screen/struts-config.xml</param-value>
        </init-param>
 
        <init-param>
            <param-name>debug</param-name>
            <param-value>2</param-value>
        </init-param>
        <init-param>
            <param-name>detail</param-name>
            <param-value>2</param-value>
        </init-param>
        <load-on-startup>2</load-on-startup>
    </servlet>
   
    <servlet>
        <servlet-name>velocity</servlet-name>
        <servlet-class>
            org.apache.velocity.tools.view.servlet.VelocityViewServlet</servlet-class>
        <init-param>
            <param-name>org.apache.velocity.toolbox</param-name>
           <param-value>/WEB-INF/toolbox.xml</param-value>
        </init-param>
        <init-param>
            <param-name>org.apache.velocity.properties</param-name>
            <param-value>/WEB-INF/velocity.properties</param-value>
        </init-param>
        <load-on-startup>10</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>Connector</servlet-name>
        <servlet-class>com.css.htmleditor.ConnectorServlet</servlet-class>
        <init-param>
            <param-name>baseDir</param-name>
            <param-value>/UserFiles/</param-value>
        </init-param>
              <init-param>
            <param-name>debug</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>AllowedExtensionsImage</param-name>
            <param-value>gif|jpg|jpeg</param-value>
        </init-param>
        <init-param>
            <param-name>UnallowedExtensionsFile</param-name>
            <param-value>exe|java|class</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
   
    <!-- Standard Action Servlet Mapping -->
    <servlet-mapping>
        <servlet-name>action</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>velocity</servlet-name>
        <url-pattern>*.vm</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
      <servlet-name>Connector</servlet-name>
      <url-pattern>
      /css_js/msg/FCKeditor/editor/filemanager/browser/default/connectors/jsp/connector
      </url-pattern>
    </servlet-mapping>
   
    <!-- The Usual Welcome File List -->
    <welcome-file-list>
        <welcome-file>index.do</welcome-file>
    </welcome-file-list>
   
    <!--<error-page>
        <error-code>404</error-code>
        <location>index.do</location>
    </error-page>-->
   
    <security-constraint>
        <web-resource-collection>
            <web-resource-name>Restrict access to vm pages</web-resource-name>
            <url-pattern>/include/*</url-pattern>
            <url-pattern>/pages/*</url-pattern>
        </web-resource-collection>
        <auth-constraint>
            <description>
            With no roles defined, no access granted
            </description>
        </auth-constraint>
  </security-constraint>
   
</web-app>
       匹配文件 webRule.xml
<digester-rules>
    <object-create-rule pattern="web-app" classname="web.WebApp"/>
    <call-method-rule pattern="web-app/display-name" methodname="setDisplayName" paramcount="0" />
    <pattern value="web-app/servlet">
        <object-create-rule classname="web.Servlet" />
        <call-method-rule pattern="servlet-name" methodname="setServletName" paramcount="0" />
        <call-method-rule pattern="servlet-class" methodname="setServletClass" paramcount="0" />
        <pattern value="init-param">
            <object-create-rule classname="web.InitParam" />
                <call-method-rule pattern="param-name" methodname="setParamName" paramcount="0" />
                <call-method-rule pattern="param-value" methodname="setParamValue" paramcount="0" />           
            <set-next-rule methodname="setInitParams" />
        </pattern>
        <call-method-rule pattern="load-on-startup" methodname="setLoadOnStartup" paramcount="0" />
        <set-next-rule methodname="setServlets" />
    </pattern>
    <pattern value="web-app/servlet-mapping">
        <object-create-rule classname="web.ServletMapping" />
        <call-method-rule pattern="servlet-name" methodname="setServletName" paramcount="0" />
        <call-method-rule pattern="url-pattern" methodname="setUrlPattern" paramcount="0" />
        <set-next-rule methodname="setServletMappings" />
    </pattern>
    <pattern value="web-app/welcome-file-list">
        <object-create-rule classname="web.WelcomeFileList" />
        <call-method-rule pattern="welcome-file" methodname="setWelcomeFile" paramcount="0" />
        <set-next-rule methodname="setWelcomeFileLists" />
    </pattern>
    <pattern value="web-app/security-constraint">
        <object-create-rule classname="web.SecurityConstraint" />
        <pattern value="web-resource-collection">
            <object-create-rule classname="web.WebResourceCollection" />
            <call-method-rule pattern="web-resource-name" methodname="setWebResourceName" paramcount="0" />
            <call-method-rule pattern="url-pattern" methodname="setUrlPattern" paramcount="0" />
            <set-next-rule methodname="setWebResourceCollections" />
        </pattern>
        <pattern value="auth-constraint">
            <object-create-rule classname="web.AuthConstraint" />
            <call-method-rule pattern="description" methodname="setDescription" paramcount="0" />
            <set-next-rule methodname="setAuthConstraints" />
        </pattern>
        <set-next-rule methodname="setSecurityConstraints" />
    </pattern>
</digester-rules>
 
       根据嵌套结构，和元素个数建立对应得 Bean 文件，如下
package web;
 
import java.util.Vector;
 
public class AuthConstraint {
    private Vector description;
    public AuthConstraint(){
        description = new Vector();
    }
    /**
     * @return description
     */
    public Vector getDescription() {
        return description;
    }
    /**
     * @param description 要设置的 description
     */
    public void setDescription(String description) {
        this.description.addElement(description);
   }
   
}
package web;
 
public class InitParam {
    private String paramName;
    private String paramValue;
    /**
     * @return paramName
     */
    public String getParamName() {
        return paramName;
    }
    /**
     * @param paramName 要设置的 paramName
     */
    public void setParamName(String paramName) {
        this.paramName = paramName;
    }
    /**
     * @return paramValue
     */
    public String getParamValue() {
        return paramValue;
    }
    /**
     * @param paramValue 要设置的 paramValue
     */
    public void setParamValue(String paramValue) {
        this.paramValue = paramValue;
    }
   
}
package web;
 
import java.util.Vector;
 
public class SecurityConstraint {
    private Vector webResourceCollections;
    private Vector authConstraints;
   
    public SecurityConstraint(){
        webResourceCollections = new Vector();
        authConstraints = new Vector();
    }
 
    /**
     * @return authConstraint
     */
    public Vector getAuthConstraints() {
        return authConstraints;
    }
 
    /**
    * @param authConstraint 要设置的 authConstraint
     */
    public void setAuthConstraints(AuthConstraint authConstraint) {
        this.authConstraints.addElement(authConstraint);
    }
 
    /**
     * @return webResourceCollection
     */
    public Vector getWebResourceCollections() {
        return webResourceCollections;
    }
 
    /**
     * @param webResourceCollection 要设置的 webResourceCollection
     */
    Public void setWebResourceCollections(WebResourceCollection webResourceCollection) {
        this.webResourceCollections.addElement(webResourceCollection);
    }
   
}
package web;
 
import java.util.Vector;
 
public class Servlet {
    private String servletName;
    private String servletClass;
    private Vector initParams;
    private String loadOnStartup;
   
    public Servlet(){
        initParams = new Vector();
    }
    /**
     * @return initParams
     */
    public Vector getInitParams() {
        return initParams;
    }
    /**
     * @param initParams 要设置的 initParams
     */
    public void setInitParams(InitParam initParam) {
        this.initParams.addElement(initParam);
    }
    /**
     * @return servletClass
     */
    public String getServletClass() {
        return servletClass;
    }
    /**
     * @param servletClass 要设置的 servletClass
     */
    public void setServletClass(String servletClass) {
        this.servletClass = servletClass;
    }
    /**
     * @return servletName
     */
    public String getServletName() {
        return servletName;
    }
    /**
     * @param servletName 要设置的 servletName
     */
    public void setServletName(String servletName) {
        this.servletName = servletName;
    }
    /**
     * @return loadOnStartup
     */
    public String getLoadOnStartup() {
        return loadOnStartup;
    }
    /**
     * @param loadOnStartup 要设置的 loadOnStartup
     */
    public void setLoadOnStartup(String loadOnStartup) {
        this.loadOnStartup = loadOnStartup;
    }
   
}
package web;
 
public class ServletMapping {
    private String servletName;
    private String urlPattern;
    /**
     * @return servletName
     */
    public String getServletName() {
        return servletName;
    }
    /**
     * @param servletName 要设置的 servletName
     */
    public void setServletName(String servletName) {
        this.servletName = servletName;
    }
    /**
     * @return urlPattern
     */
    public String getUrlPattern() {
        return urlPattern;
    }
    /**
     * @param urlPattern 要设置的 urlPattern
     */
    public void setUrlPattern(String urlPattern) {
        this.urlPattern = urlPattern;
    }
   
}
package web;
 
import java.util.Vector;
 
public class WebApp {
    private String displayName;
    private Vector servlets;
    private Vector servletMappings;
   private Vector welcomeFileLists;
    private Vector securityConstraints;
   
    public WebApp(){
        servlets = new Vector();
        servletMappings = new Vector();
        welcomeFileLists = new Vector();
        securityConstraints = new Vector();
    }
 
    /**
     * @return displayName
     */
    public String getDisplayName() {
        return displayName;
    }
 
    /**
     * @param displayName 要设置的 displayName
     */
    public void setDisplayName(String displayName) {
        this.displayName = displayName;
    }
 
    /**
     * @return securityConstraints
     */
    public Vector getSecurityConstraints() {
        return securityConstraints;
    }
 
    /**
     * @param securityConstraints 要设置的 securityConstraints
     */
    public void setSecurityConstraints(SecurityConstraint securityConstraint) {
        this.securityConstraints.addElement(securityConstraint);
    }
 
    /**
     * @return servletMappings
     */
    public Vector getServletMappings() {
        return servletMappings;
    }
 
    /**
     * @param servletMappings 要设置的 servletMappings
     */
    public void setServletMappings(ServletMapping servletMapping) {
        this.servletMappings.addElement(servletMapping);
    }
 
    /**
     * @return servlets
     */
    public Vector getServlets() {
        return servlets;
    }
 
    /**
     * @param servlets 要设置的 servlets
     */
    public void setServlets(Servlet servlet) {
        this.servlets.addElement(servlet);
    }
 
    /**
     * @return welcomeFileLists
     */
    public Vector getWelcomeFileLists() {
        return welcomeFileLists;
    }
 
    /**
     * @param welcomeFileLists 要设置的 welcomeFileLists
     */
    public void setWelcomeFileLists(WelcomeFileList welcomeFileList) {
        this.welcomeFileLists.addElement(welcomeFileList);
    }
 
}
package web;
 
import java.util.Vector;
 
public class WebResourceCollection {
    private String webResourceName;
    private Vector urlPattern;
   
    public WebResourceCollection(){
        urlPattern = new Vector();
    }
    /**
     * @return urlPatterns
     */
    public Vector getUrlPattern() {
        return urlPattern;
    }
    /**
     * @param urlPatterns 要设置的 urlPatterns
     */
    public void setUrlPattern(String urlPattern) {
        this.urlPattern.addElement(urlPattern);
    }
    /**
     * @return webResourceName
     */
    public String getWebResourceName() {
        return webResourceName;
    }
    /**
     * @param webResourceName 要设置的 webResourceName
     */
    public void setWebResourceName(String webResourceName) {
        this.webResourceName = webResourceName;
    }
   
}
package web;
 
import java.util.Vector;
 
public class WelcomeFileList {
    private Vector welcomeFile;
    public WelcomeFileList(){
        welcomeFile = new Vector();
   }
    /**
     * @return welcomeFile
     */
    public Vector getWelcomeFiles() {
        return welcomeFile;
    }
 
    /**
     * @param welcomeFile 要设置的 welcomeFile
     */
    public void setWelcomeFile(String welcomeFile) {
        this.welcomeFile.addElement(welcomeFile);
    }
   
}
    读取XML类ReadWeb.java
package web;
 
import java.io.IOException;
import java.util.Vector;
 
import org.apache.commons.digester.Digester;
import org.apache.commons.digester.xmlrules.DigesterLoader;
import org.xml.sax.SAXException;
 
public class ReadWeb {
    public void read(){
       try {
       Digester digester = DigesterLoader.createDigester(  
       this.getClass().getClassLoader().getResource("web/webRule.xml"));  
       WebApp a = (WebApp)digester.parse(  
       this.getClass().getClassLoader().getResourceAsStream("web/web.xml"));
       String dn = a.getDisplayName();
       Vector sl = a.getServlets();
       Vector sm = a.getServletMappings();
       Vector wfl = a.getWelcomeFileLists();
       Vector sc = a.getSecurityConstraints();
       System.out.println("display-name: "+dn);
       for (int i = 0; i < sl.size(); i++) {
           Servlet s = (Servlet)sl.get(i);
           System.out.println("servlet-name: "+s.getServletName());
           System.out.println("servlet-class: "+s.getServletClass());
           Vector ip = s.getInitParams();
           for (int j = 0; j < ip.size(); j++) {
               InitParam in = (InitParam)ip.get(j);
               System.out.println("param-name: "+in.getParamName());
               System.out.println("param-value: "+in.getParamValue());
           }
           System.out.println("load-on-startup: "+s.getLoadOnStartup());
       }
       for (int i = 0; i < sm.size(); i++) {
           ServletMapping ser = (ServletMapping)sm.get(i);
           System.out.println("servlet-name: "+ser.getServletName());
           System.out.println("url-pattern: "+ser.getUrlPattern());
       }
       for (int i = 0; i < wfl.size(); i++) {
           WelcomeFileList wf = (WelcomeFileList)wfl.get(i);
           Vector v = wf.getWelcomeFiles();
           for (int j = 0; j < v.size(); j++) {
               System.out.println("welcome-file: "+v.get(i));
           }
       }
       for (int i = 0; i < sc.size(); i++) {
           SecurityConstraint syc = (SecurityConstraint)sc.get(i);
           Vector wrc = syc.getWebResourceCollections();
           Vector ac = syc.getAuthConstraints();
           for (int j = 0; j < wrc.size(); j++) {
               WebResourceCollection wc = (WebResourceCollection)wrc.get(j);
               System.out.println("web-resource-name: "+wc.getWebResourceName());
               Vector up = wc.getUrlPattern();
               for (int k = 0; k < up.size(); k++) {
                   System.out.println("url-pattern: "+up.get(k));
               }
           }
           for (int j = 0; j < ac.size(); j++) {
               AuthConstraint act = (AuthConstraint)ac.get(j);
               Vector de = act.getDescription();
               for (int k = 0; k < de.size(); k++) {
                   System.out.println("description: "+de.get(k));
               }
           }
       }
        }
        catch (IOException e) {
            // TODO 自动生成 catch 块
            e.printStackTrace();
            System.out.println(111);
        }
        catch (SAXException e) {
            // TODO 自动生成 catch 块
            e.printStackTrace();
            System.out.println(222);
        }  
    }
    public static void main(String[] arg){
        ReadWeb w = new ReadWeb();
        w.read();
    }
}
       打印结果如下：
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 

 
qq249923523
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Degister
weixin_41960204的博客
01-06 330
一、Degister 是干嘛的 Digester 被用于完成 xml 解析。Digester 是 Jakarta 子项目 Commons 下的一个模块，支持基于规则的对任意 XML 文档的处理。它最初是 Structs 项目的一部分，后因其通用性而划归 Commons 二、使用 引入 jar 包 <dependency> <groupId>org.apache.commons</groupId> <artifactId>co
Digester简介和使用
leileibest_437147623的专栏
01-13 8411
一、Digester简介                   1、sax简单介绍，对于XML的解析java有很多种实现，如DOM、SAX等，degister就是基于SAX实现，SAX提供了文件读取的底层接口，它是基于事件驱动类型。在解析XML的过程中，元素通过匹配模式(matching pattern)进行识别，比如当扫描到文节点元素(element)开始或者结束这些地方的时候会通知事件处理函数...
XML解析之Degister(新手必看)
tiancorn的专栏
09-13 967
 导读： XML已经成为了我们开发过程中不可缺少的技术。我们可以用它来描述程序的配置，适配不同的数据格式，甚至作为数据库使用。 帮助处理XML的工具很多，它们让我们活得更轻松。Jakarta Commons下的Digester就是一个不错的工具。它提供了一种将XML与Java对象进行映射的方便方法。这么说可能让新手更迷惑，还是举个例子吧！ 我们有这样一个XML文件：  Memos_2004
Tomcat7 源码分析--Degister使用
weixin_41651116的博客
09-26 485
tomcat加载server.xml过程 tomcat启动类是Bootstrap，当启动时会去调用init()方法，在这个方法过程中，会设置Catalina path,通过反射将Catalina给实例化 public void init() throws Exception { // Set Catalina path set...
XML解析之Digester(新手必看)
Senton
03-29 3843
XML已经成为了我们开发过程中不可缺少的技术。我们可以用它来描述程序的配置，适配不同的数据格式，甚至作为数据库使用。帮助处理XML的工具很多，它们让我们活得更轻松。Jakarta Commons下的Digester就是一个不错的工具。它提供了一种将XML与Java对象进行映射的方便方法。这么说可能让新手更迷惑，还是举个例子吧！我们有这样一个XML文件：   "1.0"?>
license.xml
03-02
word文档转pfd所需xml配置
XML
03-17
XML格式
XML_xml_
10-01
XML主要是讲用XML语言编写前台页面的样式设计，这样布局清晰。
Workvisual倍福XML文件
05-23
Workvisual倍福XML文件
XML查看工具
12-20
一款强大的XML查看软件，节点明细，方便查找，适用于超大XML查看
degister相关包
07-31
该包是在采用degister将xml文件解析成java对象时使用的
Dom4j,Degister操作XML的基本应用
mohamode的专栏
07-27 2866
定义及简单介绍是我复制的，代码是自己写的  Dom4J1 Dom4J介绍Dom4j is an easy to use, open source library for working with XML, XPath and XSLT on the Java platform using the Java Collections Framework and with full su
Degister源码解析及在tomcat中的应用
lantian0802的专栏
03-14 1815
上周研究学习了下tomcat的启动过程的源代码，了解了一下tomcat启动所做的事情，有一个地方是用Digester来加载我们conf/server.xml的配置。这个地方研究的不是很深入，只是说了Digester是一个xml引擎，能把对应的xml配置转换成javabean对象，但是这个强大的Digester是怎么工作的呢？在tomcat中又具体是如果操作的呢？这周抽了点时间研究了一下。 1.首
Digester解析xml文件
热门推荐
caihaijiang的专栏
10-16 2万+
刚刚学了一下Digester如何解析xml文件，所以记录下来，方便以后查看。解析XML文档方面有不少的方法，也有不少的工具包可用，这里介绍的是来自Apache Jakarta的Digester，使用其解析XML文件非常方便而不需要过多的关心底层的具体解析过程。 Digester最早出现在Struts中，后来随着Struts的发展以及其的公用性而被提到commens中独自立项，其底层实现的是SAX解析。下面介绍解析xml文件的代码下面是存放地址及编码的xml文件viewcache.xml(片段)：109810
利用Digester实现xml和bean之间的转换（二）
LchinaM的专栏
07-04 2582
Digester框架属于Jakarta Commons，它以规则和模式为基础处理XML文档。与SAX和DOM之类的标准API相比，Digester不涉及太多的细节问题，非常适合于对XML文档进行简单的处理。 比如要解析如下的xml文件 <persons> <person name="tom"> <age>4</age> <address>
Java操作XML的五种方式之DOM
zbwroom的博客
08-24 1426
1、了解XMLXML，即可扩展标记语言（Extensible Markup Language），标准通用标记语言的子集，一种用于标记电子文件使其具有结构性的标记语言。它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 它非常适合万维网传输，提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。它和JSON都是一种数据交换格式。作用：解析XML文档，创建XML文
（原）用nXML-mode编辑xml
Jamsa
12-09 517
最近想用emacs打造一个小型的Java开发环境，Java开发的mode肯定是选jde了，在IBM的网站上有一篇文章介绍了jde的使用文章《使用emacs-jde进行Java开发》需要注意的是ede、eieio、semantic、speedbar都在cedet这个包中，elib还需要单独下载，这里就不再缀述。 做为Java开发环境，一个称手的xml编辑器少不了。网上很多介绍使用psgml-mode...
XML生成Java类代码
zhengshg的博客
03-20 471
最近对接第三方公司接口，对方调用我们http接口是在request的body里传的整个的xml字符串，xml的定义是第三方公司定义的。我接到字符串后要对xml内容解析，解析出自己要的业务数据。之前xml和bean之间的转换都是用JAXB，先定义java bean，然后加上xml注解，然后用JAXB把java对象转为xml，或者把xml转为java对象。 现在的问题是没有这个java bean...
delphi xml
最新发布
11-26
Delphi XML是指使用Delphi编程语言进行XML数据处理的技术和工具。XML是一种标记语言，用于在不同系统之间传输和存储数据。Delphi是一种强大的编程语言，它可以轻松地处理XML数据。 在Delphi中，可以使用内置的XML...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值