xml基础知识

<!DOCTYPE 书架 [
     <!ELEMENT 书架 (书+)>
     <!ELEMENT 书 (书名,作者,售价)>
     <!ELEMENT 书名 (#PCDATA)>
     <!ELEMENT 作者 (#PCDATA)>
     <!ELEMENT 售价 (#PCDATA)>
 ]>

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE 书架 SYSTEM "book.dtd">
<书架>
    <书>
        <书名>Java就业培训教程</书名>
        <作者>张孝祥</作者>
        <售价>58.00元</售价>
        <!--如果添加dtd中无添加的元素，就会报错，即为约束-->
    </书>
    <书>
        <书名>EJB3.0入门经典</书名>
        <作者>黎活明</作者>
        <售价>39.00元</售价>
    </书>
</书架>

<!ELEMENT 书架 (书+)>
    <!ELEMENT 书 (书名,作者,售价)>
        <!ELEMENT 书名 (#PCDATA)>
        <!ELEMENT 作者 (#PCDATA)>
        <!ELEMENT 售价 (#PCDATA)>

private static void list1(Node node) {
    //判断元素类型时候才打印
    if (node.getNodeType() == Node.ELEMENT_NODE){
        System.out.println(node.getNodeName());
    }
    //得到一层子节点
    NodeList list = node.getChildNodes();
    //遍历list
    for(int i=0; i<list.getLength();i++){
        //继续得到node1的子节点
        Node node1 = list.item(i);
        list1(node1);
    }
}

<?xml version="1.0" encoding="UTF-8" standalone="no"?><person>
    <p1>
        <name>zhangsan</name>
        <age>20</age>
        <sex>女</sex>
    </p1>
    <p1>
        <name>lisi</name>
        <age>30</age>
    </p1>
</person>}

  1 package jaxptest;
  2 import org.w3c.dom.*;
  3 import javax.xml.parsers.DocumentBuilder;
  4 import javax.xml.parsers.DocumentBuilderFactory;
  5 import javax.xml.transform.Transformer;
  6 import javax.xml.transform.TransformerFactory;
  7 import javax.xml.transform.dom.DOMSource;
  8 import javax.xml.transform.stream.StreamResult;
  9 
 10 public class TestJaxp {
 11     public static void main(String[] args) throws Exception{
 12         String uri = "src/person.xml";
 13 //        selectAll(uri);
 14 //        selectSin(uri);
 15 //        addSex(uri);
 16 //        modifySex(uri);
 17 //        delSex(uri);
 18         listElement(uri);
 19     }
 20     //解析dom方法解析xml文档方法
 21     private static Document jaxpParseXml(String uri) throws Exception {
 22         //创建解析器工厂
 23         DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
 24         //创建解析器
 25         DocumentBuilder builder = builderFactory.newDocumentBuilder();
 26         //解析xml返回document
 27         Document document = builder.parse(uri);
 28         return document;
 29     }
 30     //回写xml方法
 31     private static void writeBack(Document document,String uri) throws Exception{
 32         TransformerFactory transformerFactory = TransformerFactory.newInstance();
 33         Transformer transformer = transformerFactory.newTransformer();
 34         transformer.transform(new DOMSource(document),new StreamResult(uri));
 35     }
 36     //查询所有name元素的值
 37     public static void selectAll(String uri) throws Exception {
 38         //查询所有name元素的值
 39         /*
 40         * 1、创建解析器工厂
 41         * 2、根据解析器工厂创建解析器
 42         * 3、解析xml返回document
 43         * 4、得到所有的name元素
 44         * 5、返回集合，遍历集合，得到每一个name元素
 45         * */
 46         Document document = jaxpParseXml(uri);
 47         //得到name元素
 48         NodeList list = document.getElementsByTagName("name");
 49         //遍历集合
 50         for(int i=0;i<list.getLength();i++) {
 51             Node name1 = list.item(i);
 52             //得到name1元素里面的值
 53             String s = name1.getTextContent();
 54             System.out.println(s);
 55         }
 56     }
 57     //查询xml中第一个name元素的值
 58     public static void selectSin(String uri) throws Exception{
 59         /*
 60         * 1、创建解析器工厂
 61         * 2、根据解析器工厂创建解析器
 62         * 3、解析xml返回document
 63         * 4、得到所有的name元素
 64         * 5、使用返回集合，里面方法item，下标获取具体的元素
 65         * 6、得到具体的值，使用getTextContent方法
 66         * */
 67         Document document = jaxpParseXml(uri);
 68         NodeList list = document.getElementsByTagName("name");
 69         Node name1 = list.item(0);
 70         String s1 = name1.getTextContent();
 71         System.out.println(s1);
 72     }
 73     //在第一个p1下面（末尾）添加<sex>nv</sex>
 74     public static void addSex(String uri) throws Exception {
 75         /*
 76         * 1、创建解析器工厂
 77         * 2、根据解析器工厂创建解析器
 78         * 3、解析xml返回document
 79         * 4、得到第一个p1（得到所有p1，使用item方法下标得到）
 80         * 5、创建sex标签createElementNode
 81         * 6、串及文本createTextNode
 82         * 7、把文本添加到sex下面appendChild
 83         * 8、把sex添加到第一个p1下面
 84         * 9、回写xml
 85         * */
 86         Document document = jaxpParseXml(uri);
 87         NodeList list = document.getElementsByTagName("p1");
 88         Node p1 = list.item(0);
 89         Element sex1 = document.createElement("sex");
 90         Text text = document.createTextNode("女");
 91         sex1.appendChild(text);
 92         p1.appendChild(sex1);
 93         writeBack(document,uri);
 94     }
 95     //修改第一p1下面的sex内容是男
 96     public static void modifySex(String uri) throws Exception{
 97         /*
 98         * 1、创建解析器工厂
 99         * 2、根据解析器工厂创建解析器
100         * 3、解析xml返回document
101         * 4、得到sex item方法
102         * 5、修改sex里面的值setTextContent方法
103         * 6、回写xml
104         * */
105         Document document = jaxpParseXml(uri);
106         Node sex1 = document.getElementsByTagName("sex").item(0);
107         sex1.setTextContent("男");
108         writeBack(document,uri);
109     }
110     //删除<sex>男</sex>节点
111     public static void delSex(String uri) throws Exception{
112         /*
113         * 1、创建解析器工厂
114         * 2、根据解析器工厂创建解析器
115         * 3、解析xml返回document
116         * 4、获取sex元素
117         * 5、获取sex的父节点,使用getParentNode方法
118         * 6、删除，使用父节点删除removeChild方法
119         * 7、回写xml
120         * */
121         Document document = jaxpParseXml(uri);
122         Node sex1 = document.getElementsByTagName("sex").item(0);
123         Node p1 = sex1.getParentNode();
124         p1.removeChild(sex1);
125         writeBack(document,uri);
126     }
127     //遍历节点，把xml中的所有元素名称打印出来
128     public static void listElement(String uri) throws Exception {
129          /*
130         * 1、创建解析器工厂
131         * 2、根据解析器工厂创建解析器
132         * 3、解析xml返回document
133         * ===使用递归实现======
134         * 4、得到根节点
135         * 5、得到根节点子节点
136         * 6、得到根节点子节点的子节点
137         * */
138         Document document = jaxpParseXml(uri);
139         //编写一个方法实现遍历操作
140         list1(document);
141     }
142     private static void list1(Node node) {
143         //判断元素类型时候才打印
144         if (node.getNodeType() == Node.ELEMENT_NODE){
145             System.out.println(node.getNodeName());
146         }
147         //得到一层子节点
148         NodeList list = node.getChildNodes();
149         //遍历list
150         for(int i=0; i<list.getLength();i++){
151             //继续得到node1的子节点
152             Node node1 = list.item(i);
153             list1(node1);
154         }
155     }

<complexType>
　　<sequence>
　　　　　　子元素
　　</sequence>
</complexType>

<element name="person">
    <complexType>
        <sequence>
            <element name="name" type="string"></element>
            <element name="age" type="int"></element>
        </sequence>
    </complexType>
</element>

<person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.itcast.cn/201711111"
xsi:schemaLocation="http://www.itcast.cn/201711111 1.xsd">

<?xml version="1.0" encoding="UTF-8" ?>
<person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.itcast.cn/201711111"
xsi:schemaLocation="http://www.itcast.cn/201711111 1.xsd">
    <name>zhangsan</name>
    <age>20</age>
</person>

<?xml version="1.0" encoding="UTF-8" ?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.itcast.cn/201711111"
        elementFormDefault="qualified">
    <element name="person">
        <complexType>
            <sequence>
                <element name="name" type="string"></element>
                <element name="age" type="int"></element>
            </sequence>
        </complexType>
    </element>
</schema>

 1 import org.xml.sax.Attributes;
 2 import org.xml.sax.SAXException;
 3 import org.xml.sax.helpers.DefaultHandler;
 4 import javax.xml.parsers.SAXParser;
 5 import javax.xml.parsers.SAXParserFactory;
 6 
 7 public class TestSax {
 8     public static void main(String[] args) throws Exception {
 9         /*
10         * 1、创建解析工厂
11         * 2、创建解析器
12         * 3、执行parse方法
13         * 4、自己创建一个类，继承DefaultHandler
14         * 5、重写里面的三个方法
15         * */
16         SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
17         SAXParser saxParser = saxParserFactory.newSAXParser();
18         saxParser.parse("src/p1.xml",new MyDefault2());
19         saxParser.parse("src/p1.xml",new MyDefault1());
20     }
21 }
22 //实现获取所有的name元素
23 class MyDefault2 extends DefaultHandler {
24     boolean flag = false;
25     int index = 1;
26     @Override
27     public void startElement(String uri, String localName, String qName, 
　　　　　　　　Attributes attributes) throws SAXException {
28         //判断qName是否是name元素
29         if ("name".equals(qName)) {
30             flag = true ;
31         }
32     }
33     @Override
34     public void characters(char[] ch, int start, int length) throws SAXException {
35         //当flag值是true时候，表示解析到name元素
36         if (flag == true && index == 1){
37                 System.out.println(new String(ch,start,length));
38             }
39     }
40     @Override
41     public void endElement(String uri, String localName, String qName) throws SAXException {
42         //把flag设置成false，表示name元素结束
43         if ("name".equals(qName)) {
44             flag = false;
45         }
46         index++;
47     }
48 }
49 class MyDefault1 extends DefaultHandler {
50     @Override
51     public void startElement(String uri, String localName, String qName,
52                              Attributes attributes) throws SAXException {
53         System.out.print("<"+qName+">");
54     }
55     @Override
56     public void characters(char[] ch, int start, int length) throws SAXException {
57         System.out.print(new String(ch,start,length));
58     }
59     @Override
60     public void endElement(String uri, String localName, String qName) throws SAXException {
61         System.out.print("</"+ qName+">");
62     }
63 }

<?xml version="1.0" encoding="UTF-8" ?>
<person>
    <p1>
        <name>zhangsan</name>
        <age>20</age>
    </p1>
    <p1>
        <name>lisi</name>
        <age>25</age>
    </p1>
</person>

<?xml version="1.0" encoding="UTF-8"?>
<person> 
  <p1 id1="aaa">
    <name>zhangsan</name>  
    <age>30</age>  
    <sex>女</sex> 
  </p1>  
  <p1> 
    <name>lisi</name>  
    <age>25</age> 
  </p1> 
</person>

  1 package testDom4j;
  2 
  3 import dom4jutils.Dom4jUtils;
  4 import org.dom4j.Document;
  5 import org.dom4j.DocumentHelper;
  6 import org.dom4j.Element;
  7 import org.dom4j.io.OutputFormat;
  8 import org.dom4j.io.SAXReader;
  9 import org.dom4j.io.XMLWriter;
 10 
 11 import java.io.FileOutputStream;
 12 import java.util.List;
 13 
 14 public class TestDom4j {
 15     public static void main(String[] args) throws Exception {
 16 //        selectName();
 17 //        selectSin();
 18 //        selectSecond();
 19 //        addSex();
 20 //        addAgeBefore();
 21 //        modifyAge();
 22 //        deleteSchool();
 23         getValues();
 24     }
 25     //查询xml中所有name元素的值
 26     public static void selectName() throws Exception{
 27         /*
 28         * 1、创建解析器
 29         * 2、得到document
 30         * 3、得到根节点  getRootElement() 返回Element
 31         * 4、得到所有的p1标签
 32         *   -elements（"p1"） 返回Element
 33         * 5、得到name
 34         *   -在p1下面执行element（"name"）的方法返回Element
 35         * 6、得到name里面的值
 36         *   -getText方法得到值
 37         * */
 38         //创建解析器
 39         SAXReader reader = new SAXReader();
 40         //得到document
 41         Document document = reader.read("src/p1.xml");
 42         //得到根节点
 43         Element root = document.getRootElement();
 44         //得到p1
 45         List<Element> list = root.elements("p1");
 46         //遍历list
 47         for(Element element : list) {
 48             //element是每一个p1
 49             //得到p1下面的name元素
 50             Element name1 = element.element("name") ;
 51             //得到name里面的值
 52             String s = name1.getText();
 53             System.out.println(s);
 54         }
 55     }
 56 
 57     //获取得到第一个name元素的值
 58     public static void selectSin() throws Exception {
 59         /*
 60         * 1、创建解析器
 61         * 2、得到document
 62         * 3、得到根节点
 63         * 4、得到第一个p1标签
 64         * 5、得到p1下面的name元素
 65         * 6、得到name里面的值
 66         * */
 67         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
 68         Element root = document.getRootElement();
 69         Element p1 = root.element("p1");
 70         Element name1 = p1.element("name");
 71         System.out.println(name1.getText());
 72     }
 73     //获取得到第二个name元素的值
 74     public static void selectSecond() throws Exception {
 75         /*
 76         * 1、创建解析器
 77         * 2、得到document
 78         * 3、得到根节点
 79         * 4、得到所有的p1
 80         * 5、遍历得到第二p1
 81         * 6、得到第二个p1下面的name
 82         * 7、得到name的值
 83         * */
 84         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
 85         Element root = document.getRootElement();
 86         List<Element> list = root.elements("p1");
 87         Element p2 = list.get(1);
 88         Element name2 = p2.element("name");
 89         System.out.println(name2.getText());
 90     }
 91 
 92     //在第一个p1标签末尾添加一个元素<sex>女</sex>
 93     public static void addSex() throws Exception {
 94         /*
 95         * 1、创建解析器
 96         * 2、得到document
 97         * 3、得到根节点
 98         * 4、获取第一个p1
 99         * 5、在p1下面添加元素
100         * 6、在添加完成之后的元素下面添加文本
101         * 7、回写xml
102         * */
103         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
104         Element root = document.getRootElement();
105         //得到第一个p1元素
106         Element p1 = root.element("p1");
107         //在p1下面直接添加元素
108         Element sex1 = p1.addElement("sex");
109         //在sex下面添加文本
110         sex1.setText("女");
111         //回写xml
112         OutputFormat format = OutputFormat.createPrettyPrint();
113         XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/p1.xml"),format);
114         xmlWriter.write(document);
115         xmlWriter.close();
116     }
117 
118     //在特定位置添加元素，在第一个p1下面的age标签之前添加<school>ecit</school>
119     public static void addAgeBefore() throws Exception {
120         /*
121         * 1、创建解析器
122         * 2、得到document
123         * 3、得到根节点
124         * 4、获取第一个p1
125         * 5、在p1下面所有的元素
126         * 6、在指定位置添加元素
127         * 7、回写xml
128         * */
129         //获得document
130         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
131         Element root = document.getRootElement();
132         Element p1 = root.element("p1") ;
133         //获取p1下所有元素的集合
134         List<Element> list = p1.elements();
135         //创建元素
136         Element school = DocumentHelper.createElement("school");
137         school.setText("ecit");
138         //在指定位置添加元素
139         list.add(1,school);
140         //回写xml
141         Dom4jUtils.xmlWriters(Dom4jUtils.PATH,document);
142     }
143     //修改节点的操作，修改第一个p1下面的age元素值为30
144     public static void modifyAge() throws Exception {
145         /*
146         * 1、得到document
147         * 2、得到根节点
148         * 3、获取第一个p1
149         * 4、得到p1下面的age
150         * 5、修改为30
151         * 6、回写xml
152         * */
153         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
154         Element root = document.getRootElement();
155         Element p1 = root.element("p1");
156         Element age = p1.element("age");
157         //使用setText（）方法修改文本内容
158         age.setText("30");
159         Dom4jUtils.xmlWriters(Dom4jUtils.PATH,document);
160     }
161     //使用dom4j实现删除节点的操作，删除第一个p1下面的<school>ecit<school>元素
162     public static void deleteSchool() throws Exception{
163          /*
164         * 1、得到document
165         * 2、得到根节点
166         * 3、获取第一个p1
167         * 4、得到第一个p1下面的school
168         * 5、删除（使用p1删除school）
169         * -得到school的父节点
170         *   -第一种直接得到p1
171         *   -使用方法getParent方法
172         * -在p1上面执行remove方法删除节点
173         * 6、回写xml
174         * */
175         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
176         Element root = document.getRootElement();
177         Element p1 = root.element("p1");
178         Element sch = p1.element("school");
179         //通过父节点删除
180         p1.remove(sch);
181         Dom4jUtils.xmlWriters(Dom4jUtils.PATH,document);
182     }
183     //使用dom4j获取属性的操作，获取第一个p1的属性id1的值
184     public static void getValues() throws Exception {
185          /*
186         * 1、得到document
187         * 2、得到根节点
188         * 3、获取第一个p1
189         * 4、得到第一个p1的值
190         * */
191         Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
192         Element root = document.getRootElement();
193         Element p1 = root.element("p1");
194         String value = p1.attributeValue("id1");
195         System.out.println(value);
196     }
197 }

 1 package dom4jutils;
 2 
 3 import org.dom4j.Document;
 4 import org.dom4j.DocumentException;
 5 import org.dom4j.io.OutputFormat;
 6 import org.dom4j.io.SAXReader;
 7 import org.dom4j.io.XMLWriter;
 8 
 9 import java.io.FileOutputStream;
10 import java.io.IOException;
11 
12 public class Dom4jUtils {
13     public static final String PATH="src/p1.xml";
14     //返回document
15     public static Document getDocument(String path) {
16         try {
17             //创建解析器
18             SAXReader reader = new SAXReader();
19             //得到document
20             Document document = reader.read(path);
21             return document;
22         } catch (DocumentException e) {
23             e.printStackTrace();
24         }
25         return null;
26     }
27     //回写xml
28     public static void xmlWriters(String path,Document document) {
29         try {
30             OutputFormat format = OutputFormat.createPrettyPrint();
31             XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(path),format);
32             xmlWriter.write(document);
33             xmlWriter.close();
34         } catch (IOException e) {
35             e.printStackTrace();
36         }
37     }
38 }

/*
* 1、得到document
* 2、直接使用selectNodes("//name")方法的到所有的name元素
* */
//得到document
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
//使用selectNodes（"//name"）方法得到所有的name元素
List<Node> list = document.selectNodes("//name");
for (Node node : list){
    //node是每一个name元素
    String s = node.getText();
    System.out.println(s);
}

<?xml version="1.0" encoding="UTF-8"?>
<student> 
  <stu> 
    <id>100</id>  
    <name>zhangsan</name>  
    <age>20</age> 
  </stu>  
  <stu> 
    <id>101</id>  
    <name>zhangsan</name>  
    <age>30</age> 
  </stu> 
</student>

 1 package service;
 2 
 3 import org.dom4j.Document;
 4 import org.dom4j.Element;
 5 import org.dom4j.Node;
 6 import vo.Student;
 7 import java.util.List;
 8 
 9 public class StuService {
10 
11     //查询 根据id查询学生信息
12     public static Student getStu(String id) throws Exception {
13         /*
14         * 1、创建解析器
15         * 2、得到document
16         * 3、获取所有的id
17         *
18         * 4、返回list集合，遍历list集合
19         * 5、得到每一个id的节点
20         * 6、id节点的值
21         * 7、判断id的值和传递的id值是否相同
22         * 8、如果相同，先获取到id的父节点stu
23         * 9、通过stu获取到name age值
24         * */
25         Document document = StudentUtils.getDocument(StudentUtils.PATH);
26         List<Node> list = document.selectNodes("//id");
27         Student student = new Student();
28         for (Node node : list) {
29              String idv = node.getText();
30              if (idv.equals(id)) {
31                 Element stu = node.getParent();
32                 String namev = stu.element("name").getText();
33                 String agev = stu.element("age").getText();
34                 student.setId(idv);
35                 student.setName(namev);
36                 student.setAge(agev);
37              }
38         }
39         return student;
40     }
41     //增加
42     public static void addStu(Student student) throws Exception {
43         /*
44         * 1、创建解析器
45         * 2、得到document
46         * 3、获得根节点
47         * 4、在根节点上面创建stu标签
48         * 5、在stu标签上面依次添加id、name、age
49         * 6、在id name age上面依次添加值
50         * */
51         Document document = StudentUtils.getDocument(StudentUtils.PATH);
52         Element root = document.getRootElement();
53         Element stu = root.addElement("stu");
54         Element id1 = stu.addElement("id");
55         Element name1 = stu.addElement("name");
56         Element age1 = stu.addElement("age");
57         id1.setText(student.getId());
58         name1.setText(student.getName());
59         age1.setText(student.getAge());
60         StudentUtils.xmlWriters(StudentUtils.PATH,document);
61     }
62     //删除，根据学生的id删除
63     public static void delStu(String id) throws Exception{
64         /*
65         * 1、创建解析器
66         * 2、得到document
67         * 3、获取所有的id
68         *   使用xpath //id 返回list集合
69         * 4、遍历list集合
70         * 5、判断集合里面的id和传递的id是否相同
71         * 6、如果相同，把id所在的stu删除
72         * */
73         Document document = StudentUtils.getDocument(StudentUtils.PATH);
74         List<Node> list = document.selectNodes("//id");
75         for (Node node : list) {
76             String idv = node.getText();
77             if (idv.equals(id)) {
78                 Element stu = node.getParent();
79                 Element student = stu.getParent();
80                 student.remove(stu);
81             }
82         }
83         StudentUtils.xmlWriters(StudentUtils.PATH,document);
84     }
85 }

 1 package service;
 2 import org.dom4j.Document;
 3 import org.dom4j.DocumentException;
 4 import org.dom4j.io.OutputFormat;
 5 import org.dom4j.io.SAXReader;
 6 import org.dom4j.io.XMLWriter;
 7 import java.io.FileOutputStream;
 8 import java.io.IOException;
 9 
10 public class StudentUtils {
11     public static final String PATH="src/student.xml";
12     //返回document
13     public static Document getDocument(String path) {
14         try {
15             //创建解析器
16             SAXReader reader = new SAXReader();
17             //得到document
18             Document document = reader.read(path);
19             return document;
20         } catch (DocumentException e) {
21             e.printStackTrace();
22         }
23         return null;
24     }
25     //回写xml
26     public static void xmlWriters(String path,Document document) {
27         try {
28             OutputFormat format = OutputFormat.createPrettyPrint();
29             XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(path),format);
30             xmlWriter.write(document);
31             xmlWriter.close();
32         } catch (IOException e) {
33             e.printStackTrace();
34         }
35     }
36 }

 1 package vo;
 2 
 3 public class Student {
 4     private String id;
 5     private String name;
 6     private String age;
 7     public String getId() {return id; }
 8     public String getName() {return name;  }
 9     public String getAge() { return age;}
10     public void setId(String id) {this.id = id;}
11     public void setName(String name) { this.name = name;}
12     public void setAge(String age) { this.age = age;}
13 
14     @Override
15     public String toString() {
16         return "Student{" +
17                 "id=‘" + id + ‘\‘‘ +
18                 ", name=‘" + name + ‘\‘‘ +
19                 ", age=‘" + age + ‘\‘‘ +
20                 ‘}‘;
21     }
22 }

 1 package test;
 2 
 3 import service.StuService;
 4 import vo.Student;
 5 
 6 public class TestStu {
 7     public static void main(String[] args) throws Exception{
 8         testSelect();
 9 //        testAdd();
10 //        testDel();
11     }
12     //测试查询方法
13     public static void testSelect() throws Exception {
14         Student stu = StuService.getStu("100");
15         System.out.println(stu.toString());
16     }
17     //测试添加方法
18     public static void testAdd() throws Exception {
19         Student stu = new Student();
20         stu.setId("103");
21         stu.setName("wanwu");
22         stu.setAge("25");
23         StuService.addStu(stu);
24     }
25     //测试添加方法
26     public static void testDel() throws Exception{
27         StuService.delStu("103");
28     }
29 }