mybatis源码解析二之(xml解析器dom和sax)

最新推荐文章于 2022-09-17 17:55:40 发布
最新推荐文章于 2022-09-17 17:55:40 发布
阅读量283 收藏
点赞数
分类专栏： mybatis源码解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nuan_Feng/article/details/105854087
版权

dom

<?xml version="1.0" encoding="UTF-8" standalone="no"?><exam>
    <Student examid="22" idcard="01">
        <name value="zhangsan">张三</name>
        <location>湖北</location>
        <grade>89</grade>
    </Student>
    
</exam>

package org.example.dom;

import lombok.Data;

@Data
public class Student {
private String idcard;
private String examid;
private String name;
private String location;
private double grade;




}


package org.example.dom;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;



public class StudentDao {
	public void add(Student s) {
		// 这里的异常不能抛，会给上一层造成影响。捕捉异常后，还要通知上一层，转换成运行时期异常。
		// 转换后，上一层可处理可不处理。既没有给上一层带来麻烦，同时也告诉上一层我这里出错了。
		try {
			Document document = XmlUtils.getDocument();
			Element student_tag = document.createElement("Student");

			// 创建Student节点，并赋值和属性。
			Element name = document.createElement("name");
			Element location = document.createElement("location");
			Element grade = document.createElement("grade");
			name.setTextContent(s.getName());
			location.setTextContent(s.getLocation());
			grade.setTextContent(s.getGrade() + "");

			student_tag.setAttribute("idcard", s.getIdcard());
			student_tag.setAttribute("examid", s.getExamid());
			student_tag.appendChild(name);
			student_tag.appendChild(location);
			student_tag.appendChild(grade);

			// 更新的数据挂到文档
			document.getElementsByTagName("exam").item(0)
					.appendChild(student_tag);

			// 更新内存
			XmlUtils.writeXml(document);

		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public Student find(String examid) {
		try {
			Document document = XmlUtils.getDocument();

			// 获取所有examid的信息
			NodeList node = document.getElementsByTagName("Student");
			for (int i = 0; i < node.getLength(); i++) {
				Element parentNode=	(Element) node.item(i);
			String id=parentNode.getAttribute("examid");
				if (id.equals(examid)) {
					Student s = new Student();
					s.setExamid(examid);
					s.setIdcard(parentNode.getAttribute("idcard"));
					s.setName(parentNode.getElementsByTagName("name").item(0)
							.getTextContent());
					s.setLocation(parentNode.getElementsByTagName("location")
							.item(0).getTextContent());
					s.setGrade(Double.parseDouble(parentNode
							.getElementsByTagName("grade").item(0)
							.getTextContent()));

					return s;

				}

			}
			return null;

		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	public void delete(String name) throws StudentNotExistException {
		try {
			Document document = XmlUtils.getDocument();

			// 获取所有examid的信息
			NodeList list = document.getElementsByTagName("name");
			for(int i=0;i<list.getLength();i++){
				if(list.item(i).getTextContent().equals(name)){
					list.item(i).getParentNode().getParentNode().removeChild(list.item(i).getParentNode());
					// 更新内存
					XmlUtils.writeXml(document);
//					通过则返回
					return;
				}

				
			}
//			不通过，提示删除失败，因为不能乱改签名，所以需要返回一个异常提示用户，运行时期异常容易省略，所以编译时期异常，出错必须要显示控制台。
//			自定义一个异常友好的提示用户,抛出个学生不存在异常
			throw new StudentNotExistException(name+"不存在");
//			因为与下面的异常有冲突，所以在catch一个异常
			

		} 
		catch (StudentNotExistException e) {
			throw e;
		}catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

}


package org.example.dom;


public class StudentNotExistException extends Exception {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public StudentNotExistException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public StudentNotExistException(String message, Throwable cause,
			boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public StudentNotExistException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public StudentNotExistException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public StudentNotExistException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}

}


package org.example.dom;

import java.io.File;
import java.io.FileOutputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;

public class XmlUtils {
	private static String filename = "E:\\workspace\\my\\spring\\mybatisParse\\src\\main\\java\\org\\example\\dom\\exam.xml";

	public static Document getDocument() throws Exception {
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		DocumentBuilder builder = factory.newDocumentBuilder();
		return builder.parse("file:///"+filename);
	}
	
	public static void writeXml(Document document) throws Exception{
		TransformerFactory factory=TransformerFactory.newInstance();
		Transformer tf=factory.newTransformer();
		tf.transform(new DOMSource(document), new StreamResult(new FileOutputStream(filename)));
	}
}


package org.example.dom;

import org.w3c.dom.NodeList;

import javax.xml.xpath.*;


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

        XPathFactory xPathFactory = XPathFactory.newInstance();
        XPath xPath = xPathFactory.newXPath();
        XPathExpression compile = xPath.compile("//name[@value="+"zhangsan"+"]");
        NodeList result =(NodeList) compile.evaluate(XmlUtils.getDocument(), XPathConstants.NODESET);

    }
}

dom4j

<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT 书架 (书+)>
<!ELEMENT 书 (书名,作者,售价)>
<!ELEMENT 书名 (#PCDATA)>
<!ELEMENT 作者 (#PCDATA)>
<!ELEMENT 售价 (#PCDATA)>


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE 书架 SYSTEM "book.dtd">

<书架>
  <书>
    <书名 name="yyy">javaee</书名>
    <作者>老王</作者>
    <售价>120元</售价>
  </书>
  <书>
    <书名 name="xxx">javase</书名>
    <作者>老张</作者>
    <售价>15</售价>
  </书>
</书架>


package dom4j;

import java.io.FileOutputStream;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;

public class Demo1 {

	// 获取第二本书的书名
	@Test
	public void read() throws DocumentException {
		// 获得解析器
		SAXReader reader = new SAXReader();
		// 获得document
		// Document document = reader.read(new File("src/book.xml"));
		Document document = reader.read("src/book.xml");
		// 获得根节点
		Element root = document.getRootElement();

		// 获得Element
		// root.element("书"); 得到第2本书
		Element book = (Element) root.elements("书").get(1);

		// 获取第二本书的名字
		String value = book.element("书名").getText();
		System.out.println(value);
	}

	// 获取第二本书的属性
	@Test
	public void readAttr() throws DocumentException {
		// 获得解析器
		SAXReader reader = new SAXReader();
		// 获得document
		Document document = reader.read("src/book.xml");
		// 获得根节点
		Element root = document.getRootElement();

		// 获得Element
		// root.element("书"); 得到第2本书
		Element book = (Element) root.elements("书").get(1);

		// 获取第二本书的名字
		// String value = book.element("书名").attribute("name").getValue();
		String value = book.element("书名").attributeValue("name");
		System.out.println(value);
	}

	// 在第一本书上添加售价
	@Test
	public void add() throws Exception {
		SAXReader reader = new SAXReader();
		Document document = reader.read("src/book.xml");
		Element book = document.getRootElement().element("书");
		// 添加节点
		book.addElement("售价").setText("107元");


		// 写入XML文档中
		// XMLWriter write=new XMLWriter(new OutputStreamWriter(new
		// FileOutputStream("src/book.xml"),"UTF-8"));

		// XMLWriter write = new XMLWriter(new FileWriter("src/book.xml"));
		// //本地编码 gb2312
		// write.write(document);//UTF-8
		// write.close();

		// 使用输出格式
		// 漂亮排版的格式
		// OutputFormat format = OutputFormat.createPrettyPrint();
		// 紧凑排版的格式
		OutputFormat format = OutputFormat.createCompactFormat();
		format.setEncoding("gb2312");
		// XMLWriter write = new XMLWriter(new
		// FileWriter("src/book.xml"),format); //本地编码 gb2312

		// 1：表示写入到哪里（默认gb2312编码）。2：编码
		// XMLWriter write = new XMLWriter(new OutputStreamWriter(
		// new FileOutputStream("src/book.xml"), "gb2312"), format);

		// 推荐字节流
		XMLWriter write = new XMLWriter(new FileOutputStream("src/book.xml"),
				format);

		write.write(document);// 上面设置编码后，document编码为gb2312
		write.close();

		// 结论，字符流的话，会默认采用系统默认的gb2312编码，需要手设置。字节流则不会，会使用输出格式使用的编码
	}

	// 在第二本书的指定位置上添加一个新的售价,更改了所有孩子的list集合的顺序
	@Test
	@SuppressWarnings("unchecked")
	public void add1() throws Exception {
		SAXReader reader = new SAXReader();
		Document document = reader.read("src/book.xml");
		// 获取第二本书
		Element book = (Element) document.getRootElement().elements("书").get(1);
		// 第二本书的节点以list显示

		List<Element> list = book.elements(); // 书名，作者，售价
		// 创建售价节点
		Element price = DocumentHelper.createElement("售价");
		price.setText("122元");

		// 售价节点添加到list中
		list.add(2, price);

		OutputFormat format = OutputFormat.createPrettyPrint();
		format.setEncoding("UTF-8");
		XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),
				format);
		writer.write(document);
		writer.close();
	}

	@Test
	public void delete() throws Exception {
		SAXReader reader = new SAXReader();
		Document document = reader.read("src/book.xml");

		Element element = (Element) document.getRootElement().elements("书")
				.get(1);
		Element price = (Element) element.elements("售价").get(1);
		price.getParent().remove(price);

		OutputFormat format = OutputFormat.createPrettyPrint();
		format.setEncoding("UTF-8");
		XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),
				format);
		writer.write(document);
		writer.close();

	}

	@Test
	public void update() throws Exception {
		SAXReader reader = new SAXReader();
		Document document = reader.read("src/book.xml");

		Element element = (Element) document.getRootElement().elements("书")
				.get(1);
		Element price = (Element) element.elements("售价").get(0);
		price.setText("15");

		OutputFormat format = OutputFormat.createPrettyPrint();
		format.setEncoding("UTF-8");
		XMLWriter writer = new XMLWriter(new FileOutputStream("src/book.xml"),
				format);
		writer.write(document);
		writer.close();

	}

}


<?xml version="1.0" encoding="UTF-8"?>
<users>
	<user id="1" username="aaa" passwork="123" email="a@sina.com" >用户一</user>
	<user id="2" username="abb" passwork="132" email="b@sina.com" />
	<user id="3" username="bbb" passwork="312" email="c@sina.com" />
</users>

package org.example.dom4j;

import org.dom4j.Document;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
import org.w3c.dom.NodeList;

import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathFactory;

public class UsersXpathDemo {
	public static void main(String[] args) throws Exception {
		String  username="aaa";
		String passwork="123";
		SAXReader reader=new SAXReader();
		Document document=reader.read("E:/workspace/my/spring/mybatisParse/src/main/java/org/example/dom4j/users.xml");



		Node node=document.selectSingleNode("//user[@username='"+username+"' and @passwork='"+passwork+"']");
		System.out.println(node.getText());
		if(node==null){
			System.out.println("输入错误");
		}
		else{
			System.out.println("登陆成功");
		}

	}
}

jaxp-dom

<?xml version="1.0" encoding="UTF-8"?>
<!ELEMENT 书架 (书+)>
<!ELEMENT 书 (书名,作者,售价)>
<!ELEMENT 书名 (#PCDATA)>
<!ELEMENT 作者 (#PCDATA)>
<!ELEMENT 售价 (#PCDATA)>


<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE 书架 SYSTEM "book.dtd">
<书架>
	<书>
		<书名 name="yyy"> javaee</书名>
		<作者> 老王 </作者>
		<售价>120元</售价>
	</书>
	<书>
		<书名 name="xxx"> javase</书名>
		<作者> 老张 </作者>
		<售价>128元</售价>
	</书>
</书架>

package org.example.jaxp.dom;

import java.io.FileOutputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class Demo {
    // 读取XML文档中：<书名>Java</书名> 节点中的值
    @Test
    public void read() throws Exception {
        // 创建工厂
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        // 得到dom解析器
        DocumentBuilder buider = factory.newDocumentBuilder();
        // 解析xml文件，得到代表文档的document
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        // 得到标签内容
        NodeList list = document.getElementsByTagName("书名");
        // 利用索引获取书名
        Node node = list.item(0);
        // 获取内容
        String Content = node.getTextContent();
        System.out.println(Content);
    }

    // 得到XML文档中所有标签
    @Test
    public void read1() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        // 得到根节点
        Node root = document.getElementsByTagName("书架").item(0);
        list(root);

    }

    private void list(Node node) {
        // 判断是不是Element
        //node.getNodeType()==Node.ELEMENT_NODE
        if (node instanceof Element) {
            // 输出节点名
            System.out.println(node.getNodeName());
        }
        // 得到所有子节点
        NodeList list = node.getChildNodes();
        for (int i = 0; i < list.getLength(); i++) {
            Node child = list.item(i);
            list(child);
        }

    }

    // 得到XML文档中标签属性的值
    @Test
    public void read2() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        // 得到根节点 (强转原因：子类拥有比父类更多的方法)
        Element bookName = (Element) document.getElementsByTagName("书名")
                .item(0);
        // 获取指定name属性的值
        String value = bookName.getAttribute("name");
        System.out.println(value);
    }

    // XML文档添加 节点<售价>888</售价>
    @Test
    public void add() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        // 文档创建标签
        Element price = document.createElement("售价");
        // 标签添加内容
        price.setTextContent("18.5元");

        // 把创建的节点挂到第一本书上
        Element book = (Element) document.getElementsByTagName("书").item(0);
        book.appendChild(price);

        // 把更新后内存写回到xml文档中
        TransformerFactory tfffactory = TransformerFactory.newInstance();
        Transformer tf = tfffactory.newTransformer();
        // 将 document 转换为 book.xml
        tf.transform(new DOMSource(document), new StreamResult(
                new FileOutputStream("src/main/java/org/example/jaxp/dom/book.xml")));
    }

    // XML文件指定位置添加节点
    @Test
    public void add1() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        // 文档创建标签
        Element price = document.createElement("售价");
        // 标签添加内容
        price.setTextContent("18.5元");

        // 得到参考节点（就是放在这个节点下）
        Element refNode = (Element) document.getElementsByTagName("售价").item(0);

        // 把创建的节点挂到第一本书上
        Element book = (Element) document.getElementsByTagName("书").item(0);

        // Node insertBefore(Node newChild,在现有子节点 refChild 之前插入节点 newChild。
        book.insertBefore(price, refNode);

        TransformerFactory tfffactory = TransformerFactory.newInstance();
        Transformer tf = tfffactory.newTransformer();
        tf.transform(new DOMSource(document), new StreamResult(
                new FileOutputStream("src/main/java/org/example/jaxp/dom/book.xml")));
    }

    // XML文档节点上添加属性
    @Test
    public void addAtt() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        Element book = (Element) document.getElementsByTagName("书名").item(0);
        book.setAttribute("name", "xxx");

        TransformerFactory tfffactory = TransformerFactory.newInstance();
        Transformer tf = tfffactory.newTransformer();
        tf.transform(new DOMSource(document), new StreamResult(
                new FileOutputStream("src/main/java/org/example/jaxp/dom/book.xml")));
    }

    // 删除指定节点
    @Test
    public void delete() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        // 获取要删除的节点
        Element e = (Element) document.getElementsByTagName("售价").item(0);

        // 获取要删除节点的父类
        Element books = (Element) document.getElementsByTagName("书").item(0);

        // 父类删除指定节点
        books.removeChild(e);

        TransformerFactory tfffactory = TransformerFactory.newInstance();
        Transformer tf = tfffactory.newTransformer();
        tf.transform(new DOMSource(document), new StreamResult(
                new FileOutputStream("src/main/java/org/example/jaxp/dom/book.xml")));
    }

    // 删除指定节点
    @Test
    public void delete1() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        // 获取要删除的节点
        Element e = (Element) document.getElementsByTagName("售价").item(0);
        // 获取节点的父类然后删除当前节点
        e.getParentNode().removeChild(e);

        TransformerFactory tfffactory = TransformerFactory.newInstance();
        Transformer tf = tfffactory.newTransformer();
        tf.transform(new DOMSource(document), new StreamResult(
                new FileOutputStream("src/main/java/org/example/jaxp/dom/book.xml")));
    }

    // 删除所有XML文档
    @Test
    public void delete2() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        // 获取要删除的节点
        Element e = (Element) document.getElementsByTagName("售价").item(0);
//		e.removeAttribute("name"); 删除属性
        // 获取节点的父类然后删除当前节点
        e.getParentNode().getParentNode().getParentNode()
                .removeChild(e.getParentNode().getParentNode());

//回写，把内存中的更新信息回写到xml中
        TransformerFactory tfffactory = TransformerFactory.newInstance();
        Transformer tf = tfffactory.newTransformer();
        tf.transform(new DOMSource(document), new StreamResult(
                new FileOutputStream("src/main/java/org/example/jaxp/dom/book.xml")));
    }

    //	更新价格
    @Test
    public void update() throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder buider = factory.newDocumentBuilder();
        Document document = buider.parse("src/main/java/org/example/jaxp/dom/book.xml");

        Element e = (Element) document.getElementsByTagName("售价").item(0);
//		更新数据
        e.setTextContent("18.88元");

        //回写，把内存中的更新信息回写到xml中
        TransformerFactory tfffactory = TransformerFactory.newInstance();
        Transformer tf = tfffactory.newTransformer();
        //参数1：数据源，2：路径
        tf.transform(new DOMSource(document), new StreamResult(
                new FileOutputStream("src/main/java/org/example/jaxp/dom/book.xml")));
    }
}

jaxp-sax

package org.example.jaxp.sax;

import lombok.Data;

@Data
public class Book {
	private String bookName;
	private String author;
	private String Price;

	public String getBookName() {
		return bookName;
	}

	public void setBookName(String bookName) {
		this.bookName = bookName;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public String getPrice() {
		return Price;
	}

	public void setPrice(String price) {
		Price = price;
	}

}


package org.example.jaxp.sax;

import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

public class Demo1 {
	public static void main(String[] args) throws ParserConfigurationException,
			SAXException, IOException {
		// 1:创建解析工厂
		SAXParserFactory factry = SAXParserFactory.newInstance();
		// 2：得到解析器
		SAXParser sp = factry.newSAXParser();
		// 3：得到读取器
		XMLReader reader = sp.getXMLReader();
		// 4：设置内容处理器
		reader.setContentHandler(new ListHarder());
		// 5：获取xml文档内容
		reader.parse("E:/workspace/my/spring/mybatisParse/src/main/java/org/example/jaxp/dom/book.xml");
	}

}
//得到XML文档所有内容
class ListHarder implements ContentHandler {
	@Override
	public void startElement(String uri, String localName, String qName,
							 Attributes atts) throws SAXException {
		System.out.println("<" + qName + ">");
//		防止atts属性为空，报空值异常，添加条件判断
		for(int i=0;atts!=null&&i<atts.getLength();i++){
//			获取属性name
			String attsName=atts.getQName(i);
//			获取属性值
			String attsValue=atts.getValue(i);
			System.out.println(attsName+" "+attsValue);
		}

	}
	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		System.out.println(new String(ch, start, length));

	}
	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {

		System.out.println("</" + qName + ">");
	}


	@Override
	public void setDocumentLocator(Locator locator) {
		// TODO Auto-generated method stub

	}

	@Override
	public void startDocument() throws SAXException {

	}

	@Override
	public void endDocument() throws SAXException {
		// TODO Auto-generated method stub

	}

	@Override
	public void startPrefixMapping(String prefix, String uri)
			throws SAXException {
		// TODO Auto-generated method stub

	}

	@Override
	public void endPrefixMapping(String prefix) throws SAXException {
		// TODO Auto-generated method stub

	}



	@Override
	public void ignorableWhitespace(char[] ch, int start, int length)
			throws SAXException {
		// TODO Auto-generated method stub

	}

	@Override
	public void processingInstruction(String target, String data)
			throws SAXException {
		// TODO Auto-generated method stub

	}

	@Override
	public void skippedEntity(String name) throws SAXException {
		// TODO Auto-generated method stub

	}

}



package org.example.jaxp.sax;

import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;

public class Demo2 {
	public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
		// 1: 创建解析工厂
		SAXParserFactory factry = SAXParserFactory.newInstance();
		// 2：得到解析器
		SAXParser sp = factry.newSAXParser();
		// 3：得到读取器
		XMLReader reader = sp.getXMLReader();
		// 4：设置内容处理器
		reader.setContentHandler(new TagValueHandler());
		// 5：获取xml文档内容
		reader.parse("E:/workspace/my/spring/mybatisParse/src/main/java/org/example/jaxp/dom/book.xml");
	}
}


//获取作者标签第二个对应的值
class  TagValueHandler extends DefaultHandler{
	private String currentTag; //记住当前解析的是什么标签
	private int needNumver=1;//记住想获取第几个作者标签的值
	private int currentNumber;  //当前解析到的是第几个

	@Override
	public void startElement(String uri, String localName, String qName,
							 Attributes attributes) throws SAXException {
		currentTag=qName;
		if(currentTag.equals("作者")){
			currentNumber++;
		}

	}
	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		if(currentTag.equals("作者")&&currentNumber==needNumver){
			System.out.println(new String(ch,start,length));
		}

	}
	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {

		currentTag=null;
	}







}


package org.example.jaxp.sax;

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

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

import org.example.jaxp.sax.Book;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;

public class Demo3 {
	public static void main(String[] args) throws ParserConfigurationException,
			SAXException, IOException {

		SAXParserFactory factry = SAXParserFactory.newInstance();

		SAXParser sp = factry.newSAXParser();

		XMLReader reader = sp.getXMLReader();

		BeanListHandler br = new BeanListHandler();
		reader.setContentHandler(br);

		reader.parse("E:/workspace/my/spring/mybatisParse/src/main/java/org/example/jaxp/dom/book.xml");
		List<Book> book=br.getList();
		book.forEach(k-> System.out.println(k.toString()));
	}
}

//把xml文档中的每一本书封装到book对象中，并将多个book对象封装到list集合中返回
class BeanListHandler extends DefaultHandler {
	private String currentTag; // 记住当前解析的是什么标签
	private List<Book> list = new ArrayList<Book>();
	private Book book;

	public List<Book> getList() {
		return list;
	}
	@Override
	public void startElement(String uri, String localName, String qName,
							 Attributes attributes) throws SAXException {
		currentTag=qName;
		if("书".equals(currentTag)){
			book=new Book();
		}
	}

	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		if("书名".equals(currentTag)){
			String bookName=new String(ch,start,length);
			book.setBookName(bookName);
		}
		if("作者".equals(currentTag)){
			String author=new String(ch,start,length);
			book.setAuthor(author);
		}
		if("售价".equals(currentTag)){
			String price=new String(ch,start,length);
			book.setPrice(price);
		}

	}
	@Override
	public void endElement(String uri, String localName, String qName)
			throws SAXException {
		if("书".equals(qName)){
			list.add(book);
			book=null;
		}
//		currentTag不设置为null的话，空指针异常
		currentTag=null;
	}

}
Nuan_Feng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《手写Mybatis》第4章：Mapper XML的解析和注册使用.doc
07-10
1. 使用SqlSessionFactoryBuilder读取Mapper XML文件，这通常涉及DOM或SAX解析器，将XML文档转换为内存中的数据结构。 2. 解析XML文件，提取出Mapper接口名称、SQL语句、参数和结果映射等信息。 3. 创建...
Mybatis 处理器Handler分类及介绍
landywu1985的博客
06-22 3276
Handler分类及介绍处理器定位ParameterHandlerResultSetHandlerStatementHandler二级目录三级目录 处理器定位 前面我们分析过Mybatis的Executor，其实执行器还是调用StatementHandler来执行数据库操作。Mybatis中有3种类型的hanlder，分别为StatementHandler、ParameterHandler、ResultSetHandler。ParameterHandler主要解析参数，为Statement设置参数，Resu
mybatis源码-解析配置文件（一）之XML的DOM解析方式
09-15 228
目录 简介 Java 中 XML 文件解析 解析方式 DOM 解析 XML 新建 XML 文件 DOM 操作相关类 Java 读取 XML 文件 一起学 mybatis ...
DOM解析XML之mybatis逆向工程框架解读
气自华
12-30 1100
XML 概念 Xml可扩展的标记语言 XML与html区别 1、  Html的所有标记是固定的，不允许程序员新增，而xml语言可允许程序员任意的新增自己的标签，没有自己固定的标签； 2、  Html可以将数据和格式综合编写，然而xml语言则只能放入一定逻辑规则的数据； Java 解析XML文档方案 应用程序 API
使用dom4j解析mybatis核心配置文件、SqlMapper配置文件_学习笔记
滨海之君的博客
09-17 350
dom4j解析文件
mybatis源码解析三之(xml解析器dom和sax)5
Nuan_Feng的博客
05-13 193
xpath解析xml public class XPathParser { private final Document document; //是否开启验证 private boolean validation; //加载本地DTD private EntityResolver entityResolver; //Properties标签定义值 private Pr...
mybatis-3.4.1源码
10-29
5. **XML映射文件解析**: MyBatis通过Dom4J或SAX解析XML配置文件，提取出SQL语句、结果映射、参数映射等信息。这些信息被加载到Configuration中。 6. **动态SQL**: MyBatis允许在XML映射文件或注解中编写动态SQL，...
java 解析xml类映射数据库 数据库操作 反射机制 源码
04-07
首先，XML解析在Java中通常有两种方式：DOM（Document Object Model）和SAX（Simple API for XML）。DOM解析器会将整个XML文档加载到内存中，形成一个树形结构，方便遍历和查找，适合小规模的XML文件。SAX解析器则...
根据mybatis/ibatis sqlmapper文件解析生成数据库表
12-02
在解析SQL映射文件时，`Sqlmap2Table.java` 可能会使用DOM（Document Object Model）或SAX（Simple API for XML）等XML解析库。它可能首先寻找`<insert>`、`<update>`、`<select>`和`<delete>`等标签，这些是MyBatis...
MybatisGenerator源码
12-31
解析XML配置文件的过程涉及到Java的DOM或SAX解析技术，以及对MybatisGenerator特定元素的理解。 2. **数据库交互**：通过JDBC API，MybatisGenerator与数据库进行交互，获取表信息，包括表名、字段名、字段类型等。...
netexam在线考试
06-14
b/s架构的考试系统，适合毕业设计 测试平台采用了B/S体系结构和数据中间件技术，实现了网络环境下的大规模实时出题、阅卷等内容
mybatis源码解析一 xml解析（解析器）
lpy的专栏
04-18 2276
最近闲来无事，看着一些源码类的书籍，只是光看，好像并不能给自己很好的益处，无法记下来，所以就有了这个Mybatis源码解析系列的博客。网上也有大量的源码解析，在此记录有两个原因，一是为了加深自己的印象，二来则是让广大读者朋友能及时纠正在下的一些理解的错误。如果各位发现有任何的错误，请留言指出，在此感激不尽。闲话不多说，这就开始我们的第一篇xml解析。 首先，本博客系列的图、代码...
Mybatis工作机制源码分析—初始化—sax解析
探索java技术、web技术
01-05 803
本文以解析Mybatis config配置文件中"/configuration"元素为例进行说明Mybatis是如何进行sax解析工作的。 Mybatis配置文件解析流程图 时序图 相关源码 /** XMLConfigBuilder.java */ // 以解析Mybatis config配置文件"/configuration"元素为例说明sax解析机制： parser.e
Dom和sax解析的比较
yangm
08-26 622
Dom和sax解析的比较 DOM解析：(Document Object Model) 文档对象模型 易用性强，使用DOM时，将把所有的XML文档信息都存于内存中，并且遍历简单，支持XPath，增强了易用性。 效率低，解析速度慢，内存占用量过高，对于大文件来说几乎不可能使用 支持增删改查 SAX解析：（Simple API for Xml） SAX是一个用于处理XML事件驱动的“推”模型，
考试题分析
qq_43279936的博客
11-11 306
考试信息： IPADDR: 172.25.254.x(X 在这里指您的工作站编号加100) NETMASK: 255.255.255.0 GATEWAY: 172.25.254.250 DNS: 172.25.254.250 yum源地址为：http://172.25.254.250/rhel7 在进行考试之前,请先重置根用户密码为 examwestos passwd examwestos ...
用Dom和Sax对xml文件的解析
weixin_33924312的博客
07-30 66
package day12.xml; import java.io.FileNotFoundException; import java.io.IOException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import j...
mybatis源码编译的一些坑
dustinqi的博客
12-28 846
  讲道理，如果mybatis和mybatis-parent的版本号一致的话，大概率是不会遇到坑的。但是不排除某些人的自残倾向，非要用不同版本的mybatis和mybatis-parent，这样的话可能会遇到以下这些坑： “cannot resolve plugins xxx”的问题： 导致这个问题的原因是没有指定插件的版本号，在pom文件中为相应插件指定version即可，例如： 或者干脆注释掉： “Cannot resolve plugin org.apache.maven.plugins:mav
怎么解析MyBatis.xml
最新发布
04-05
1. 创建XML解析器：使用Java自带的DOM解析器或者第三方库（如JDOM、SAX等）创建一个XML解析器对象。 2. 加载配置文件：使用解析器对象读取MyBatis.xml文件，并将其转换为Document对象。 3. 解析配置信息：通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值