解析xml文件并且输出（SAX解析器）

本文解析三个xml文件，难度依次增加

文件1：p1.xml

<?xml version="1.0" encoding="UTF-8" ?>
<persons>
    <person>
      <name>张三</name>
      <age>22</age>
   </person>
</persons>

文件2：p2.xml

<?xml version="1.0" encoding="UTF-8" ?>
<persons>
    <person>
      <name>张三</name>
      <age>33</age>
   </person>
   <person>
      <name>李四</name>
      <age>44</age>
   </person>
</persons>

文件3：p3.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
    <servlet>
        <servlet-name>login</servlet-name>
        <servlet-class>cs.cwnu.servlet.LoginServlet
        </servlet-class>
    </servlet>
    <servlet>
        <servlet-name>reg</servlet-name>
        <servlet-class>cs.cwnu.servlet.RegisterServlet
        </servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>login</servlet-name>
        <url-pattern>/login</url-pattern>
        <url-pattern>/g</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>reg</servlet-name>
        <url-pattern>/reg</url-pattern>
    </servlet-mapping>
</web-app>

首先解析文件1

public class XmlTest {

    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
        //SAX解析
        //1、获取解析工厂
        SAXParserFactory factory=SAXParserFactory.newInstance();
        //2、从解析工厂获取解析器
        SAXParser parse =factory.newSAXParser();
        //3、编写处理器
        //4、加载文档 Document 注册处理器
        PHandler handler=new PHandler();
        //5、解析
        parse.parse(Thread.currentThread().getContextClassLoader()
        .getResourceAsStream("cs/cwnu/test/p1.xml")
        ,handler);

    }

}
class PHandler extends DefaultHandler{
    @Override
    public void startDocument() throws SAXException {
        System.out.println("----解析文档开始----");
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        System.out.println(qName+"元素解析开始");
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        String contents = new String(ch,start,length).trim();
        if(contents.length()>0) {
            System.out.println("内容为"+contents);
        }else {
            System.out.println("内容为空");
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        System.out.println(qName+"元素解析结束");
    }
    @Override
    public void endDocument() throws SAXException {
        System.out.println("----解析文档结束----");
    }
}结果展示

----解析文档开始----
persons元素解析开始
内容为空
person元素解析开始
内容为空
name元素解析开始
内容为张三
name元素解析结束
内容为空
age元素解析开始
内容为22
age元素解析结束
内容为空
person元素解析结束
内容为空
内容为空
persons元素解析结束
----解析文档结束----

其次解析文件2

public class XmlTest02 {

    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
        //SAX解析
        //1、获取解析工厂
        SAXParserFactory factory=SAXParserFactory.newInstance();
        //2、从解析工厂获取解析器
        SAXParser parse =factory.newSAXParser();
        //3、编写处理器
        //4、加载文档 Document 注册处理器
        PersonHandler handler=new PersonHandler();
        //5、解析
        parse.parse(Thread.currentThread().getContextClassLoader()
        .getResourceAsStream("cs/cwnu/test/p2.xml")
        ,handler);

        //获取数据
        List<Person> persons = handler.getPersons();
        for(Person p:persons) {
            System.out.println(p.getName()+"-->"+p.getAge());
        }
    }

}
class PersonHandler extends DefaultHandler{
    private List<Person> persons ;
    private Person person ;
    private String tag; //存储操作标签
    @Override
    public void startDocument() throws SAXException {
        persons = new ArrayList<Person>();
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        if(null!=qName) {
            tag = qName; //存储标签名
            if(tag.equals("person")) {
                person = new Person();
            }
        }
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        String contents = new String(ch,start,length).trim();
        if(null!=tag) { //处理了空
            if(tag.equals("name")) {
                person.setName(contents);
            }else if(tag.equals("age")) {
                if(contents.length()>0) {
                    person.setAge(Integer.valueOf(contents));
                }
            }
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        if(null!=qName) {
            if(qName.equals("person")) {
                persons.add(person);
            }
        }
        tag = null; //tag丢弃了
    }
    @Override
    public void endDocument() throws SAXException {
    }

    public List<Person> getPersons() {
        return persons;
    }
}结果为：

张三-->33
李四-->44

最后解析文件3：p3.xml

用户访问的网址不同，会访问不同的Servlet

比如：访问“/login或/g”,用户会跳转到LoginServlet

访问“/reg”,用户会跳转到RegisterServlet

具体代码如下：

创建Entity类用来存放<Servlet>元素的内容

package cs.cwnu.servlet;

//<servlet>
//<servlet-name>login</servlet-name>
//<servlet-class>com.sxt.server.basic.servlet.LoginServlet
//</servlet-class>
//</servlet>

public class Entity {
    private String name;
    private String clz;
    public Entity(){

    }
    /**
     * @param name
     * @param clz
     */
    public Entity(String name, String clz) {
        super();
        this.name = name;
        this.clz = clz;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getClz() {
        return clz;
    }
    public void setClz(String clz) {
        this.clz = clz;
    }

}

创建Mapping类来存放<ServletMapping>元素的内容

package cs.cwnu.servlet;

import java.util.HashSet;
import java.util.Set;
//<servlet-mapping>
//<servlet-name>login</servlet-name>
//<url-pattern>/login</url-pattern>
//<url-pattern>/g</url-pattern>
//</servlet-mapping>
public class Mapping {
    private String name;
    private Set<String> patterns;
    /**
     * @param name
     * @param patterns
     */
    public Mapping() {
        patterns = new HashSet<String>();
    }
    public Mapping(String name, Set<String> patterns) {
        super();
        this.name = name;
        this.patterns = patterns;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<String> getPatterns() {
        return patterns;
    }
    public void setPatterns(Set<String> patterns) {
        this.patterns = patterns;
    }
    public void addPattern(String pattern){
        this.patterns.add(pattern);
    }
}

创建Servlet接口

package cs.cwnu.servlet;

public interface Servlet {
    void service();
}

创建LoginServlet实现Servlet类

package cs.cwnu.servlet;

public class LoginServlet implements Servlet {

    @Override
    public void service() {
        System.out.println("LoginServlet");
    }

}

创建RegisterServlet实现Servlet类

package cs.cwnu.servlet;

public class RegisterServlet implements Servlet {

    @Override
    public void service() {
        System.out.println("RegisterServlet");
    }

}

创建WebContext类，功能是用户输入url通过匹配<servlet-mapping>中的<url-pattern>的值，找到同级<servlet-name>的值，再找到与<servlet>中<servlet-name>值相同且同级的<servlet-class>的值，即找到Servlet类

package cs.cwnu.servlet;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class WebContext {
    private List<Entity> entitys=null;
    private List<Mapping> mappings=null;
    //key:servlet-name,value:servlet-class
    private Map<String,String> entityMap = new HashMap<String,String>();
    //key:url-pattern,value:servlet-name
    private Map<String,String> mappingMap = new HashMap<String,String>();

    /**
     * @param entitys
     * @param mappings
     */
    public WebContext(List<Entity> entitys, List<Mapping> mappings) {
        super();
        this.entitys = entitys;
        this.mappings = mappings;
        for (Entity entity : entitys) {
            entityMap.put(entity.getName(), entity.getClz());
        }
        for (Mapping mapping : mappings) {
            for(String pattern:mapping.getPatterns()){
                mappingMap.put(pattern, mapping.getName());
            }
        }
    }
    public String getClz(String pattern){
        String name = mappingMap.get(pattern);
        String clas = entityMap.get(name);
        return clas;
    }
}

测试代码：

package cs.cwnu.servlet;

import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class XmlTest01 {

    public static void main(String[] args) throws Exception{
        // SAX解析
        // 1、获取解析工厂
        SAXParserFactory factory = SAXParserFactory.newInstance();
        // 2、从解析工厂获取解析器
        SAXParser parse = factory.newSAXParser();
        // 3、编写处理器
        // 4、加载文档 Document 注册处理器
        WebHandler handler = new WebHandler();
        // 5、解析
        parse.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("cs/cwnu/servlet/web.xml"), handler);
        List<Entity> entitys = handler.getEntitys();
        List<Mapping> mappings = handler.getMappings();
        WebContext wb = new WebContext(entitys, mappings);

        //假设登录
        //String name = wb.getClz("/login");输出LoginServlet
        String name = wb.getClz("/g");
        //String name = wb.getClz("/reg");输出RegisterServlet
        Class clazz = Class.forName(name);
        Servlet servlet = (Servlet)clazz.getConstructor().newInstance();
        servlet.service();
    }

}

class WebHandler extends DefaultHandler {
    private List<Entity> entitys;
    private List<Mapping> mappings;
    private Entity entity;
    private Mapping mapping;
    private String tag;
    private boolean isMapping = false;

    @Override
    public void startDocument() throws SAXException {
        entitys = new ArrayList<Entity>();
        mappings = new ArrayList<Mapping>();
    }

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        if (null != qName) {
            tag = qName;
            if (tag.equals("servlet")) {
                entity = new Entity();
                isMapping = false;
            } else if (tag.equals("servlet-mapping")) {
                mapping = new Mapping();
                isMapping = true;
            }
        }
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        String contents = new String(ch, start, length).trim();
        if (null != tag) {
            if (isMapping) {
                if (tag.equals("servlet-name")) {
                    mapping.setName(contents);
                } else if (tag.equals("url-pattern")) {
                    mapping.addPattern(contents);
                }
            } else {
                if (tag.equals("servlet-name")) {
                    entity.setName(contents);
                } else if (tag.equals("servlet-class")) {
                    entity.setClz(contents);
                }
            }

        }

    }

    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        if (null != qName) {
            if (qName.equals("servlet")) {
                entitys.add(entity);
            } else if (qName.equals("servlet-mapping")) {
                mappings.add(mapping);
            }

        }
        tag = null;

    }

    @Override
    public void endDocument() throws SAXException {
    }

    public List<Entity> getEntitys() {
        return entitys;
    }

    public List<Mapping> getMappings() {
        return mappings;
    }

}

测试结果：LoginServlet

原文地址：https://www.cnblogs.com/5aixin/p/11100564.html

时间： 2024-10-10 07:54:56

解析xml文件并且输出（SAX解析器）的相关文章

【Android进阶】解析XML文件之使用DOM解析器

在前面的文章中,介绍了使用SAX解析器对XML文件进行解析,SAX解析器的优点就是占用内存小.这篇文章主要介绍使用DOM解析器对XML文件进行解析.DOM解析器的优点可能是理解起来比较的直观,当然,每个人对不同的解析方法可能有不同的喜好.但是DOM解析器有个比较大的缺点,就是占用内存比较多,在Android中的XML解析中,还是更推荐其他的解析方式. 下面介绍使用DOM解析器对XML进行解析. 下面是我们需要解析的xml文件 <?xml version="1.0" encodin

java解析xml文件并输出

使用java解析xml文件,通过dom4j,代码运行前需先导入dom4j架包. ParseXml类代码如下: import java.io.File; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import org.dom4j.Document; import org.dom4j.Element; import org.dom4j.io.SAXReader; public class

Java:简单的解析XML文件之使用DOM解析

XML简介 要理解XML,HTML等格式,先来理解文档对象模型DOM 根据 DOM,HTML 文档中的每个成分都是一个节点,这些节点组成了一棵树.DOM 是这样规定的:整个文档是一个文档节点每个 HTML 标签是一个元素节点包含在 HTML 元素中的文本是文本节点每一个 HTML 属性是一个属性节点注释属于注释节点 节点彼此都有等级关系.HTML 文档中的所有节点组成了一个文档树(或节点树).HTML 文档中的每个元素.属性.文本等都代表着树中的一个节点.树起始于文档节点,并由此继续伸出枝条,直

解析XML文件之使用SAM解析器

XML是一种常见的传输数据方式,所以在开发中,我们会遇到对XML文件进行解析的时候,本篇主要介绍使用SAM解析器,对XML文件进行解析. SAX解析器的长处是显而易见的,那就是SAX并不须要将全部的文档都载入内存之后才进行解析.SAX是事件驱动机制的,也就是碰到元素节点.文本节点.文档节点的时候,都会触发一定的事件.我们仅仅须要在对应的回调事件里面进行对应的处理就能够了.由于这个特点,所以SAX解析占用的内存比較少.其它的解析方式,比方下一节要介绍的DOM解析器,则占用内存比較多.在解析比較小的

Python解析xml文件遇到的编码解析的问题

使用python对xml文件进行解析的时候,如果xml文件的头文件是utf-8格式的编码,那么解析是ok的,但如果是其他格式将会出现如下异常: xml.parsers.expat.ExpatError: unknown encoding 因此,为了保证程序的正常运行,我们需要对读取的文件进行编码处理. 1.首先将读取的字符从原来的编码解析,并编码成utf-8: 2.修改xml的encoding: 代码如下: import sys import os import datetime import

XML文件解析【安卓7】——SAX解析

XML文件解析 XML解析:XML技术是Android平台的应用基础,  Android提供了多种解析XML的方式:SAX解析.DOM解析.PULL解析 SAX解析 SAX --Simple  API  forXML  (XML简单的API) --解析速度快.占用内存少 --提供一组简单的API用于解析XML文件 --SAX在解析XML文件前,先指定一个解析事件处理器(Handler),SAX会对XML文档进行简单的顺序扫描,当扫描到[文档(Document)的开始和结束.元素(Element)

javaweb学习总结十二(JAXP对XML文档进行SAX解析)

一:JAXP使用SAX方式解析XML文件 1:dom解析与sax解析异同点 2:sax解析特点 二:代码案例 1:xml文件 1 <?xml version="1.0" encoding="UTF-8" standalone="no"?> 2 <students> 3 <student> 4 <name sid="111">李四</name> 5 <age>

Android解析XML文件

前言 在学习Android的Framework层源码时,Android大量的使用XmlPullParser来解析xml文件的源码.因此,这里也顺道介绍一下XmlPullParser的使用. XML XML(eXtensible Markup Language)中文名为可扩展标记语言.标记指计算机所能理解的信息符号,通过此种标记,计算机之间可以处理包含各种信息的文章等. 用途 XML设计用了传送及携带数据信息,不用了表现或展示数据,HTML语言则用了表现数据,所以XML用途的焦点是它说明数据是什么

使用DOM解析器解析XML文件 学习笔记

dom解析和dom4j原理一致 Node是所有元素的父接口 常用的API: DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();取得DOM解析器工厂 DocumentBuilder domParser = factory.newDocumentBuilder();取得DOM解析器 domParser.parse(*.xml)加载需要解析的XML文件 Document.getDocumentElement()取