day5
一、表单提交方式
1.使用submit提交
<form>
aaa
<input type="submit"/>
</form>
2.使用button提交表单
function form1() {
var form1 = document.getElementById("form1");
form1.action = "day4.html";
form1.submit();
}
3.使用超链接提交
<a href="day4.html?username=123124">使用超链接提交</a>
4.onclick:鼠标点击事件
onchange：改变内容（一般和selected以前使用）
onfocus：得到焦点
onblur：失去焦点
function focus1() {
var input1 = document.getElementById("id1");
input1.value = "";
}
function blur1() {
var input1 = document.getElementById("id1");
input1.value = "please input";
}
二、XML的简介
可扩展标记语言（Extensible Markup Language，简称：XML）
标记型语言：*使用标签来操作
可扩展：标签可以自己定义，<猫></猫>
用途：存储数据
三、XML的应用
1.不同的系统之间传输数据
2.用来表示生活中有关系的数据
3.经常用在配置文件
四、XML的语法
XML的文档声明
创建一个文件，后缀名是 .xml
xml必须有文档声明 <?xml version="1.0" encoding="gbk"?>
五、XML元素的定义
标签定义：
有开始必须有结束：<person></person>
没有内容可在标签内结束:<aa/>
一个XML中，只能有一个根标签，其他标签都是这个标签下面的标签。
在XML中空格和换行都当成内容来解析
XML中标签的名称规则：
（1）XML代码区分大小写
（2）不能以数字和下划线开头
（3）不能包含空格和冒号
六、XML中属性的定义
1.一个标签上可以有多个属性
2.属性名称不能相同
3.属性名称和属性值之间使用=，属性值使用引号包起来（可以是单引号，也可以是双引号）
4.xml属性的名称规范和元素的名称规范一致
七、XML中的注释
<!--xml注释 -->
八、XML中的特殊字符
在XML中显示a<b，需要对<进行转义
九、CDATA区
可以解决多个字符都需要转义的操作，把这些内容放到CDATA区里面就不需要转义了。
写法：<![CDATA[内容]]>
<![CDATA[a>b&&a<5]]>
十、PI指令（处理指令）
可以在XML中设置样式
写法：<?xml-stylesheet type="text/css" href="1.css"?>
只能对英文标签名称起作用，对于中文的标签名称不起作用
十一、XML的约束
dtd约束
schema约束
十二、dtd的快速入门
1.看XML中有多少个元素，有几个元素，在dtd文件中写<!ELEMENT>
2.判断元素是简单元素还是复杂元素
复杂元素：有子元素的元素
<!ELEMENT 元素名称(子元素)>
简单元素：没有子元素
<!ELEMENT 元素名称(#PCDATA)>
3.需要在xml文件中引入dtd文件（三种方式）
（1）引用内部的dtd文件：
<!DOCTYPE 根元素名称 SYSTEM "dtd文件的路径">
（2）使用内部的dtd文件
<!DOCTYPE 根元素名称 [
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
]>
（3）使用外部的dtd文件（网络上的dtd文件）
<!DOCTYPE 根元素 PUBLIC "dtd名称" "dtd文档的URL">
十三、使用dtd来定义元素
语法：<!ELEMENT 元素名 约束>
使用规则：
(#PCDATA): 约束name是字符串类型
EMPTY：元素为空（没有内容）
ANY：任意
子元素出现的次数：
+：表示一次或多次
?：表示出现零次或一次
*：表示零次或多次
子元素之间使用逗号进行隔开：表示元素出现的顺序
子元素之间用 | 隔开：表示元素只能出现其中的任意一个
十四、使用dtd来定义属性
语法：
<!ATTLIST 元素名称
属性名称 属性类型 属性的约束
>
属性类型：
1.CDATA:字符串
<!ATTLIST birthday
ID1 CDATA #REQUIRED
>
2.枚举：表示每次只能在一定的范围内出现新值，但是没次只能出现其中的一个
（aa|bb|cc）
<!ATTLIST age
ID2 (AA|BB|CC) #REQUIRED>
3.ID：值只能是字母或者下划线开头
<!ATTLIST name
ID3 ID #REQUIRED>
属性的约束：
#REQUIRED:属性必须存在
#IMPLIED：属性可有可无
#FIXED: 表示一个固定值
<!ATTLIST sex
ID4 CDATA #FIXED "ABC">
直接值：不写属性，使用直接值
写了属性，使用的值
十五、实体的定义
语法：<!ENTITY 实体名称 "实体的值">
<!ENTITY TEST "HAHHEHE">
实体使用：&实体名称；
注意：定义实体需要写在内部dtd里面，如果写在外部的dtd里面，某些浏览器内容得不到
十六、XML解析的简介
xml解析方式（技术）：dom和sax
dom解析：根据xml的层级结构在内存中分配一个树形结构，把xml的标签，属性和文本都封装成对象
使用dom解析缺点：如果文件过大，会造成内存溢出
使用dom解析优点：很方便实现增删改操作
sax方式解析：采用事件驱动，边读边解析；从上到下一行一行解析，解析到某一个对象，返回对象名称。
使用sax解析缺点：不能实现增删改操作
使用sax解析优点：不会造成内存溢出，会实现查询
十七、jaxp的api查看
jaxp是javase的一部分
jaxp解析器在jdk的javax.xml.parsers包里面
四个类：分别是针对dom和sax解析使用的类
dom：
DocumentBuilder：解析器类
这个类是一个抽象类，不能new
此类的实例可以从DocumentBuilderFactory.newDocumentBuilder()方法获取
可以解析xml parse("xml路径") 返回时document整个文档
返回的document是一个接口，父节点是Node
在document里面方法:
getElementByTagName（String tagname）：这个方法可以得到标签；返回的是集合NodeList
createElement(String tagname):创建标签
createTextNode(String data):创建文本
appendChild(Node newChild):把文本添加到标签下面去
removeChild(Node newChild):删除节点
getParentNode()：获取父节点
NodeList：
getLength()：得到集合的长度
item(int index)：下标取到具体的值
getTextContent()：得到标签里面的内容
DocumentBuilderFactory：解析器工厂
着也是一个抽象类，不能new
newInstance（）获取DocumentBuilderFactory的实例
sax：
SAXparser：解析器类
SAXparserFactory：解析器工厂
十八、使用jaxp实现查询操作
查询xml中所有的name元素的值
1.创建解析器工厂
DocumentBuilderFactory.newInstance();
2.根据解析器工厂创建解析器
builderFactory.newDocumentBuilder();
3.解析xml返回document
Document document = builder.parse("src/person.xml");
4.得到所有的name元素
document.getElementsByTagName("name");
5.返回集合，遍历集合，得到每一个name元素
遍历：
for(int i=0;i<list.getLength();i++) {
Node name1 = list.item(i);//得到每一个name元素
String s = name1.getTextContent();//得到name元素里面的值
System.out.println(s);
}
查询xml中第一个元素的值
public static void selectSin(DocumentBuilderFactory builderFactory) throws Exception {
//创建解析器工厂
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//解析xml返回document
org.w3c.dom.Document document = builder.parse("src/person.xml");
//得到所有的name元素
NodeList list = document.getElementsByTagName("name");
//使用下标得到第一个元素
Node name1 = list.item(0);
//得到name里面的具体的值
String s1 = name1.getTextContent();
System.out.println(s1);
}
十九、使用jaxp添加节点
public static void addSex(DocumentBuilderFactory builderFactory) throws Exception{
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
org.w3c.dom.Document document = builder.parse("src/person.xml");
NodeList list = document.getElementsByTagName("p1");
Node p1 = list.item(0);
org.w3c.dom.Element sex1 = document.createElement("sex");
Text text1 = document.createTextNode("nv");
sex1.appendChild(text1);
p1.appendChild(sex1);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(new DOMSource(document),new StreamResult("src/person.xml"));
}
二十、使用jaxp修改节点
public static void modifySex(DocumentBuilderFactory builderFactory) throws Exception{
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder();
org.w3c.dom.Document document = builder.parse("src/person.xml");
Node sex1 = document.getElementsByTagName("sex").item(0);
sex1.setTextContent("nan");
//回写xml：把内存中的文档写到文件里面
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(new DOMSource(document),new StreamResult("src/person.xml"));
}
二十一、使用jaxp删除节点
public static void delSex(DocumentBuilderFactory builderFactory) throws Exception{
//创建解析器工厂
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//得到document
org.w3c.dom.Document document = builder.parse("src/person.xml");
//得到sex元素
Node sex1 = document.getElementsByTagName("sex").item(0);
//得到sex1父节点
Node p1 = sex1.getParentNode();
//删除操作
p1.appendChild(sex1);
//回写xml
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(new DOMSource(document),new StreamResult("src/person.xml"));
}
二十二、使用jaxp遍历节点
public static void listElement(DocumentBuilderFactory builderFactory) throws Exception{
//创建解析器工厂
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
//创建解析器
DocumentBuilder builder = builderFactory.newDocumentBuilder();
//得到document
org.w3c.dom.Document document = builder.parse("src/person.xml");
//编写一个方法实现遍历操作
list1(document);
}
//递归遍历方法
private static void list1(org.w3c.dom.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++) {
Node node1 = list.item(1);
//继续得到node1的字节点
list1(node1);//自己调用自己
}
}
=====================================================================================================================================================================================================================
day6
一、schema约束
- schema符合xml的语法，xml语句
- 一个xml中可以有多个schema，多个schema使用名称空间区分（类似于java包名）
- dtd里面有PCDATA类型，但是在schema里面可以支持更多的数据类型
- schema语法更复杂，目前不能替代dtd
二、schema的快速入门
创建一个schema文件 后缀名是.xml
步骤
- 在schema文件里面
属性：
1.xmlns="http://www.w3.org/2001/XMLSchema"
表示当前xml文件是一个约束文件
2.targetNamespace="http://www.example.org/1"
使用schema约束文件，直接通过这个人地址引入约束文件
3.elementFormDefault="qualified"
1.看xml中有多少个元素：<element>
2.看简单元素和复杂元素
复杂元素：
<complexType>
<sequence>
子元素
</sequence>
</complexType>
简单元素写在复杂元素的 <sequence>下面
<element name="person">
<complexType>
<sequence>
<element name="name" type="string"></element>
<element name="age" type="int"></element>
</sequence>
</complexType>
</element>
3.在被约束文件里面引入约束文件
<person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"//表示xml是一个被约束文件
xmlns="http://www.example.org/1"//是约束文档里面的targetNamespace
xsi:schemaLocation="http://www.example.org/1 1.xsd">//targetNamespace+空格+约束文档的地址路径
<sequence>:表示元素出现的顺序
<all>：元素只能出现一次
<choice>：元素只能出现其中的一个
maxOccurs="unbounded"：表示元素出现的次数
<any></any>：表示任意元素
可以约束属性
写在复杂元素里面
写在</complexType>之前
<attribute name="id1" type="int" use="required"></attribute>
//name:属性名称
//type：属性类型 int string
//use：属性是否必须出现 required
引用多个schema文件，可以给每个起一个别名
别名：dept：元素名称
三、sax解析原理
解析有俩种技术：dom和sax
根据xml的层级结构在内存中分配一个树形结构
把xml中标签，属性，文本封装成对象
sax方式：事件驱动，边读边解析
在java.xml.parsers包里面
SAXParser：此类的实例可以从SAXParserFactory.newSAXParser()方法获得
parse(File f,DefaultHandler dh)
俩个参数：
第一个参数：xml路径
事件处理器
SAXParserFactory:实例newInnewInstance（）方法得到
SAX解析过程：
1.当解析到开始标签的时候，自动执行startElement方法
2.当解析到文本的时候，自动执行charcharacters方法
3.当解析到结束标签时候，自动执行endElement方法
四、使用jaxp的sax方法解析xml
sax方法不能实现增删改操作，只能做查询操作
例：打印出整个文档
1.执行parse方法：第一个参数xml路径；第二个参数是 事件处理器
2.创建一个类，继承事件处理器的类
3.重写里面的三个方法（右键→Source→Oververride/implement）
public class TestSax {
public static void main(String[] args) throws Exception {
//创建解析器工厂
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
//创建解析器
SAXParser saxParser = saxParserFactory.newSAXParser();
//执行parser方法
saxParser.parse("src/p1.xml",new MyDefault1());
}
}
class MyDefault1 extends DefaultHandler{
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
System.out.print("<"+qName+">");
}
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
System.out.print(new String(ch,start,length));
}
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
System.out.print("</"+qName+">");
}
}
获取所有name元素的值
public class TestSax {
public static void main(String[] args) throws Exception {
//创建解析器工厂
SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
//创建解析器
SAXParser saxParser = saxParserFactory.newSAXParser();
//执行parser方法
saxParser.parse("src/p1.xml",new MyDefault2());
}
}
class MyDefault2 extends DefaultHandler{
boolean flag = false;
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes)
throws SAXException {
//判断qName是否是name元素
if("name".equals(qName)) {
flag = true;
}
}
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
//当flag是true的时候，表示解析到name元素
if(flag==true) {
System.out.println(new String(ch, start, length));
}
}
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
//把flag设置成false，表示name元素结束
if("name".equals(qName)) {
flag = false;
}
}
五、使用dom4j解析xml
dom4j：是一个组织，针对xml解析提供提供解析器dom4j
得到document
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(url);
document的父接口是Node
document里面的方法getRootElement():获取根节点 返回的是Element
Element也是一个接口，父接口是Node
Element和Node里面方法
getParent（）：获取父节点
addElement：添加标签
element(qname)：获取标签下面的第一个子标签
qname：标签的名称
elements(qname)：获取标签下面是这个名称的所有子标签（一层）
elements():获取标签下面所有一层子标签
六、使用dom4j查询xml
查询所有name元素里面的值
1.创建解析器
2.得到document
3.得到根节点 getRootElement()
4.得到所有的p1标签:elements("p1") ； 返回list集合；遍历list得到每一个p1
5.得到name
6.得到name里面的值
public static void selectName() throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read("src/p1.xml");
Element root = document.getRootElement();
java.util.List<Element> list = root.elements("p1");
for (Element element : list) {
Element name1 = element.element("name");
String s = name1.getText();
System.out.println(s);
}
}
查询第一个name元素的值：
1.创建解析器
2.得到document
3.得到根节点 getRootElement()
4.得到第一个p1元素：element（"p1"）；返回Element
5.得到p1下面的name元素：element（"name"）；返回Element
6.得到name元素里面的值：getText方法
public static void selectNmae1() throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read("src/p1.xml");
Element root = document.getRootElement();
Element p1 = root.element("p1");
Element name1 = p1.element("name");
String s1 = name1.getText();
System.out.println(s1);
}
七、使用dom4j实现添加操作
在第一个标签末尾添加一个元素<sex>nv</sex>
public static void addSex() throws Exception {
SAXReader saxReader = new SAXReader();//创建解析器
Document document = saxReader.read("src/p1.xml");//得到document
Element root = document.getRootElement();//得到根节点
Element p1 = root.element("p1");//得到第一个p1元素
Element sex = p1.addElement("sex");//在p1下面直接添加元素
sex.setText("nv");//在sex下面添加文本
OutputFormat format = OutputFormat.createPrettyPrint();//回写xml
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/p1.xml"), format);
xmlWriter.write(document);
xmlWriter.close();
}
八、使用dom4j在特定位置添加元素
在第一个p1下面的age标签之前添加<school>ecit.edu.cn</school>
public static void addAgeBefore() throws Exception {
SAXReader saxReader = new SAXReader();//创建解析器
Document document = saxReader.read("src/p1.xml");//得到document
Element root = document.getRootElement();//得到根节点
Element p1 = root.element("p1");//得到第一个p1元素
java.util.List<Element> list = p1.elements();//获取p1下面的所有元素
Element school = DocumentHelper.createElement("school");//创建元素使用
school.setText("ecit");//在school下面创建文本
list.add(1, school);//在特定位置添加
OutputFormat format = OutputFormat.createPrettyPrint();//回写xml
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/p1.xml"), format);
xmlWriter.write(document);
xmlWriter.close();
}
对得到的document 的操作和回写xml的操作封装成方法
也可以把传递的文件路径，封装成一个常量
好处：可以提高开发速度，提高代码维护性
public class Dom4jUtils {
public static final String PATH = "src/p1.xml";
public static Document getDocument(String path) {
try {
SAXReader reader = new SAXReader();// 创建解析器
Document document = reader.read(path);
return document;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static void xmlWriters(String path, Document document) {
try {
OutputFormat format = OutputFormat.createPrettyPrint();// 回写xml
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(path), format);
xmlWriter.write(document);
xmlWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
九、使用dom4j实现修改节点操作
修改第一个p1下面age元素的值<age>30</age>
public static void modifyAge() {
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);//得到document
Element root = document.getRootElement();//得到根节点
Element p1 = root.element("p1");//得到p1
Element age = p1.element("age");//得到第一个p1元素
age.setText("300");//修改值是300
Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);//回写xml
}
十、使用dom4j实现删除节点的操作
删除第一个下面 <school>ecit</school> 元素
public static void delSch() {
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);//得到document
Element root = document.getRootElement();//得到根节点
Element p1 = root.element("p1");//得到第一个p1元素
Element school = p1.element("school");//得到p1下面的school标签
p1.remove(school);//通过父节点删除
Dom4jUtils.xmlWriters(Dom4jUtils.PATH, document);//回写xml
}
十一、使用dom4j获取属性的操作
获取第一个p1里面的属性id1的值
public static void getValues() {
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
Element root = document.getRootElement();
Element p1 = root.element("p1");
String id1 = p1.attributeValue("id1");//获取属性值attributeValue()；
System.out.println(id1);
}
十二、XPATH的简介
可以直接获取到某个元素
- 第一种形式：
/AAA/DDD/BBB:表示一层一层的，AAA下面的DDD下面的BBB - 第二种形式：
//BBB:表示名称是BBB，都可以得到 - 第三种形式：
/*：所有元素 - 第四种形式：
BBB[1]:表示第一个BBB元素
BBB[last()]：表示最后一个BBB元素 - 第五种形式：
//BBB[@id]：表示只有BBB元素上面有id属性，都得到 - 第六种形式：
//BBB[@id='b1']：表示元素名称是BBB，在BBB上面有id属性，并且id属性值是b1
十三、使用dom4j支持XPATH的操作
默认情况下dom4j不支持XPATH
需要引入支持XPATH的包，使用jaxen-1.1-beta-6.jar，导入到项目中
在dom4j里面提供了两个方法用来支持XPATH
selectNodes("xpath表达式")：获取多个节点
selectSingleNode("xpath表达式")：获取一个节点
使用XPATH实现：查询xml中所有name元素的值
public class TestDemo4jXpath {
public static void main(String[] args) throws Exception {
test1();
}
public static void test1() throws Exception {
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
Element root = document.getRootElement();
List<Node> list = root.selectNodes("//name");// 得到name所有元素
for (Node node : list) { // node是每一个name元素
String s = node.getText();// 得到name元素里面的值
System.out.println(s);
}
}
}
使用XPATH实现：获取第一个p1下面的name的值
public static void test2() {
Document document = Dom4jUtils.getDocument(Dom4jUtils.PATH);
Element root = document.getRootElement();
Node name1 = root.selectSingleNode("//p1[@id1='aaa']/name");
String s = name1.getText();
System.out.println(s);
}
十四、实现简单的学术管理系统
使用xml当做数据，存储学生信息
//student.xml
<student>
<stu>
<id>100</id>
<name>zhangsan</name>
<age>20</age>
</stu>
<stu>
<id>200</id>
<name>lisi</name>
<age>30</age>
</stu>
<stu>
<id>1234</id>
<name>miao</name>
<age>12</age>
</stu>
</student>
public class Student {
private String id;
private String name;
private String age;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
}
}
//通过id添加信息
public class StrService {
public static void addStu(Student student) throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read("src/student.xml");
Element root = document.getRootElement();
//在根节点上面添加stu
Element stu = root.addElement("stu");
//在stu上面依次添加id name age标签
Element id1 = stu.addElement("id");
Element name1 = stu.addElement("name");
Element age1 = stu.addElement("age");
//在id name age上面依次添加值
id1.setText(student.getId());
name1.setText(student.getName());
age1.setText(student.getAge());
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/student.xml"), format);
xmlWriter.write(document);
xmlWriter.close();
}
}
//删除信息
public static void delStu(String id) throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read("src/student.xml");
List<Node> list = document.selectNodes("//id");//获取所有id
for (Node node : list) {//node是每一个id的元素
String idv = node.getText();//得到id的值
if(idv.equals(id)) {//判断idv和传递的id是否相同
Element stu = node.getParent();//得到stu节点
Element student = stu.getParent();//得到stu的父节点
student.remove(stu);//删除stu
}
}
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream("src/student.xml"), format);
xmlWriter.write(document);
xmlWriter.close();
}
//通过id查询信息
public static Student getStu(String id) throws Exception {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read("src/student.xml");
List<Node> list = document.selectNodes("//id");
Student student = new Student();
for (Node node : list) {//node是每一个id节点
String idv = node.getText();//得到id的值
if(idv.equals(id)) {//判断idv和传递的值是否相同
Element stu = node.getParent(); //获取id的父节点stu
String name1 = stu.element("name").getText();//通过stu获取name的值
String age1 = stu.element("age").getText();//通过stu获取age的值
student.setId(idv);
student.setAge(age1);
student.setName(name1);
}
}
return student;
}
//测试
public class TestStu {
public static void main(String[] args) throws Exception {
testAdd();
testDel();
}
public static void testAdd() throws Exception {
Student stu = new Student();
stu.setAge("12");
stu.setId("1234");
stu.setName("miao");
StrService.addStu(stu);
}
}
public static void testDel() throws Exception {
StrService.delStu("1234");//删除id为1234的信息
}
public static void testStr() throws Exception {//查询id为12356的信息
Student stu = StrService.getStu("12356");
System.out.println(stu.toString());
}
}
