XML编程与约束-优快云博客

XML编程

主要内容

l XML及其语法

l XML约束之DTD

l XML编程(CRUD---CreateRead Update Delete)

l XML约束之Schema

XML及其语法

什么是XML

l XML是指可扩展标记语言(eXtensibleMarkup Language)，它是一种标记语言，很类似HTML。它被设计的宗旨是传输数据，而非显示数据。

l XML标签没有被预定义，需要用户自行定义标签。

l XML技术是W3C组织(WorldWide Web Consortium万维网联盟)发布的，目前遵循的是W3C组织于2000年发布的XML1.0规范。

l XML被广泛认为是继Java之后在Internet上最激动人心的新技术。

XML技术用于解决什么问题？

l 在现实生活中存在大量有关系的数据，如右图所示。

l 问题：这样的数据该如何表示并交给计算机处理呢？

XML技术用于解决什么问题？

l XML语言出现的根本目的在于描述向上图那种有关系的数据。

l XML是一种通用的数据交换格式。

l 在XML语言中，它允许用户自定义标签。一个标签用于描述一段数据；一个标签可分为开始标签和结束标签，在起始标签之间，又可以使用其它标签描述其它数据，以此来实现数据关系的描述。

l XML中的数据必须通过软件程序来解析执行或显示，如IE；这样的解析程序称之为Parser(解析器)。

<?xmlversion="1.0" encoding="UTF-8"?>

<中国>

<北京>

<海淀></海淀>

<丰台></丰台>

</北京>

<山东>

<济南></济南>

<青岛></青岛>

</山东>

<湖北>

<武汉></武汉>

<荆州></荆州>

</湖北>

</中国>

XML常见应用

l 在Java开发中，传统的配置文件是*.properties属性文件(key=value)，而XML表示的数据更为丰富。

l XML技术除用于描述有关系的数据外，还经常用作软件配置文件，以描述程序模块之间的关系。(如后面将要学习到的Struts、Spring和Hibernate都是基于XML作为配置文件的)

l 在一个软件系统中，通过XML配置文件可以提高系统的灵活性。即程序的行为是通过XML文件来配置的，而不是硬编码。

XML文档的组成

l 一个XML文件一般由以下几部分组成：

• 文档声明

• 元素

• 元素的属性

• 注释

• CDATA区

• 特殊字符

• 处理指令(PI:ProcessingInstruction)

文档声明

l 在编写XML文档时，需要先使用文档声明来声明XML文档。且必须出现在文档的第一行。

l 最简单的语法:<?xml version=“1.0”?>

l 用encoding属性说明文档所使用的字符编码，默认为UTF-8。保存在磁盘上的文件编码要与声明的编码一致。

如：<?xmlversion=“1.0”encoding=“GB2312”?>

l 用standalone属性说明文档是否独立，即是否依赖其他文档。

如：<?xmlversion=“1.0”standalone=“yes”?>

元素(1)

l XML元素指XML文件中出现的标签。一个标签分为起始和结束标签(不能省略)。一个标签有如下几种书写形式：

• 包含标签主体：<mytag>somecontent</mytag>

• 不含标签主体：<mytag/> == <mytag></mytag> <br/><hr/>

l 一个标签中可以嵌套若干子标签，但所有标签必须合理的嵌套，不允许有交叉嵌套。

• <mytag1><mytag2></mytag1></mytag2> WRONG

l 一个XML文档必须有且仅有一个根标签，其他标签都是这个根标签的子标签或孙标签。

元素(2)

l XML中不会忽略主体内容中出现的空格和换行。

元素(3)--元素命名规范

l 元素(标签)的名称可以包含字母、数字、减号、下划线和英文句点，但必须遵守下面的一些规范：

• 严格区分大小写；<P> <p>

• 只能以字母或下划线开头；abc _abc

• 不能以xml(或XML、Xml等)开头----W3C保留日后使用；

• 名称字符之间不能有空格或制表符；ab

• 名称字符之间不能使用冒号；(有特殊用途)

元素的属性

l 一个元素可以有多个属性，每个属性都有它自己的名称和取值，例如：<mytagname=“value”…/>

l 属性值一定要用引号(单引号或双引号)引起来。

l 属性名称的命名规范与元素的命名规范相同

l 元素中的属性是不允许重复的

l 在XML技术中，标签属性所代表的信息也可以被改成用子元素的形式来描述，例如：

注释

l XML中的注释语法为：

l 注意：

• XML声明之前不能有注释

• 注释不能嵌套，例如：

CDATA区

l CDATA是CharacterData的缩写

l 作用：把标签当做普通文本内容；

l 语法：<![CDATA[内容]]>

特殊字符

l 对于一些特殊字符，若要在元素主体内容中显示，必须进行转义。

处理指令

l 处理指令，简称PI(ProcessingInstruction)。

l 作用：用来指挥软件如何解析XML文档。

l 语法：必须以“<?”作为开头，以“?>”作为结尾。

l 常用处理指令：

• XML声明：<?xmlversion=“1.0”encoding=“GB2312”?>

• xml-stylesheet指令：

• 作用：指示XML文档所使用的CSS样式XSL。

XML约束之DTD

为什么需要约束

l XML都是用户自定义的标签，若出现小小的错误，软件程序将不能正确地获取文件中的内容而报错。(如：Tomcat)

l XML技术中，可以编写一个文档来约束一个XML的书写规范，这个文档称之为约束。

l 两个概念：

• 格式良好的XML：遵循XML语法的XML（不一定是有效的）

• 有效的XML：遵循约束文档的XML（有效的一定就是格式良好的）

l 总之：约束文档定义了在XML中允许出现的元素名称、属性及元素出现的顺序等等。

常用的约束技术

l XML DTD

l XDR

l SOX

l XML Schema

DTD快速入门

l DTD(Document TypeDefinition)：文档类型定义。

l 作用：约束XML的书写规范

验证XML的有效性

l 如何根据DTD中定义的内容来验证XML书写是否正确呢？

l 答：需要软件程序，即解析器

l 根据能否对XML文档进行约束模式校验，可以将解析器分为两类：

• 非校验解析器，如IE

• 校验解析器

编程校验XML文档的正确性

编写DTD的方式

l DTD约束文档可以在XML文档中直接定义，也可以作为单独的文档进行编写(单独的文档必须以UTF-8编码进行保存)。

l 在XML文档中编写DTD示例

引入外部DTD文档

l XML使用DOCTYPE声明语句来指明它所遵循的DTD文档，有两种形式：

• 当引用的DTD文档在本地时，采用如下方式：

<!DOCTYPE根元素SYSTEM“DTD文档路径”>

如：<!DOCTYPE书架SYSTEM “book.dtd”>

• 当引用的DTD文档在公共网络上时，采用如下方式：

<!DOCTYPE根元素PUBLIC“DTD名称”“DTD文档的URL”>

如：<!DOCTYPEweb-app PUBLIC

"-//Sun Microsystems, Inc.//DTD WebApplication 2.3//EN"

"http://java.sun.com/dtd/web-app_2_3.dtd">

DTD语法细节

l DTD文档的语法主要涉及以下内容的定义：

• 定义元素

• 定义属性

• 定义实体

DTD-定义元素

l 在DTD文档中使用ELEMENT关键字来声明一个XML元素。

l 语法：<!ELEMENT 元素名称使用规则>

• 使用规则：

• (#PCDATA):指示元素的主体内容只能是普通的文本.(ParsedCharacter Data)

• EMPTY：用于指示元素的主体为空。比如<br/>

• ANY:用于指示元素的主体内容为任意类型。

• (子元素)：指示元素中包含的子元素

• 定义子元素及描述它们的关系:

• 如果子元素用逗号分开，说明必须按照声明顺序去编写XML文档。

如: <!ELEMENT FILE (TITLE,AUTHOR,EMAIL)

• 如果子元素用“|”分开，说明任选其一。

如:<!ELEMENT FILE (TITLE|AUTHOR|EMAIL)

• 用+、*、？来表示元素出现的次数

• 如果元素后面没有+*?:表示必须且只能出现一次

• +:表示至少出现一次，一次或多次

• *：表示可有可无，零次、一次或多次

• ?:表示可以有也可以无，有的话只能有一次。零次或一次

• 如：<!ELEMENT MYFILE ((TITLE, AUTHOR?,EMAIL) | COMMENT)>

DTD--定义属性1

l 在DTD文档中使用ATTLIST关键字来为一个元素声明属性。

l 语法：

DTD--定义属性2

l 属性值类型：

• CDATA：表示属性的取值为普通的文本字符串

• ENUMERATED (DTD没有此关键字)：表示枚举，只能从枚举列表中任选其一，如(鸡肉|牛肉|猪肉|鱼肉)

• ID:表示属性的取值不能重复

l 设置说明

• #REQUIRED：表示该属性必须出现

• #IMPLIED：表示该属性可有可无

• #FIXED:表示属性的取值为一个固定值。语法：#FIXED"固定值"

• 直接值：表示属性的取值为该默认值

DTD--定义属性示例

l ID表示属性的设置值为一个唯一值。

<?xml version ="1.0" encoding="GB2312" ?>

<!DOCTYPE 联系人列表[

<!ELEMENT 联系人列表 ANY>

<!ELEMENT 联系人(姓名,EMAIL)>

<!ELEMENT 姓名(#PCDATA)>

<!ELEMENT EMAIL(#PCDATA)>

<!ATTLIST 联系人编号 ID #REQUIRED>

]>

<联系人列表>

<联系人编号=“a">

<姓名>张三</姓名>

<EMAIL>zhang@it315.org</EMAIL>

</联系人>

<联系人编号=“b">

<姓名>李四</姓名>

<EMAIL>li@it315.org</EMAIL>

</联系人>

</联系人列表>

DTD--定义实体

l 定义实体就是为一段内容指定一个名称，使用时通过这个名称就可以引用其所代表的内容。

l 在DTD文档中使用ENTITY关键字来声明一个实体。

l 实体可分为：引用实体和参数实体，两者的语法不同

定义引用实体

l 概念：在DTD中定义，在XML中使用

l 语法：<!ENTITY 实体名称“实体内容”>

l 引用方式（注意是在XML中使用）：&实体名称;

定义参数实体(了解)

l 概念：在DTD中定义，在DTD中使用

l 语法：<!ENTITY % 实体名称“实体内容”>

l 引用方式（注意是在DTD中使用）：%实体名称;

XML及DTD练习

l XML练习题

l DTD实例

XML编程(用Java编写解析器)

Java解析XML概述

l XML解析方式分为两种：DOM方式和SAX方式

• DOM：DocumentObject Model，文档对象模型。这种方式是W3C推荐的处理XML的一种方式。

• SAX：SimpleAPI for XML。这种方式不是官方标准，属于开源社区XML-DEV，几乎所有的XML解析器都支持它。

l XML解析开发包

• JAXP：是SUN公司推出的解析标准实现。JDK

• Dom4J：是开源组织推出的解析开发包。(牛，大家都在用，包括SUN公司的一些技术的实现都在用)

• JDom：是开源组织推出的解析开发包。

JAXP

l JAXP:(Java API for XMLProcessing)开发包是JavaSE的一部分，它由以下几个包及其子包组成：

• org.w3c.dom:提供DOM方式解析XML的标准接口

• org.xml.sax:提供SAX方式解析XML的标准接口

• javax.xml:提供了解析XML文档的类

l javax.xml.parsers包中，定义了几个工厂类。我们可以通过调用这些工厂类，得到对XML文档进行解析的DOM和SAX解析器对象。

• DocumentBuilderFactory

• SAXParserFactory

使用JAXP进行DOM解析

l javax.xml.parsers 包中的DocumentBuilderFactory用于创建DOM模式的解析器对象，DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回。

获得JAXP中的DOM解析器

l 调用DocumentBuilderFactory.newInstance() 方法得到创建DOM 解析器的工厂。

l 调用工厂对象的newDocumentBuilder方法得到DOM 解析器对象。

l 调用DOM 解析器对象的parse()方法解析XML 文档，得到代表整个文档的Document对象，进行可以利用DOM特性对整个XML文档进行操作了。

Tip：DOM编程

l DOM模型(document object model)

• DOM解析器在解析XML文档时，会把文档中的所有元素，按照其出现的层次关系，解析成一个个Node对象(节点)。

• 在dom中，节点之间关系如下：

• 位于一个节点之上的节点是该节点的父节点(parent)

• 一个节点之下的节点是该节点的子节点（children）

• 同一层次，具有相同父节点的节点是兄弟节点（sibling）

• 一个节点的下一个层次的节点集合是节点后代(descendant)

• 父、祖父节点及所有位于节点上面的，都是节点的祖先(ancestor)

• 节点类型（下页ppt）

Node对象

l Node对象提供了一系列常量来代表结点的类型，当开发人员获得某个Node类型后，就可以把Node节点转换成相应的节点对象(Node的子类对象)，以便于调用其特有的方法。（查看API文档）

l Node对象提供了相应的方法去获得它的父结点或子结点。编程人员通过这些方法就可以读取整个XML文档的内容、或添加、修改、删除XML文档的内容了。

DOM方式解析XML文件

l DOM解析编程

• 1、得到某个具体的节点内容

• 2、遍历所有元素节点

• 3、修改某个元素节点的主体内容

• 4、向指定元素节点中增加子元素节点

• 5、向指定元素节点上增加同级元素节点

• 6、删除指定元素节点

• 7、操作XML文件属性

<?xml version="1.0" encoding="UTF-8" standalone="no"?><exam>
	<student examid="323" idcard="111">
		<name>Jim</name>
		<location>沈阳</location>
		<grade>89</grade>
	<age>23</age></student>
	<student examid="444" idcard="333">
		<age>24</age>
		<name>Tom</name>
		<location>大连</location>
		<grade>97</grade>
	</student>
</exam>

package cn.simplefile.xml;

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;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
 * 实现Jaxp 的增删检查操作
 */
public class JaxpCURD {
	public static void main(String[] args) throws Exception {
		// get DocumentBuilder
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();
		
		//get xml file  Document
		Document document  = db.parse("src/student.xml");
//		test1(document);
//		test2(document);
//		test3(document);
//		test4(document);
//		test5(document);
//		test6(document);
//		test7(document);
		test8(document);
		
		
	}
	
	//获取某个节点的内容
	private static void test1(Document document){
		NodeList list = document.getElementsByTagName("name");
//		System.out.println(list.getLength());
		Node node = list.item(1);
		System.out.println(node.getTextContent());
	}
	
	// 遍历所有元素的节点：递归
	private static void test2(Node node){
		// 判断node是否是元素节点
		if (node.getNodeType() == Node.ELEMENT_NODE) {
			System.out.println(node.getNodeName());
		}
		// 判断它是否有孩子节点，循环遍历		
		NodeList children = node.getChildNodes();
		for (int i = 0; i < children.getLength(); i++) {
			Node n = children.item(i);
			// 递归调用
			test2(n);
		}
	}
	
	// 修改某个节点的主体内容
	private static void test3(Document document) throws Exception{
		// 得到某个第一个节点的内容容
		Node node = document.getElementsByTagName("name").item(0);
		// 修改主体内容
		node.setTextContent("Jim");
		// 更新XML文档
			// 利用Transformer的transform更新文档
			// 得到Transformer对象
		TransformerFactory tf = TransformerFactory.newInstance();
		Transformer ts = tf.newTransformer();
		ts.transform(new DOMSource(document), new StreamResult("src/student.xml"));
	}
	
	// 向指定元素节点中增加子元素节点
	private static void test4(Document document) throws Exception{
		// 得到节点
		Node node = document.getElementsByTagName("student").item(0);
		// 创建新节点，并设置主体内容
		Element newEle = document.createElement("age");
		newEle.setTextContent("23");
		// 建立和原节点的关系
		node.appendChild(newEle);
		// 更新xml文档
		TransformerFactory tf = TransformerFactory.newInstance();
		Transformer ts = tf.newTransformer();
		ts.transform(new DOMSource(document), new StreamResult("src/student.xml"));
	}
	
	// 向指定元素节点上增加同级元素节点
	private static void test5(Document document) throws Exception{
		// 找到需要的节点
		Node node = document.getElementsByTagName("name").item(1);
		// 创建新的节点
		Element e = document.createElement("age");
		e.setTextContent("24");
		// 由父节点完成插入操作
		node.getParentNode().insertBefore(e, node);
		// 更新xml文档
		TransformerFactory tf = TransformerFactory.newInstance();
		Transformer ts = tf.newTransformer();
		ts.transform(new DOMSource(document), new StreamResult("src/student.xml"));
	}
	
	// 删除指定元素节点
	private static void test6(Document document) throws Exception{
		// 得到内部节点
		Node node = document.getElementsByTagName("name").item(1);
		// 用其父节点删除
		node.getParentNode().removeChild(node);
		// 更新xml文档
		TransformerFactory tf = TransformerFactory.newInstance();
		Transformer ts = tf.newTransformer();
		ts.transform(new DOMSource(document), new StreamResult("src/student.xml"));
	}
	
	// 操作节点的属性
		// 得到节点的属性
	private static void test7(Document document){
		// 得到节点元素
		Node node = document.getElementsByTagName("student").item(0);
		// 设置节点属性
			// 如果节点是元素节点 则可以设置属性
		if (node.getNodeType() == Node.ELEMENT_NODE) {
			Element e = (Element)node;
			System.out.println(e.getAttribute("examid"));
		}
	}
	
	// 设置节点的属性
	private static void test8(Document document) throws Exception{
		// 得到节点元素
		Node node = document.getElementsByTagName("student").item(0);
		// 设置属性
		Element e = (Element) node;
		e.setAttribute("examid", "323");
		// 更新xml文档
		TransformerFactory tf = TransformerFactory.newInstance();
		Transformer ts = tf.newTransformer();
		ts.transform(new DOMSource(document), new StreamResult("src/student.xml"));
	}
}

l DOM编程练习

1、以如下格式的exam.xml文件为例

<?xml version="1.0" encoding="UTF-8"standalone="no"?>

<exam>

</student>

</student>

</exam>

２、编程实现如下功能

３、实现学生信息的添加

４、实现学生信息的查询

５、实现学生的删除功能

先建立XML文档，然后再在不同的包下写代码

cn.example.util包

package cn.example.utils;

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;

/**
 * 工具类
 * 功能： 获取Document对象,更新xml文档
 */
public class XmlUtil {
	// 获取Document对象
	public static Document getDocument() throws Exception{
		DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
		Document document = db.parse("src/student.xml");
		return document;
	}
	
	// 更新xml文档
	public static void write2Xml(Document document) throws Exception{
		Transformer tf = TransformerFactory.newInstance().newTransformer();
		tf.transform(new DOMSource(document), new StreamResult("src/student.xml"));
	}

}

cn.example.domain包

package cn.example.domain;
// 代表学生信息的JavaBeann
public class Student {
	private String name;
	private String location;
	private float grade;
	private String examid;// 准考证号 
	private String idcard;// 身份证号
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getLocation() {
		return location;
	}
	public void setLocation(String location) {
		this.location = location;
	}
	public float getGrade() {
		return grade;
	}
	public void setGrade(float grade) {
		this.grade = grade;
	}
	public String getExamid() {
		return examid;
	}
	public void setExamid(String examid) {
		this.examid = examid;
	}
	public String getIdcard() {
		return idcard;
	}
	public void setIdcard(String idcard) {
		this.idcard = idcard;
	}
	@Override
	public String toString() {
		return "姓名=" + name + ", 地址=" + location + ", 成绩="
				+ grade + ", 准考证号=" + examid + ", 身份证号=" + idcard;
	}
		
}

cn.example.dao包

package cn.example.dao;

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

import cn.example.domain.Student;
import cn.example.utils.XmlUtil;

/**
 * 完成学生类的增删改查
 */
public class StudentDao {
	boolean result = false;
	
	// 添加学生
	public boolean addStudent(Student student) {
		try {
			// 得到Document对象
			Document document = XmlUtil.getDocument();
			// 创建新元素节点和属性
			Element stu = document.createElement("student");
			stu.setAttribute("examid", student.getExamid());
			stu.setAttribute("idcard", student.getIdcard());
			// 创建子元素节点
			Element name = document.createElement("name");
			name.setTextContent(student.getName());
			Element location = document.createElement("location");
			location.setTextContent(student.getLocation());
			Element grade = document.createElement("grade");
			grade.setTextContent(student.getGrade() + "");
			// 确定他们之间的关系
			stu.appendChild(name);
			stu.appendChild(location);
			stu.appendChild(grade);
			document.getElementsByTagName("exam").item(0).appendChild(stu);
			// 　更新XML文档
			XmlUtil.write2Xml(document);
			result = true;
		} catch (Exception e) {
			// 异常转义，由编译异常转为运行异常
			throw new RuntimeException(e);
		}
		return result;
	}

	// 删除学生
	public boolean removeStudent(String name) {
		boolean result = false;
	
		try {
			// 得到DOM对象
			Document document = XmlUtil.getDocument();
			// 得到要删除的节点
			NodeList list = document.getElementsByTagName("name");
			// 循环遍历所有节点
			for (int i = 0; i < list.getLength(); i++) {
				Node node = list.item(i);
				// 利用根节点删除父节点
				if (node.getTextContent().equals(name.trim())) {
					node.getParentNode().getParentNode().removeChild(node.getParentNode());
					// 更新XML文档
					XmlUtil.write2Xml(document);
					result = true;
				}
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		return result;
	}

	// 查询学生信息
	public Student queryStudent(String examid) {
		Student student = null;
		try {
			// 创建dom对象
			Document document = XmlUtil.getDocument();
			// 得到所有的student元素
			NodeList list = document.getElementsByTagName("student");
			// 循环遍历匹配与examid相等的节点
			for (int i = 0; i < list.getLength(); i++) {
				Node node = list.item(i);
				Element e = (Element) node;
				if (e.getAttribute("examid").equals(examid.trim())) {
					// 获取该节点的信息
					student = new Student();
					student.setExamid(examid);
					student.setIdcard(e.getAttribute("idcard"));
					student.setName(e.getElementsByTagName("name").item(0).getTextContent());
					student.setLocation(e.getElementsByTagName("location").item(0).getTextContent());
					student.setGrade(Float.parseFloat(e.getElementsByTagName("grade").item(0).getTextContent()));
				}
			}
			
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
		return student;
	}
}

cn.example.test包

package cn.example.test;

import cn.example.dao.StudentDao;
import cn.example.domain.Student;

public class StudentDaoTest {
	public static void main(String[] args) {
		Student student = new Student();
		student.setName("Tam");
		student.setExamid("12312");
		student.setGrade(100f);
		student.setIdcard("123121");
		student.setLocation("Hongkong");
		
		StudentDao dao = new StudentDao();
		dao.addStudent(student);
		
//		dao.removeStudent("Tam");
		
		Student s = dao.queryStudent("12312");
		System.out.println(s);
	}
}

cn.example.ui包

package cn.example.ui;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import cn.example.dao.StudentDao;
import cn.example.domain.Student;

/**
 * 用户操作界面
 */
public class Main {
	public static void main(String[] args) {
		StudentDao dao = new StudentDao();
		// 打印操作提示
		System.out.println("添加用户：（a）\t删除用户：（b）\t查询成绩：（c）");
		System.out.println("请输入操作类型:");
		// 接收用户的操作
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(
					System.in));
			String operation = br.readLine();
			if ("a".equals(operation)) {
				// 添加操作
				System.out.println("请输入学生姓名：");
				String name = br.readLine();
				System.out.println("请输入学生准考证号：");
				String examid = br.readLine();
				System.out.println("请输入学生身份证号：");
				String idcard = br.readLine();
				System.out.println("请输入学生所在地：");
				String location = br.readLine();
				System.out.println("请输入学生成绩：");
				String grade = br.readLine();
				Student student = new Student();
				student.setExamid(examid);
				student.setIdcard(idcard);
				student.setName(name);
				student.setGrade(Float.parseFloat(grade));
				student.setLocation(location);
				boolean result = dao.addStudent(student);
				if (result) {
					System.out.println("----添加数据成功-----");
				} else {
					System.out.println("----添加数据失败-----");
				}
			} else if ("b".equals(operation)) {
				// 删除操作
				System.out.println("请输入删除的学生的姓名：");
				String name = br.readLine();
				boolean result = dao.removeStudent(name);
				if (result) {
					System.out.println("----已成功删除学生信息-----");
				} else {
					System.out.println("----删除学生信息失败-----");
				}

			} else if ("c".equals(operation)) {
				// 查询操作
				System.out.println("请输入查询的学生的准考证号");
				String examid = br.readLine();
				Student student = dao.queryStudent(examid);
				if (student == null) {
					System.out.println("学生不存在");
				}else{
					System.out.println(student);
				}
			} else {
				System.out.println("输入错误");
			}
		} catch (Exception e) {
			System.out.println("输入错误");
		}

	}
}