Java SAX解析

sax解析 一行一行的解析，针对数据量较大的
dom解析 将整个数据加载，针对数据较小的
 
 sax步骤
1、获得解析工厂 SAXParserFactory
2、工厂获取解析器 SAXParser
3、加载文档Document注册处理器

 

1、首先写一个xml    

person.xml

<?xml version="1.0" encoding="UTF-8"?>
<persons>
    <person>
        <name>至尊宝</name>
        <age>90000</age>
    </person>
    <person>
        <name>紫霞</name>
        <age>10000</age>
    </person>
</persons>

2、Persond类（准备）

Persond.java

package xml;
/*
 * sax解析 一行一行的解析，针对数据量较大的
 * dom解析 将整个数据加载，针对数据较小的
 * 
 * sax步骤
 * 1、获得解析工厂 SAXParserFactory
 * 2、工厂获取解析器 SAXParser
 * 3、加载文档Document注册处理器
 */
public class Persond {
    private String name;
    private int age;
    
    public Persond() {
        
    }
    public Persond(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

3、注册处理器（存储对象）

PersonHandler.java

package xml;

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

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
/*
 * 存储对象
 */
public class PersonHandler extends DefaultHandler {
    private List<Persond> persons;
    private Persond person;
    private String tag;  //记录标签名

    @Override
    public void startDocument() throws SAXException {
//        System.out.println("处理文档开始");
        persons=new ArrayList<Persond>();
    }
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("开始一个元素"+qName);
        if(null!=qName) {
            tag=qName;
        }
        if(null!=qName&&qName.equals("person")) {
            person=new Persond();
        }
    }
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        String str=new String(ch,start,length);
        if(null!=tag&&tag.equals("name")) {
//            System.out.println(new String(ch,start,length));
            //存数据
            person.setName(str);
            
        }else if(null!=tag&&tag.equals("age")) {
            Integer age=Integer.valueOf(str);
            person.setAge(age);
        }
        
    }
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
//        System.out.println("结束一个元素"+qName);
        if(qName.equals("person")) {
            this.persons.add(person);
        }
        tag=null;
    }


    @Override
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("文档处理结束");
    }
    public List<Persond> getPersons() {
        return persons;
    }
    public void setPersons(List<Persond> persons) {
        this.persons = persons;
    }
    
    
}

4、正式解析

ParseDemo01.java

package xml;

import java.io.IOException;
import java.util.List;

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

import org.xml.sax.SAXException;

public class ParseDemo01 {
    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
        //1、获取解析工厂   SAXParserFactory是protect类型，所以用他的静态方法
        SAXParserFactory  factory=SAXParserFactory.newInstance();
        //2、从解析工厂获取解析器
        SAXParser parse=factory.newSAXParser();
        //3、加载文档Document注册处理器
        //4、编写处理器
        PersonHandler handler=new PersonHandler();
        parse.parse(Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("xml/person.xml")
                , handler);
        List<Persond> personds=handler.getPersons();     //得到一个List对象，里面包含两个Persond类型的对象<person1,person2>
        
        for(Persond p:personds) {
            System.out.println(p.getName()+"-->"+p.getAge());
        }
    }
}

打印结果