没账号了

java基础 - 2

JAVA编程语言和JDBC

编写正确且遵守规范的Java程序，可以无需重新编译就在任何启用Java技术的平台上运行。Java编程语言彻底地进行了规定。根据定义，启用Java技术的平台必须支持已知的核心库。java.sql包或javax.sql包或者JDBC就是这样一个库，它们可以视为ODBC的可移植版本，且其本身就是重大的标准。JAVA编程语言和JDBC一起使用，可以给编写数据库应用程序提供正确的可移植性解决方案。注意：虽然可移植的应用程序和标准数据库界面都是重大的成果，但不要忘记，因为历史，竞争，有时是没有意思的原因，各种数据库并没有彻底地进行标准化。这可能意味着，必须根据（甚至同一平台上的）特定数据库的性能或内在的调整来寻找"最低公分母"。无论采用标准的SQL，ODBC，JDBC，或其他解决方案，都存在这个问题。最后需要指明的是JDBC驱动程序就是JAVA类，它实现JDBC驱动程序接口，并可以为特别的数据库转换程序（一般是SQL）请求。无疑，驱动程序在这里起了重要作用。大多数的数据库供应商现在都提供驱动程序，以实现特定系统的JDBC API。这些通常都是免费提供的。第三方驱动程序也可以获得，成本从免费到费用浩大的都有。

JDBC编程的核心包为java.sql包，其结构如下图：

JDBC编程的步骤

第一：加载驱动程序

为了与特定的数据库相连，JDBC必须加载相应的驱动程序。如：

try {

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

// 加载Oracle的驱动程序

Class.forName("oracle.jdbc.driver.OracleDriver");

// 加载Microsoft SQL Server的驱动程序 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

第二：要将"驱动程序"传递到DriverManager,然后获得"连接"。

DriverManager类的getConnection(String url,String user, String password)方法用于建立与某个数据库的连接。每个JDBC驱动程序使用一个专门的JDBC URL作为自我标识的一种方法。

JDBC URL的格式为：jdbc : <子协议名> : <子名称>

子协议（sub-protocol）与JDBC驱动程序有关，可以是odbc,oracle,db2，mysql，microsoft等等，根据实际的JDBC驱动程序厂商而不同。数据库定位器（database locator）是与驱动程序有关的指示器，用于唯一指定应用程序要和哪个数据库进行交互。根据驱动程序的类型，该定位器可能包括主机名，端口和数据库系统名。

try{

String url="jdbc:odbc:myodbc";

Connection con=DriverManager.getConnection(url);

// 或者

Connection con=

DriverManager.getConnection(url,user,password);

}catch(SQLException e){

e.printStackTrace();

}

// 1.Microsoft SQL Server的URL

url="jdbc:Microsoft:sqlserver://192.168.0.1:1433;databasename=mydb";

127.0.0.1 也可以用字符串 "localhost"代替

// 2.Oracle 的URL

url="jdbc:oracle:thin:@192.168.0.1:1521:goudan";

第三：创建语句，Statement ,PreparedStatement,或CallableStatement，并将它们用于更新数据库或执行查询。

Statement 对象用于将 SQL 语句发送到数据库中。实际上有三种 Statement 对象，它们都作为在给定连接上执行 SQL语句的对象：Statement、PreparedStatement（继承Statement ）和 CallableStatement（继承PreparedStatement）。它们都专用于发送特定类型的 SQL 语句： Statement 对象用于执行不带参数的简单 SQL语句；PreparedStatement 对象用于执行带或不带 IN 参数的预编译 SQL 语句；CallableStatement对象用于执行对数据库已存储过程的调用。

第四：查询返回包含有已请求数据的ResultSet，该ResultSet是按类型检索的。

ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法（这些get方法可以访问当前行中的不同列）提供了对这些行中数据的访问。

第五：DatabaseMetaData和ResultSetMetaData接口可以用来提供有关数据库或ResultSet的信息。

实例分析

例1：通过ODBC建立连接

? 配置WINDOWS下ODBC详细步骤参考 <连接步骤.doc>>

? 代码如下：

import java.sql.*;

public class ODBCTest {

public static void main(String[] args) {

Connection con = null;

try {

// 加载ODBC驱动

（1）Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

// 通过驱动管理器（DriverManager）获得连接

（2）con = DriverManager.getConnection("jdbc:odbc:myodbc",

"pubuse","123");

// 如果连接不成功，就会出现异常，不会执行下面这个语句

System.out.println("connect success!");

} catch (Exception e) {// 如果出现异常，会打印堆栈里异常的信息

e.printStackTrace();

} finally {// 用完后，关闭连接，释放资源

try {

if (con != null) // 防止出现内存泄露

con.close();

} catch (Exception e) {

e.printStackTrace();

}

例2：通过SQLSERVER 提供的驱动程序获得连接

? 下面通过SQLSERVER提供的三个驱动获得连接。三个jar文件的名字分别为：msbase.jar,mssqlserver.jar,msutil.jar 然后设置classpath环境变量指向这三个路径。假如这三个文件放在d:\mssqldriver 目录下，如下图所示：

? 然后在系统环境变量classpath里面设置这三个jar文件，这样的话就可以在任何的dos命令窗口里面使用。

也可以在一个dos窗口里面设置。这样的话是只在该窗口下有效。

? 部分代码如下：

………

try {

// 加载SQLSERVER的驱动程序Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

// 通过驱动来获得一个连接

con = DriverManager.getConnection(

"jdbc:microsoft:sqlserver://localhost:1433;"

+ "databasename=pubs", "sa", "");

System.out.println("connect success!");

} catch (Exception e) {

e.printStackTrace();

}

………

例3：通过ORACLE提供的驱动程序获得连接

? 下面介绍通过ORACLE提供的驱动程序获得连接。只有一个jar文件：classes12.jar 同上设置环境变量classpath 指向该jar文件。

部分代码如下

………

try {

// 加载ORACLE9i的驱动程序

Class.forName("oracle.jdbc.driver.OracleDriver");

// 获得连接 oracle数据库的端口号：1521 数据服务器的名字叫itjob

// 登陆的用户名为system，密码为：system (默认密码为manager)

con = DriverManager.getConnection(

"jdbc:oracle:thin:@127.0.0.1:1521:itjob",

"system","system");

System.out.println("con ok");

} catch (Exception e) {

e.printStackTrace();

}

………

例4：通过数据源获得连接

使用JDBC API的一个主要好处就是独立于数据库的编程，因为大部分JDBC应用程序都可以被轻易地转换到不同的数据库。然而，仍然有两个主要的内容与特定的数据库有关，即JDBC Driver类和JDBC URL。

随着JDBC API的升级，数据源技术的引入，可以提高数据库访问的灵活性。本质上，DataSource对象表示一个特殊的数据源。除了将数据库和专门的JDBC驱动程序信息封装到一个单独的，标准化的对象中之外，数据源可以作为Connection工厂，并为设置和获取DataSource对象进行成功操作所需要的特定属性提供方法。DataSource对象可能需要的一些标准属性包括：

? databaseName

? serverName

? portNumber

? username

? password

使用数据源的另一个好处就是和安全有关的敏感信息，如用户名，密码甚至数据库服务器只在一处编码，这可以由系统管理员完成。虽然和DataSource对象的交互可以用图形应用程序完成，但真正看到运行的示例是有指导性的。虽然DataSource对象的概念很简单，但为了在Java应用程序中使用，DataSource对象是使用Java名称和目录接口（JNDI）来引用的。

下面首先介绍下JNDI的相关概念。JNDI是个JAVA API，它包括名称和目录服务器的概念，道理和JDBC与数据库进行通讯的概念差不多。如：硬盘通过与磁道和扇区打交道工作，但用户只关心文件名和目录，文件系统管理名称服务，该服务将给定的文件名和硬盘上特定的位置相关联。另一个简单的示例就是Web，多数用户只关心Web站点的名称，如www.5itjob.com，并不关心底层的IP地址。然而，TCP/IP通讯是通过使用IP地址，而不是人类能看懂的名称进行的。两个表示法之间的转换是通过DNS（域名系统，Domain Name System）完成的。虽然JNDI用自己的方式提供了一个丰富和有用的API，我们的需求却简单得多。简短地说，我们需要知道怎样做四件事：

? 创建名称并将其绑定到一个Java对象

? 查询名称以检索Java对象

? 删除一个名称

? 重新绑定名称到一个新的Java对象

首先要先加载数据源的驱动程序。让环境变量classpath指向下面几个jar文件

2，代码如下：

import java.util.Hashtable;

import javax.naming.*;

import javax.naming.directory.*;

import java.sql.*;

import javax.sql.*;

import com.microsoft.jdbcx.sqlserver.SQLServerDataSource;

public class JNDIServer {

// First we define the relevant parameters for this datasource

private String serverName = "192.168.0.1";

private int portNumber = 1433;

private String login = "student";

private String password = "student";

private String databaseName = "mydb";

private String filePath = "jdbc/mydatasource";

public JNDIServer() {

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY,

"com.sun.jndi.fscontext.RefFSContextFactory");

try {

// 创建初始化上下文环境

Context ctx = new InitialContext(env);

// 如果filePath已经绑定过了，那么先解除绑定

ctx.unbind(filePath);

// 创建SQLServerDataSource

SQLServerDataSource ds = new SQLServerDataSource();

// 设置数据源的参数

ds.setServerName(serverName);

ds.setPortNumber(portNumber);

ds.setDatabaseName(databaseName);

ds.setUser(login);

ds.setPassword(password);

ds.setDescription("JDBC DataSource Connection");

// 绑定 JDBC 数据源

ctx.bind(filePath, ds);

ctx.close();

System.out.println("DataSource Created Success!");

} catch (Exception e) {

e.printStackTrace();

}

public static void main(String args[]) {

new JNDIServer();

}

运行成功后，会在控制台打印：DataSource Created Success!

同时在运行该类所在的磁盘根目录下生成".bindings"文件，如下图：

数据源创建好之后，下面开始使用数据源。

代码如下：

import java.util.Hashtable;

import javax.naming.*;

import java.sql.*;

import javax.sql.*;

public class UseJNDI {

public static void main(String args[]) {

Connection con = null;

try {

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY,

"com.sun.jndi.fscontext.RefFSContextFactory");

Context ctx = new InitialContext(env);

// 获得数据源对象

DataSource ds =

(DataSource) ctx.lookup("jdbc/mydatasource");

// 通过数据源对象获得一个连接

con = ds.getConnection();

// 如果连接不成功，就会出现异常，不会执行下面这个语句

System.out.println("connect success!");

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (con != null)// 用完连接后，要关闭释放

con.close();

} catch (Exception e) {

e.printStackTrace();

}

下面是删除JNDI的引用的代码：

import java.util.Hashtable;

import javax.naming.*;

import java.sql.*;

import javax.sql.*;

public class DeleteJNDI {

public static void main(String[] args) {

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY,

"com.sun.jndi.fscontext.RefFSContextFactory");

try {

Context ctx = new InitialContext(env);

ctx.unbind("jdbc/pubs");

ctx.close();

System.out.println("delete succeed!");

} catch (Exception ex) {

System.err.println("ERROR: " + ex.getMessage());

}

例5：通过连接池获得连接

首先请根据我们在上面创建数据库连接的经验，来思考下列问题：

? 为什么需要连接池？

? 什么是PooledConnection?

? 初始化连接池

? 使用连接池

当使用DriverManager或者DataSource方法来获取数据库连接时，每个对新数据库连接的请求都会导致很大的开销。如果频繁地获取新的连接，将会影响性能问题。这在Web服务器端编程的时候尤为明显。请求一个新的Connection对象会带来大量的开销和很多潜在的错误。为了最小化开销，为什么在我们使用完数据库连接后不是重新使用它们，而是删除它们呢？JDBC设计者在创建接口ConnectionPoolDataSource时使用这种流行的设计模式，这允许您创建数据库连接池，其中的连接在关闭后可以重用，而不是删除。

PooledConnection是一个特殊类型的数据库连接，在关闭时不会被删除，不象常规的Connection对象（当常规的连接不再被使用时，垃圾收集器能删除它们）。相反，PooledConnection被缓存以备将来再次使用，从而可能带来大幅度的性能提升。使用数据库连接池几乎和使用DataSource对象一样。首先，不是创建一个实现DataSource接口的类的实例，而是创建了一个实现了ConnectionPoolDataSource接口的类的实例。可以像以前一样使用JNDI来绑定这个新的数据源到一个名称。要实际使用池化的数据源对象，调用ConnectionPooledDataSource（它接下来会建立数据库连接）上的getPooledConnection（）得到一个PooledConnection对象。要创建将使用的Connection对象，调用PooledConnection对象（而不是以前的DriverManager或DataSource对象）上的getConnection().这种方法的一个额外的好处是，因为是自动处理，用ConnectionPool管理一定数量的数据库连接方便多了。如果你的客户机许可限制了能够同时连接到数据库的客户机的数目，这种自动化可能非常重要。

初始化连接池。下面的例子我们将使用SQLServer2000数据库和i-net软件的第三方驱动程序来创建PooledDataSource.所有与数据库相关的代码都包含在初始化或绑定过程中。

首先应该在classpath里面再指向名字为Merlia.jar的jar文件。

2，代码如下：

import com.inet.tds.PDataSource;

import java.util.Hashtable;

import javax.naming.*;

import com.microsoft.jdbcx.sqlserver.SQLServerDataSource;

public class JNDIofPooledDataSourceTest {

public static void main(String[] args) {

String serverName = "192.168.0.1";

String databaseName = "mydb";

String userName = "student";

String password = "student";

// 通过下面的名字可以获得一个池化的连接

String filePath = "jdbcPool/mydatasource";

int portNumber = 1433;

int poolSize = 10; // We want to create a pool with 10 connections.

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY,

"com.sun.jndi.fscontext.RefFSContextFactory");

try {

Context ctx = new InitialContext(env);

// 创建一个池化的数据源对象

PDataSource ds = new PDataSource();

ds.setServerName(serverName);

ds.setPortNumber(portNumber);

ds.setDatabaseName(databaseName);

ds.setUser(userName);

ds.setPassword(password);

ds.setDescription("i-Net PDataSource");

ds.setMaxPoolSize(poolSize);

// 绑定池化的数据源

ctx.bind(filePath, ds);

ctx.close();

System.out.println("PooledDataSource Created Success!");

} catch (Exception ex) {

System.err.println("ERROR: " + ex.getMessage());

}

一旦初始化了PooledDataSource，就能够在Java应用程序中使用它来创建数据库连接池。请看下面的例子：

import java.util.Hashtable;

import javax.naming.*;

import java.sql.*;

import javax.sql.*;

import java.io.*;

public class UseJNDIOfPooledDataSource {

public static void main(String[] args) {

Connection con = null;

try {

String filePath = "jdbcPool/mydatasource";

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY,

"com.sun.jndi.fscontext.RefFSContextFactory");

Context ctx = new InitialContext(env);

// 通过JNDI获得池化的数据源

ConnectionPoolDataSource ds =

(ConnectionPoolDataSource) ctx .lookup(filePath);

// 通过池化的数据源获得池化的连接

PooledConnection pcon = ds.getPooledConnection();

// 通过池化的连接获得连接

con = pcon.getConnection();

// 如果连接不成功，就会出现异常，不会执行下面这个语句

System.out.println("connect success!");

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (con != null)// 用完连接后，要关闭释放

con.close();

} catch (Exception e) {

e.printStackTrace();

}

例6：总结数据库连接的各种方式

下面通过综合的例子来说明各种数据库的连接。

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.util.Hashtable;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.sql.ConnectionPoolDataSource;

import javax.sql.DataSource;

import javax.sql.PooledConnection;

public class DBCon {

// 通过JDBC-ODBC桥获得连接

public static Connection getOdbcCon(String datasourcename, String name,String password)

throws ClassNotFoundException, SQLException {

String url = "jdbc:odbc:";

Connection con = null;

con = DriverManager.getConnection(url + datasourcename, name, password);

return con;

}

// 通过SQLSERVER的三个驱动，连接SQLSERVER2000数据库

public static Connection getSQLServerCon(String name, String password)

throws ClassNotFoundException, SQLException {

String url = "jdbc:microsoft:sqlserver://127.0.0.1:1433";

Connection con = null;

Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

con = DriverManager.getConnection(url, name, password);

return con;

}

// 通过ORACLE的驱动，连接ORACLE数据库

public static Connection getOracleCon(String name, String password)

throws ClassNotFoundException, SQLException {

Connection con = null;

Class.forName("oracle.jdbc.driver.OracleDriver");

// 获得连接 oracle数据库的端口号为：1521 数据服务器的名字叫goudan(作者外号)

String url = "jdbc:oracle:thin:@127.0.0.1:1521:goudan";

con = DriverManager.getConnection(url, name, password);

return con;

}

// 通过数据源获得连接

public static Connection getConnectionFromDataSource(String filePath)

throws javax.naming.NamingException, SQLException {

Connection con = null;

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY,

"com.sun.jndi.fscontext.RefFSContextFactory");

Context ctx = new InitialContext(env);

DataSource ds = (DataSource) ctx.lookup(filePath);

con = ds.getConnection();

return con;

}

// 通过连接池获得连接

public static Connection getConnectionFromPooledDataSource(String filePath)

throws javax.naming.NamingException, SQLException {

Connection con = null;

Hashtable env = new Hashtable();

env.put(Context.INITIAL_CONTEXT_FACTORY,

"com.sun.jndi.fscontext.RefFSContextFactory");

Context ctx = new InitialContext(env);

ConnectionPoolDataSource ds = (ConnectionPoolDataSource) ctx

.lookup(filePath);

PooledConnection pc = ds.getPooledConnection();

con = pc.getConnection();

return con;

}

内容总结

? JDBC（Java Database Connectivity）是Sun提供的一套数据库编程接口API，由Java语言编写的类、接口组成；通过这些类和接口JAVA可以方便的访问各种数据库中的数据。

? JDBC连接数据库的四种方式

? JDBC-ODBC桥，简单易用，只适用于WINDOW平台，适用于学习JDBC。

? 部分Java驱动程序（native-API partly-Java Driver），少用到。

? 网络驱动程序（net-protocol all-java driver(JDBC Proxy)），应用比较广。

? 纯Java驱动程序（native-protocal all-Java driver）,它直接与数据库进行通讯，最好的一种连接。

? JDBC的编程步骤

? 加载驱动程序；

? 建立到数据库的连接对象Connection；

? 创建语句，Statement ,PreparedStatement,

或CallableStatement，并将它们用于更新数据库或执行查询；

? 查询返回包含有已请求数据的ResultSet；

? 通过SqlServer,Oracle的驱动程序连接数据库；

? JDBC数据源，连接池技术的实现原理及其优点

? 数据源技术的引入，可以提高数据库访问的灵活性

? 使用数据源，和安全有关的敏感信息，如用户名，密码甚至数据库服务器地址等信息只在一处编码。

? 使用连接池可以提高连接数据库的效率。

独立实践

1、写一个SQLSERVER连接池的实现，访问pub数据库。

2、写一个连接ORACLE数据库的实现，用scott用户登陆，操作emp表

3、从控制台输入注册信息（用户名，密码，确认密码），写到数据库里面。

4、从控制台输入用户名和密码，在数据库中并验证其有效性。（提示：需要编写的类有：User, Validation,DbUtil）。

5、登陆成功后，从控制台输入一个表名，并从控制台打印该表里的数据。

第二十章：高级JDBC

学习目标

? 使用DDL,DML语言对数据库进行基本操作

? 预编译语句

? 使用事务

? 事务的级别控制

? 使用存储过程

? 操作元数据

? 可滚动的和可更新的结果集

? 批处理更新

? 字符大对象CLOB

? 二进制大对象BLOB

? RowSet 新特性

使用DDL,DML语言对数据库进行基本操作。

? 创建表并插入数据及修改数据：

import java.sql.Connection;

import java.sql.Statement;

public class CreateTable {

public static void main(String[] args) {

Connection con = null;

try {

// 通过连接池来获得一个连接

con = DBCon .getConnectionFromPooledDataSource("jdbcPool/mydatasource");

// 创建语句对象

Statement st = con.createStatement();

// 创建表的SQL语句

String sql = "create table student(id int,name char(30),age int)";

// 执行完SQL语句的结果

boolean b = st.execute(sql);

if (b) {

System.out.println("create success");

} else {

System.out.println("create fail");

}

// 插入数据到student表

sql = "insert into student values(1,'andy',47)"

+ "insert into student values(2,'jacky',53)"

+ "insert into student values(3,'周润发',51)"

+ "insert into student values(4,'谢贤',60)";

// 执行完SQL语句的结果

b = st.execute(sql);

if (b) {

System.out.println("insert success");

} else {

System.out.println("create fail");

}

// 更新表数据

sql = "update student set name='刘德华' where id=1";

int rows = st.executeUpdate(sql);

// 如果更新成功，rows肯定是大于1的值

if (rows > 0)

System.out.println("update success");

else

System.out.println("update fail");

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (con != null)

con.close();

} catch (Exception e) {

e.printStackTrace();

}

查询数据库里的数据

Statement对象的executeQuery()方法一般用于执行一个select语句，它只返回一个结果集，要想把查询结果最后显示给用户，必须对ResultSet对象进行处理。ResultSet对象包括一个由查询语句返回的一个表，这个表中包含所有的查询结果。对ResultSet对象的处理必须逐行进行。ResultSet对象维持一个指向当前行的指针（类似于Iterator的用法）。最初，这个指针指向第一行之前。ResultSet的next()方法使这个指针移向下一行。因此，第一次使用next()方法将指针指向结果集的第一行，这是可以对第一行的数据进行处理。处理完毕后，使用next()方法，将指针移向下一行，继续处理第二行数据。next()方法的返回值是一个boolean值，若为true,则说明指针成功地移向下一行，可以对该行进行处理。若返回值是false，则说明没有下一行，即结果集已经处理完毕。按从左至右的顺序对各列进行处理可以获得较高的执行效率。ResultSet接口的getXXX()方法可以从某列中获得结果，XXX表示JDBC的数据类型。

请看下例：

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.Statement;

public class ResultSetTest {

public static void main(String[] args) {

Connection con = null;

try {

con = DBCon

.getConnectionFromPooledDataSource("jdbcPool/mydatasource");

Statement st = con.createStatement();

String query = "select id,name from student";

// 获得一个结果集

ResultSet rs = st.executeQuery(query);

// 获得结果集的元数据（表及相关的信息）

ResultSetMetaData rsmt = rs.getMetaData();

// 得到结果集有几列

int num = rsmt.getColumnCount();

String[] columns = new String[num];

// 列的序号是从1开始的

for (int i = 0; i < num; i++)

columns[i] = rsmt.getColumnName(i + 1);

// 先输出列名

for (int i = 0; i < num; i++)

System.out.print(columns[i] + " ");

// 输出列名之后换行

System.out.println();

// 取出结果

while (rs.next()) {

// 输出每一行的值

for (int i = 1; i <= num; i++) {

String temp = rs.getString(i);

System.out.print(temp + " ");

}

System.out.println();

}

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

// 用完后要关闭连接，释放资源

if (con != null)

con.close();

} catch (Exception e) {

e.printStackTrace();

}

输出结果为：（Eclipse环境）

预编译语句（PreparedStatement）

Statement对象在每次执行SQL语句时都将该语句传给数据库，在多次执行同一语句时，这样做效率较低。这时可以使用PreparedStatement对象.如果数据库支持预编译，它可以将SQL语句传给数据库作预编译，以后每次执行这个SQL语句时，速度就可以提高很多。如果数据库不支持预编译，则在语句执行时，才将其传给数据库。这对用户来说是透明的。PreparedStatement对象的SQL语句还可以接受参数。在语句中指出需要接受哪些参数，然后进行预编译。在每一次执行时，可以给SQL语句传输不同的参数，这样就大大提高了灵活性。PreparedStatement接口是Statement接口派生的子接口，因此它可以使用Statement接口中的方法。

代码

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.Statement;

public class PrepareStatementTest {

public static void main(String[] args) {

Connection con = null;

try {

con = DBCon

.getConnectionFromPooledDataSource("jdbcPool/mydatasource");

// 创建修改表的PrepareStatement SQL语句

String sql = "update student set name=? where id=?";

// 创建预编译语句对象

PreparedStatement st = con.prepareStatement(sql);

String[] names = new String[] { "梁朝伟", "贝壳汗母", "小罗", "霍元甲" };

for (int i = 0; i < names.length; i++) {

st.setString(1, names[i]);

st.setInt(2, i + 1);

st.executeUpdate();

}

st.close();

// 打印执行完SQL语句的结果

Statement stq = con.createStatement();

// 定义一个查询的SQL语句

String query = "select id,name from student";

// 获得一个结果集

ResultSet rs = stq.executeQuery(query);

// 获得结果集的元数据（表及的信息）

ResultSetMetaData rsmt = rs.getMetaData();

// 得到有几列，保存在num变量里

int num = rsmt.getColumnCount();

String[] columns = new String[num];

// 列的序号是从1开始的

for (int i = 0; i < num; i++)

columns[i] = rsmt.getColumnName(i + 1);

// 先输出列名

for (int i = 0; i < num; i++)

System.out.print(columns[i] + " ");

// 输出列名之后换行

System.out.println();

// 取出结果

while (rs.next()) {

// 输出每一行的值

for (int i = 1; i <= num; i++) {

String temp = rs.getString(i);

System.out.print(temp + " ");

}

System.out.println();

}

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

if (con != null)

con.close();

} catch (Exception e) {

e.printStackTrace();

}

使用事务

下面介绍如何把一系列语句组织成一个事务？如果事务中所有命令都能正确执行，就可以提交这个事务；否则，如果事务中有一个命令出现错误，回滚这个事务，并返回到提交之前的状态，好像什么也没有发生。把命令组合成事务的主要原因是保证数据库的完整性。对于一个事务而言，要么事务中语句全部得到正确执行，事务就可被提交了，要么它中间出现错误。后一种情况，可以调用rollback()方法，数据库将自动放弃上一次提交事务以来的全部变化。一个数据库连接的缺省模式是autocommit模式，每个SQL命令一执行就会提交给数据库。一旦某个命令已提交，就不能把它回退。可以用Connection接口的getAutocommit()方法，检验数据库的目前自动提交模式设置。用命令con.setAutoCommit(false)方法关闭自动提交模式。用con.commit()命令提交事务。用con.rollback()回滚一个事务。

代码

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;

import javax.naming.NamingException;

public class UseTran {

public static void main(String[] args) {

Connection con = null;// 方法里临时变量要手动初始化

PreparedStatement updateAge = null;

String updateString = "update student "

+ "set age = ? where name like ?";

String jndiname = "jdbcPool/mydatasource";

try {

con = DBCon.getConnectionFromPooledDataSource(jndiname);

updateAge = con.prepareStatement(updateString);

int[] age = { 45, 39, 25, 96 };

String[] names = { "梁朝伟%", "贝壳汗母%", "小罗%", "霍元甲%" };

int len = age.length;

// 设置事务提交模式为非自动提交

con.setAutoCommit(false);

for (int i = 0; i < len; i++) {

updateAge.setInt(1, age[i]);

updateAge.setString(2, names[i]);

updateAge.executeUpdate();

}

// 上面执行的语句，如果不出现异常则提交 SQL 语句

con.commit();

System.out.println("update success!");

} catch (NamingException ex) {

System.err.println("Name Not Bound : " + ex.getMessage());

} catch (SQLException ex) {

System.err.println("SQLException: " + ex.getMessage());

if (con != null) {

try {

System.err.print("Transaction is being ");

System.err.println("rolled back");

// 如果出现异常则事务回滚

con.rollback();

} catch (SQLException excep) {

System.err.print("SQLException: ");

System.err.println(excep.getMessage());

}

} finally {// 不管发生不发生异常，要关闭连接，释放资源

try {

if (con != null) {

con.close();

}

} catch (Exception e) {

e.printStackTrace();

}

事务的级别控制

在SQL术语中，事务是逻辑工作单元（logical unit of work,LUW）构成的一个或多个语句。这在某种含义上意味着，一切都是事务。不过，通常而言，术语事务用来表示或全或无的系列操作；也就是说，要么一切十分成功，要么什么也没有发生。典型的事务是从银行帐户提款，并存放到另一个。只要提款完成，金额就消失了。另一个范例是复式薄记记帐法中的借方和贷方：借方和贷方都必须完成。

在单用户模式，事务非常容易理解-它们只是和保存或忘记应用程序的状态有关。在多用户模式中，事务变得复杂多了。多用户事务的经典说明是银行帐户，其中一个应用程序试图在借记帐户，同时另一个应用程序试图贷记同一个帐户。在前面已经介绍过多线程编程（并发编程）。类似的，事务的根本问题是保持两个事务相互隔离，否则一个应用程序就可能影响另一个，从而导致错误的程序状态。当处理多个访问相同数据的用户时，通常可能出现三种问题：

? 脏读：当应用程序使用了被另一个应用程序修改过的数据，而这个数据处于未提交状态时，就会发生脏读。第二个应用程序随后会请求回滚被其修改的数据。第一个事务使用的数据就会被损坏，或者"变脏"。

? 不可重复的读：当一个事务获得了数据，而该数据随后被一个单独的事务所更改时，若第一个事务再次读取更改后的数据，就会发生不可重复的读。这样，第一个事务进行了一个不可重复的读。

? 虚读：当事务通过某种查询获取了数据，另一个事务修改了部分该数据，原来的事务第二次获取该数据时，就会发生虚读。第一个事务现在会有不同的结果集，它可能包含虚读。

为了解决与"多个线程请求相同数据"相关的问题，事务之间用锁相互隔开。多数主流的数据库支持不同类型的锁；因此，JDBC API支持不同类型的事务，它们由Connection对象指派或确定。在JDBC API中可以获得下列事务级别：

? TRANSACTION_NONE 说明不支持事务

? TRANSACTION_READ_UNCOMMITTED说明在提交前一个事务可以看到另一个事务的变化。这样脏读，不可重复的读和虚读都是允许的。

? TRANSACTION_READ_COMMITTED说明读取未提交的数据是不允许的。这个级别仍然允许不可重复的读和虚读产生。

? TRANSACTION_REPEATABLE_READ说明事务保证能够再次读取相同的数据而不会失败，但虚读仍然会出现。

? TRANSACTION_SERIALIZABLE是最高的事务级别，它防止脏读，不可重复读和虚读。

为什么不是所有事务都运行在TRANSACTION_SERIALIZABLE模式以保证最高程度的数据完整性呢？问题在于，和处理多线程编程有关的问题相似，事务保护的级别越高，性能损失就越大。假定您的数据库和JDBC驱动程序支持这个特性，则给定一个Connection对象，您可以明确地设置想要的事务级别：con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

您还可以确定当前事务的级别：

int transactionIsolation = con.getTransactionIsolation();

if (transactionIsolation == Connection.TRANSACTION_NONE)

System.out.println("当前事务级别为：TRANSACTION_NONE。");

代码：

import java.sql.Connection;

import java.sql.SQLException;

import javax.naming.NamingException;

public class TranTest {

public static void main(String[] args) {

String jndiname = "jdbcPool/mydatasource";

Connection con = null;

try {

con = DBCon.getConnectionFromPooledDataSource(jndiname);

int transactionIsolation = con.getTransactionIsolation();

if (transactionIsolation == Connection.TRANSACTION_NONE) {

System.out.println("当前事务级别为：TRANSACTION_NONE。");

} else if (transactionIsolation == Connection.TRANSACTION_READ_COMMITTED) {

System.out.println("当前事务级别为：TRANSACTION_READ_COMMITTED。");

} else if (transactionIsolation == Connection.TRANSACTION_READ_UNCOMMITTED) {

System.out.println("当前事务级别为：TRANSACTION_READ_UNCOMMITTED。");

} else if (transactionIsolation == Connection.TRANSACTION_REPEATABLE_READ) {

System.out.println("当前事务级别为：TRANSACTION_REPEATABLE_READ。");

} else if (transactionIsolation == Connection.TRANSACTION_SERIALIZABLE) {

System.out.println("当前事务级别为：TRANSACTION_SERIALIZABLE。");

}

con.setAutoCommit(false);

con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

transactionIsolation = con.getTransactionIsolation();

if (transactionIsolation == Connection.TRANSACTION_NONE) {

System.out.println("当前事务级别为：TRANSACTION_NONE。");

} else if (transactionIsolation == Connection.TRANSACTION_READ_COMMITTED) {

System.out.println("当前事务级别为：TRANSACTION_READ_COMMITTED。");

} else if (transactionIsolation == Connection.TRANSACTION_READ_UNCOMMITTED) {

System.out.println("当前事务级别为：TRANSACTION_READ_UNCOMMITTED。");

} else if (transactionIsolation == Connection.TRANSACTION_REPEATABLE_READ) {

System.out.println("当前事务级别为：TRANSACTION_REPEATABLE_READ。");

} else if (transactionIsolation == Connection.TRANSACTION_SERIALIZABLE) {

System.out.println("当前事务级别为：TRANSACTION_SERIALIZABLE。");

}

} catch (NamingException ex) {

System.err.println("Name Not Bound : " + ex.getMessage());

} catch (SQLException ex) {

System.err.println("SQLException : " + ex.getMessage());

} finally {

try {

if (con != null)

con.close();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println("程序执行结束！");

}

使用存储过程

很多数据库都支持在数据库内部执行的函数。这种方法有几个好处，包括更快的性能和改进的安全性。这些函数称为存储过程。存储过程是用来封装SQL语句来完成一个完整的业务功能，类似于面向对象里面方法的概念。虽然它们通常是用SQL编写的，但也可以用数据库支持的任何编程语言编写。随着Java语言日趋流行，几个数据库厂商---Oracle（Oracle数据库）和IBM（db2数据库）都起用了Java语言创建存储过程，还可以在不同数据库之间移动存储过程。

存储过程可以支持三种类型的参数：IN,OUT和INOUT，这对于存储过程在数据库内部真正能做什么来说，带来了很大的灵活性。不管存储过程是用什么语言编写的，它都能以一种标准的方式从Java应用程序调用。

首先，您需要创建一个CallableStatement对象。为了标识存储过程和过程需要的参数的类型和数量，还要允许使用三种类型的调用。下面的清单说明了这三种类型（假定我们正在调用一个名为StudentList的存储过程）：

? {call StudentList}如果过程不需要参数

? {call StudentList(?,?)}如果过程需要两个参数

? {?=call StudentList(?,?)}如果参数需要两个参数并返回一个

要想使用存储过程，首先应该创建一个存储过程！

代码的实现

import java.sql.Connection;

import java.sql.SQLException;

import java.sql.Statement;

import javax.naming.NamingException;

public class CreateStoredProceduresofSQLServer {

public static void main(String[] args) {

Connection con = null;

Statement stmt = null;

String jndiname = "jdbcPool/mydatasource";

try {

con = DBCon.getConnectionFromPooledDataSource(jndiname);

stmt = con.createStatement();

// 1.创建存储过程show_students

String createProcedure1 = "create procedure show_students " + "as " + "select id, name,age " + "from students " + "order by id";

// 删除数据库中存在的同名过程

stmt.executeUpdate("if exists(select name from sysobjects "

+ "where name='show_students'and type='p') "

+ "drop procedure show_students");

stmt.executeUpdate(createProcedure1);

// 2.创建储存过程onestudent

String createProcedure2 = "create procedure onestudent "

+ "@stu_id int = null, " + "@name varchar(20) output, "

+ "@age int output " + "as " + "if @stu_id = null "

+ "BEGIN "

+ " PRINT 'ERROR: You must specify a stu_id value.' "

+ " RETURN "

+ "END "

// Get the sales for the specified cof_name and " +

// assign it to the output parameter. " +

"SELECT @name = name, @age = age " + "FROM coffees "

+ "WHERE id = @stu_id " + "RETURN ";

stmt.executeUpdate("if exists(select name from sysobjects "

+ "where name='onestudent'and type='p') "

+ "drop procedure onestudent");

stmt.executeUpdate(createProcedure2);

// 3.创建函数

String createProcedure3 = "CREATE FUNCTION pubuse.ageofstu "

// Input cof_name

"(@stu_name varchar(20)) "

+ "RETURNS int "

+ // return sales

"AS " + "BEGIN " + " DECLARE @age int "

+ " SELECT @age = age " + " FROM student "

+ " WHERE name like @stu_name " + " RETURN @age "

+ "END ";

stmt.executeUpdate("if exists(select name from sysobjects "

+ "where name='ageofstu') "

+ "drop function pubuse.ageofstu");

stmt.executeUpdate(createProcedure3);

stmt.close();

con.close();

} catch (NamingException ex) {

System.err.println("Name Not Bound : " + ex.getMessage());

} catch (SQLException ex) {

System.err.println("SQLException : " + ex.getMessage());

}

System.out.println("程序执行结束！");

}

下面是使用存储过程的代码：

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Types;

import javax.naming.NamingException;

public class InvokeStoreProcdureofSQLServer {

public static void main(String[] args) {

Connection con = null;

String jndiname = "jdbcPool/mydatasource";

// 定义调用存储过程和函数的 SQL 语句

String callSQL1 = "{call show_students}";

String callSQL2 = "{call onestudent(?,?,?)}";

String callSQL3 = "{? = call ageofstu(?)}";

try {

con = DBCon.getConnectionFromPooledDataSource(jndiname);

// 调用第 1 个存储过程

CallableStatement cs = con.prepareCall(callSQL1);

ResultSet rs = cs.executeQuery();

System.out.println("第一个存储过程调用结果");

while (rs.next()) {

String id = rs.getString(1);

String name = rs.getString(2);

String age = rs.getString(3);

System.out.println(id + " " + name + " " + age);

}

// 调用第 2 个存储过程

cs = con.prepareCall(callSQL2);

cs.setString(1, "2");

cs.registerOutParameter(2, Types.CHAR);

cs.registerOutParameter(3, Types.INTEGER);

cs.execute();

String name = cs.getString(2);

int age = cs.getInt(3);

System.out.println("第二个存储过程调用结果");

System.out.println("This student's name is " + name

+ " and age is " + age);

// 调用函数

cs = con.prepareCall(callSQL3);

cs.setString(2, "小罗");

cs.registerOutParameter(1, Types.INTEGER);

cs.execute();

age = cs.getInt(1);

System.out.println("函数调用结果");

System.out.println("This student's name is " + age + ".");

cs.close();

con.close();

} catch (NamingException ex) {

System.err.println("Name Not Bound : " + ex.getMessage());

} catch (SQLException ex) {

System.err.println("SQLException : " + ex.getMessage());

}

System.out.println("调用结束!");

}

操作元数据

JDBC Meta Data（元数据）----描述数据的数据。它的接口有：

? DatabaseMetaData（数据库元数据）

? ResultSetMetaData（结果集元数据）

DatabaseMetaData（数据库元数据）

在对数据源进行连接以后，得到一个Connection对象，可以从这个对象获得有关数据源的各种信息，包括关于数据库中的各个表，表中的各个列，数据类型和存储过程等各方面的信息。根据这些信息，JDBC程序可以访问一个事先并不了解的数据库。获取这些信息的方法都是在DatabaseMetaData的对象上实现的，而DatabaseMetaData对象是在Connection对象之上获得的。

下面的语句可以在一个连接的基础上创建一个DatabaseMetaData 对象：

DatabaseMetaData dm=con.getMetaData();

数据库的一些常用信息可通过DatabaseMetaData对象的下列方法获得。

? getURL()//返回一个String对象，代表数据库的URL.

? getUserName()//返回此连接使用的数据库的用户名

? isReadOnly()//返回一个boolean值，指示数据库是否只允许读操作。

? getDatabaseProduceName()//返回数据库的产品名称

? getDatabaseProduceVersion()//返回数据库的版本号

? getDriverName()//返回驱动程序的名称。

? getDriverVersion()//返回驱动程序的版本号

代码示例：

import java.sql.Connection;

import java.sql.DatabaseMetaData;

import java.sql.ResultSet;

import java.sql.SQLException;

import javax.naming.NamingException;

public class DataBaseMetaDataTest {

public static void main(String[] args) {

Connection con = null;

String jndiname = "jdbcPool/mydatasource";

try {

con = DBCon.getConnectionFromPooledDataSource(jndiname);

// 测试数据库信息

DatabaseMetaData dm = con.getMetaData();

System.out.println("1. 数据库的基本信息");

System.out.println("Database is " + dm.getDatabaseProductName());

System.out.println("Database version is "

+ dm.getDatabaseProductVersion());

System.out.println("JDBC Driver is " + dm.getDriverName());

System.out.println("JDBC driver version is "

+ dm.getDriverVersion());

// 获取数据库中目录(数据库)的信息

System.out.println("2. 数据库中目录(数据库)的信息");

ResultSet catalogs = dm.getCatalogs();

while (catalogs.next()) {

System.out.println(catalogs.getString(1));

}

// 获取数据库中模式的信息

System.out.println("3. 数据库中模式的信息");

ResultSet schemas = dm.getSchemas();

while (schemas.next()) {

System.out.println(schemas.getString(1));

}

// 获取数据库中各个表的情况

System.out.println("4. 数据库中各个表的信息");

ResultSet tables = dm.getTables("pubs", null, null, null);

while (tables.next()) {

for (int i = 0; i < 5; i++) {

System.out.print(tables.getString(i + 1));

System.out.print(" | ");

}

System.out.println();

}

// 获取数据库表中各个列的信息

System.out.println("5. 数据库表中各个列的信息");

ResultSet columns = dm.getColumns(null, null,

"student", null);

while (columns.next()) {

for (int i = 0; i < 18; i++) {

System.out.print(columns.getString(i + 1));

System.out.print(" | ");

}

System.out.println();

}

} catch (NamingException ex) {

System.err.println("Name Not Bound : " + ex.getMessage());

} catch (SQLException ex) {

System.err.println("SQLException : " + ex.getMessage());

} finally {

try {

if (con != null)

con.close();

} catch (Exception e) {

e.printStackTrace();

}

System.out.println("程序结束!!!");

}

ResultSetMetaData（结果集元数据）

根据结果集的元数据，可以得到一个查询结果集关于查询表中列的个数，各个列名，类型以及各个列的宽度等。ResultSetMetaData的对象可以由ResultSet对象的getMetaData()方法得到。

ResultSetMetaData对象的常用方法如下：

? ResultSet rs=stmt.executeQuery();

? ResultSetMetaData rsmd=rs.getMetaData();

? rsmd.getColumnCount()//返回ResultSet对象的列数。

? rsmd.getColumnDisplaySize(int column);//返回column指定的列的最大宽度。

? rsmd.getColumnLabel(int column)//返回column指定列的标签。

? rsmd.getColumnName(int column)//返回column指定列的列名。

请看下例：

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import javax.naming.NamingException;

public class ResultSetMetaDataTest {

public static void main(String[] args) {

Statement stmt = null;

ResultSet rs = null;

Connection con = null;

String jndiname = "jdbcPool/mydatasource";

try {

con = DBCon.getConnectionFromPooledDataSource(jndiname);

stmt = con.createStatement();

String querySQL1 = "select * from student";

rs = stmt.executeQuery(querySQL1);

// 提取结果集的元数据：

ResultSetMetaData rsmd = rs.getMetaData();

int colCount = rsmd.getColumnCount();

String[] columnNames = new String[colCount];

String[] columnLabels = new String[colCount];

int[] columnTypes = new int[colCount];

for (int i = 0; i < colCount; i++) {

columnNames[i] = rsmd.getColumnName(i + 1);

columnLabels[i] = rsmd.getColumnLabel(i + 1);

columnTypes[i] = rsmd.getColumnType(i + 1);

}

System.out.println();

System.out.println("提取的数据如下：");

System.out.println();

System.out .println("----------------------");

for (int i = 0; i < colCount; i++) {

System.out.print(columnLabels[i] + "\t");

}

System.out.println();

for (int i = 0; i < colCount; i++) {

System.out.print(columnNames[i] + "\t");

}

} catch (NamingException ex) {

System.err.println("Name Not Bound : " + ex.getMessage());

} catch (SQLException ex) {

System.err.println("SQLException: " + ex.getMessage());

} finally {

try {

if (con != null)

con.close();

} catch (Exception e) {

}

System.out.println("程序结束!!!");

}

可滚动的和可更新的结果集

可滚动的结果集表示在结果集中前后滚动显示数据。可更新的结果集表示可以通过结果集来更新数据库里的数据。

可滚动的ResultSet可以使用以下方法：

? absolute()

? afterLast()

? beforeFirst()

? first()

? getRow()

? isAfterLast()

? isBeforeFirst()

? isFirst()

? isLast()

? last()

? moveToCurrentRow()//仅对可更新的ResultSet有效

? previous()

? relative(int rows)//将游标移动相对量的行，或者正方向或者负方向

为了让查询返回可滚动的结果集，你必须用

Statement stmt=con.createStatement(type,concurrency);

得到一个不同的Statement对象。

对于PreparedStatement,调用

PreparedStatement stmt=con.preparedStatement(command,type,concurrency);

例如，如果你只想在一个结果总来回滚动，而不想编辑它的数据，用下列语句：

Statement stmt=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

所有调用方法：

ResultSet rs=stmt.executeQuery(query);

返回的结果集都是可滚动的，一个可滚动的结果集用一个光标指示目前的位置。

ResultSet类型值

? TYPE_FORWARD_ONLY 结果集不可滚动

? TYPE_SCROLL_INSENSITIVE 结果集可滚动，但不反映数据库的变化

? TYPE_SCROLL_SENSITIVE 结果集可滚动，并反映数据库的变化

ResultSet同步值

? CONCUR_READ_ONLY 不能用结果集更新数据库

? CONCUR_UPDATABLE 可以用结果集更新数据库

如果你想编辑ResultSet类型数据，并让这些变化在数据库中自动体现出来，就需要创建一个可更新的结果集。可更新的结果集不一定是可滚动的，但如果想让用户编辑数据，通常这个结果集也是可滚动的。为了得到可更新的结果集，构造语句如下：

Statement stmt=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);

接着，调用executeQuery()就可返回可更新的结果集。

注意：不是所有的查询都可返回可更新的结果集。如果某个查询涉及多个表，那么它的返回结果可能是不可更新的。但如果查询只涉及一个表或涉及用主关键字连接的多个表，那么返回结果是可更新的，这可以用ResultSet的getConcurrency()方法验证。

和SQL类型相对应，JDBC 2.0为每个数据类型提供了与它相应的updateXxx()方法，如updateDouble(),updateString()等等。

updateXxx()方法只能改变当前光标的记录值，而不能改变数据库中数据。调用updateRow()方法把修改后的数据保存到数据库中。如果移动到另一行之前，没有调用updateRow()方法，本行中所有的更新将被撤消。也可以调用cancelRowUpdates()方法，撤消本行中的所有修改。

例如：

String query="select * from student";

ResultSet rs=stmt.executeQuery(query);

while(rs.next()){

double age=rs.getInt("age");

rs.updateInt("age",age+1);

rs.updateRow();

往数据库中添加一个新记录：

? 首先用moveToInsertRow()方法把光标移动到指定位置（它称为插入行）。

? 接着，调用 updateXxx()方法，在插入位置创建一个新行。

? 最后，调用insertRow()方法，把这个新行发送给数据库。插入完成后，调用

moveToCourrentRow()方法把光标移回调用moveToInsertRow()方法以前的位置。

例：

rs.moveToInsertRow();

rs.updateString("name","李雨春");

rs.updateInt("age",21);

rs.insertRow();

rs.moveToCurrentRow();

调用下面的方法，可以删除位于光标下面的一行：

rs.deleteRow();

deleteRow() 方法会立即把这行从结果集和数据库中删除。

代码的实现

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import javax.naming.NamingException;

public class ResultSetDemo {

public static void main(String[] args) {

Connection con = null;

Statement stmt = null;

ResultSet rs = null;

String querySQL = "select name,age from student";

String jndiname = "jdbcPool/mydatasource";

try {

con = DBCon.getConnectionFromPooledDataSource(jndiname);

stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,

ResultSet.CONCUR_UPDATABLE);

rs = stmt.executeQuery(querySQL);

// 显示修改之前的数据

System.out.println("修改之前的数据：");

while (rs.next()) {

for (int i = 1; i <= 2; i++) {

System.out.print(rs.getObject(i));

System.out.print(" ");

}

System.out.println();

}

// 过年了，把记录里年龄都加1，虽然写一个SQL语句就可以实现

// update student set age=age+1

// 但是为了测试rs的用法我们还使用JDBC。

rs.beforeFirst();

while (rs.next()) {

int age = rs.getInt("age");

rs.updateInt("age", age + 1);

rs.updateRow();

}

// 显示修改后的数据

rs = stmt.executeQuery(querySQL);

System.out.println("修改之后的数据：");

while (rs.next()) {

for (int i = 1; i <= 2; i++) {

System.out.print(rs.getObject(i));

System.out.print(" ");

}

System.out.println();

}

// 增加一条数据

rs.moveToInsertRow();

rs.updateString("name", "李雨春");

rs.updateInt("age", 21);

rs.insertRow();

rs.moveToCurrentRow();

// 显示增加后的数据

System.out.println("增加之后的数据：");

rs = stmt.executeQuery("select name,age from student");

while (rs.next()) {

for (int i = 1; i <= 2; i++) {

System.out.print(rs.getObject(i));

System.out.print(" ");

}

System.out.println();

}

// 删除最后一行数据

if (rs.last())

rs.deleteRow();

System.out.println("删除之后的数据：");

rs = stmt.executeQuery(querySQL);

while (rs.next()) {

for (int i = 1; i <= 2; i++) {

System.out.print(rs.getObject(i));

System.out.print(" ");

}

System.out.println();

}

stmt.close();

} catch (NamingException ex) {

System.err.println("Name Not Bound : " + ex.getMessage());

} catch (SQLException ex) {

System.out.println("\n--- SQLException caught ---\n");

while (ex != null) {

System.out.println("Message: " + ex.getMessage());

System.out.println("SQLState: " + ex.getSQLState());

System.out.println("ErrorCode: " + ex.getErrorCode());

ex = ex.getNextException();

System.out.println();

}

} finally {

try {

if (con != null)

con.close();

} catch (Exception e) {

}

System.out.println();

System.out.println("End.");

}

打印结果如图

批处理更新

批处理更新功能可以一次向数据库提交多个更新操作，要求数据库进行处理。一起提交多个更新（而非一个一个单独地提交更新）在某些情况下将大大提高性能。

可以利用Statement,PreparedStatement,CallableStatement对象来提交批处理更新。

代码的实现

import java.sql.BatchUpdateException;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import javax.naming.NamingException;

public class BatchUpdateTest {

public static void main(String[] args) {

Connection con = null;

Statement stmt = null;

String jndiname = "jdbcPool/mydatasource";

try {

con = DBCon.getConnectionFromPooledDataSource(jndiname);

stmt = con.createStatement();

con.setAutoCommit(false);

stmt.addBatch("insert into student values('拉登',56)");

stmt.addBatch("insert into student values('张学友',49)");

stmt.addBatch("insert into student values('刘德华',51)");

stmt.addBatch("insert into student values('猪八戒',128)");

int[] updateCounts = stmt.executeBatch();

con.commit();

for (int i = 0; i < updateCounts.length; i++) {

System.out.println("Line" + (i + 1) + " update counts is : "

+ updateCounts[i]);

}

con.setAutoCommit(true);

ResultSet uprs = stmt.executeQuery("select * from student");

System.out.println("table student after insertion:");

while (uprs.next()) {

String name = uprs.getString("name");

int age = uprs.getInt("age");

System.out.print(name + " " + age);

System.out.println();

}

uprs.close();

stmt.close();

} catch (BatchUpdateException b) {

System.err.println("SQLException: " + b.getMessage());

System.err.println("SQLState: " + b.getSQLState());

System.err.println("Message: " + b.getMessage());

System.err.println("Vendor: " + b.getErrorCode());

System.err.print("Update counts: ");

int[] updateCounts = b.getUpdateCounts();

for (int i = 0; i < updateCounts.length; i++) {

System.err.print(updateCounts[i] + " ");

}

} catch (SQLException ex) {

System.err.println("SQLException: " + ex.getMessage());

System.err.println("SQLState: " + ex.getSQLState());

System.err.println("Message: " + ex.getMessage());

System.err.println("Vendor: " + ex.getErrorCode());

} catch (NamingException ex) {

System.err.println("Name Not Bound : " + ex.getMessage());

} finally {

try {

if (con != null)

con.close();

} catch (Exception e) {

}

System.out.println("程序执行结束！");

}

打印结果如图

字符大对象CLOB

在mssqlserver 2000里面并没有字符大对象这个数据类型，但是可以通过nchar类型来代替字符大对象数据，但是只能存放3k字符以下的。在ORACLE数据库里面存在字符大对象CLOB数据类型。该数据类型用来存放文本类型的数据。

SQL代码：

ORACLE的实现，在运行该例子之前，首先把ORACLE的驱动文件classes12.jar加到classpath里面。然后打开ORACLE数据库，建立一张表。SQL语句如下：

CREATE TABLE MESSAGES(ID VARCHAR2(20),TITLE VARCHAR2(30),AUTHOR VARCHAR(20),MESSAGE CLOB);）

JAVA代码：

package com.app;

import java.io.File;

import java.io.FileInputStream;

import java.io.OutputStream;

import java.sql.ResultSet;

import java.sql.Statement;

import java.sql.Connection;

import oracle.sql.CLOB;

public class OracleClob {

public static void main(String[] args) {

String jndiname = "jdbcPool/mydatasource";

Connection con = DBCon.getConnectionFromPooledDataSource(jndiname);

String insertSQL = "Insert INTO messages VALUES('1001','my message', 'xsw', empty_clob())";

try {

con.setAutoCommit(false);

Statement stmt = con.createStatement();

stmt.execute(insertSQL);

String cmd = "SELECT message FROM messages WHERE id='1001'";

ResultSet rset = stmt.executeQuery(cmd);

rset.next();

CLOB clob = (CLOB) rset.getClob(1);

File file = new File("myfile.txt");

FileInputStream fis = new FileInputStream(file);

OutputStream outstream = clob.getAsciiOutputStream();

int size = clob.getBufferSize();

byte[] buffer = new byte[size];

int length = -1;

while ((length = fis.read(buffer)) != -1)

outstream.write(buffer, 0, length);

fis.close();

outstream.close();

con.commit();

con.setAutoCommit(true);

} catch (Exception e) {

e.printStackTrace();

}

下面看下MSSQLSERVER数据库的实现（首先在查询分析器里面运行下列SQL语句：

CREATE TABLE messages (

id char(30),

title char(40) ,

author char(20) ,

message ntext

)

然后运行下面的代码：

package com.app;

import java.io.File;

import java.io.FileInputStream;

import java.sql.Connection;

import java.sql.PreparedStatement;

public class MSSQLClob {

public static void main(String[] args) {

String jndiname = "jdbcPool/mydatasource";

Connection con = DBCon.getConnectionFromPooledDataSource(jndiname);

String insertSQL = "Insert INTO messages VALUES(?,?,?,?)";

PreparedStatement stmt = con.prepareStatement(insertSQL);

File file = new File("myfile.txt");

FileInputStream fis = new FileInputStream(file);

stmt.setString(1, "1001");

stmt.setString(2, "my message");

stmt.setString(3, "xsw");

stmt.setAsciiStream(4, fis, (int) file.length());

stmt.executeUpdate();

fis.close();

}

二进制大对象BLOB

该数据类型是用来存放图片文件的。在MSSQLSERVER 2000没有该数据类型，那么可以用binary数据类型代替，但是该数据只能存放小7k的图片。在ORACLE数据库里，有BLOB数据类型，来直接存放图片文件，直接操作该数据类型。对不支持BLOB数据类型的MSSQLSERVER 2000数据库，我们可以用二进制流进行读取图片文件。

ORACLE的实现：

SQL语句：

CREATE TABLE AUTHORS(AUTHOR VARCHAR2(40),PHOTO BLOB)；

JAVA代码：

package com.app;

import java.io.File;

import java.io.FileInputStream;

import java.io.OutputStream;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.Statement;

import oracle.sql.BLOB;

public class OracleBlob {

public static void main(String[] args) {

String jndiname = "jdbcPool/mydatasource";

Connection con = DBCon.getConnectionFromPooledDataSource(jndiname);

String insertSQL = "Insert INTO authors VALUES('1001', empty_blob())";

try {

con.setAutoCommit(false);

Statement stmt = con.createStatement();

stmt.execute(insertSQL);

String cmd = "SELECT photo FROM authors WHERE author='1001'";

ResultSet rset = stmt.executeQuery(cmd);

rset.next();

BLOB blob = (BLOB) rset.getBlob(1);

File file = new File("mypic.jpg");

FileInputStream fis = new FileInputStream(file);

OutputStream outstream = blob.getAsciiOutputStream();

int size = blob.getBufferSize();

byte[] buffer = new byte[size];

int length = -1;

while ((length = fis.read(buffer)) != -1)

outstream.write(buffer, 0, length);

fis.close();

outstream.close();

con.commit();

con.setAutoCommit(true);

} catch (Exception e) {

e.printStackTrace();

}

MSSQLSERVER 2000的实现

SQL语句：

CREATE TABLE authors(

author char(50) ,

photo image NOT NULL

)

代码：

package com.app;

import java.io.File;

import java.io.FileInputStream;

import java.sql.Connection;

import java.sql.PreparedStatement;

public class MSSQLBlob {

public static void main(String[] args) {

String jndiname = "jdbcPool/mydatasource";

Connection con = DBCon.getConnectionFromPooledDataSource(jndiname);

String insertSQL = "Insert INTO authors VALUES(?,?)";

PreparedStatement stmt = con.prepareStatement(insertSQL);

File file = new File("mypic.jpg");

FileInputStream fis = new FileInputStream(file);

stmt.setString(1, "1001");

stmt.setBinaryStream(2, fis, (int) file.length());

stmt.executeUpdate();

fis.close();

}

RowSet 新特性

Java 5在Java Database Connectivity (JDBC)方面加强了支持，其中加入了新的包javax.sql.rowset，javax.sql.rowset.serial，javax.sql.rowset.spi。从RowSet接口继承规定了五个新的接口：

? CachedRowSet：可以不用与数据源建立长期的连接，只有当从数据库读取数据或是往数据库写入数据的时候才会与数据库建立连接，它提供了一种轻量级的访问数据库的方式，其数据均存在内存中。

? JdbcRowSet：对ResultSet的对象进行包装，使得可以将ResultSet对象做为一个JavaBeans 组件。

? FilteredRowSet：继承自CachedRowSet，可以根据设置条件得到数据的子集。

? JoinRowSet：继承自CachedRowSet，可以将多个RowSet对象进行SQL Join语句的合并。

? WebRowSet：继承自CachedRowSet，可以将WebRowSet对象输出成XML格式。

CachedRowSet

CachedRowSet可以通过调用populate(ResuletSet rs)来生成数据，一旦获得数据，CachedRowSet就可以断开与数据库的连接，直到往数据库写入数据的时候才需建立连接。

下面的代码演示了如何根据ResultSet建立一个CachedRowSet对象:

package com.itjob;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import javax.sql.rowset.CachedRowSet;

import com.sun.rowset.CachedRowSetImpl;

public class CachedRSTest {

private final static String DRIVER = "sun.jdbc.odbc.JdbcOdbcDriver";

private final static String URL = "jdbc:odbc:myodbc";

private final static String USER = "student";

private final static String PASSWORD = "student";

public static void main(String[] args) throws InstantiationException,

IllegalAccessException, ClassNotFoundException, SQLException {

Class.forName(DRIVER);

Connection con = DriverManager.getConnection(URL, USER, PASSWORD);

Statement stmt = con.createStatement();

ResultSet rs = stmt.executeQuery("SELECT * FROM student");

CachedRowSet crset = new CachedRowSetImpl();

crset.populate(rs);

rs.close();

stmt.close();

con.close();

System.out.println("name");

while (crset.next()) {

System.out.println(crset.getString("name"));

}

JdbcRowSet

JdbcRowSet功能与ResultSet类似，与CachedRowSet不同，JdbcRowSet在操作时保持与数据库的连接。可以将与数据库连接的URL，用户名，密码以及执行的SQL语句通过setXXX形式绑定。另外，JdbcRowSet返回的结果默认是可以上下滚动和可更新的，当然这需要数据库厂商提供的JDBC Driver支持。下面的代码演示了如何通过set方法设定数据库连接参数，以及如何操作JdbcRowSet对象。

package com.itjob;

import java.sql.SQLException;

import javax.sql.rowset.JdbcRowSet;

import com.sun.rowset.JdbcRowSetImpl;

public class JdbcRSDemo {

private final static String DRIVER = "sun.jdbc.odbc.JdbcOdbcDriver";

private final static String URL = "jdbc:odbc:myodbc";

private final static String USER = "student";

private final static String PASSWORD = "student";

public static void main(String[] args) throws SQLException, ClassNotFoundException {

Class.forName(DRIVER);

JdbcRowSet jrs = new JdbcRowSetImpl();

// 设置连接数据库的URL

jrs.setUrl(URL);

// 设置连接数据库的用户名

jrs.setUsername(USER);

// 设置连接数据库的密码

jrs.setPassword(PASSWORD);

// 设置执行数据库的SQL语句

jrs.setCommand("select * from student");

jrs.execute();

System.out.println("name");

while (jrs.next()) {

System.out.println(jrs.getString("name"));

}

jrs.close();

}

FilteredRowSet

FilteredRowSet接口中规定了可以设定过滤器，其过滤接口为Predicate接口，必须实现Predicate接口中的evaluate方法。具体的代码如下：

package com.itjob;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import javax.sql.rowset.CachedRowSet;

import javax.sql.rowset.FilteredRowSet;

import com.sun.rowset.CachedRowSetImpl;

import com.sun.rowset.FilteredRowSetImpl;

public class FilteredRSDemo {

private final static String DRIVER = "sun.jdbc.odbc.JdbcOdbcDriver";

private final static String URL = "jdbc:odbc:myodbc";

private final static String USER = "student";

private final static String PASSWORD = "student";

public static void main(String[] args) throws InstantiationException,

IllegalAccessException, ClassNotFoundException, SQLException {

Class.forName(DRIVER).newInstance();

Connection con = DriverManager.getConnection(URL, USER, PASSWORD);

Statement stmt = con.createStatement();

ResultSet rs = stmt.executeQuery("SELECT * FROM student");

FilteredRowSet frs = new FilteredRowSetImpl();

frs.populate(rs);

con.close();

MyDBFilter filter = new MyDBFilter(1, 4);

frs.setFilter(filter);

System.out.println("name");

while (frs.next()) {

System.out.println(frs.getString("name"));

}

frs.close();

}

package com.itjob;

import java.sql.SQLException;

import javax.sql.RowSet;

import javax.sql.rowset.CachedRowSet;

import javax.sql.rowset.Predicate;

class MyDBFilter implements Predicate {

private int low;

private int high;

public MyDBFilter(int low, int high) {

this.low = low;

this.high = high;

}

public boolean evaluate(RowSet rs) {

CachedRowSet crs=(CachedRowSet)rs;

//如果id在low和high之间返回真

try {

int idValue = crs.getInt("id");

if (low < idValue && idValue < high) {

return true;

}

} catch (SQLException e) {

}

return false;

}

public boolean evaluate(Object arg0, int arg1) throws SQLException {

return false;

}

public boolean evaluate(Object arg0, String arg1) throws SQLException {

return false;

}

WebRowSet

WebRowSet继承自CachedRowSet，支持XML格式的查询，更新等操作，下面的代码将WebRowSet对象输出成XML格式到文件。

package com.itjob;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import javax.sql.rowset.WebRowSet;

import com.sun.rowset.WebRowSetImpl;

public class WebRSDemo {

private final static String DRIVER = "sun.jdbc.odbc.JdbcOdbcDriver";

private final static String URL = "jdbc:odbc:myodbc";

private final static String USER = "student";

private final static String PASSWORD = "student";

public static void main(String[] args) throws InstantiationException,

IllegalAccessException, ClassNotFoundException, SQLException, IOException {

Class.forName(DRIVER).newInstance();

Connection con = DriverManager.getConnection(URL, USER, PASSWORD);

Statement stmt = con.createStatement();

ResultSet rs = stmt.executeQuery("SELECT * FROM student");

// 关闭与数据库的连接

con.close();

WebRowSet wrs = new WebRowSetImpl();

wrs.populate(rs);

FileOutputStream out = new FileOutputStream("data.xml");

wrs.writeXml(out);

wrs.close();

}

内容总结

? 对数据库进行SQL语句进行基本操作（包括create, insert, update,delete）

? 使用预编译语句可以提高数据库访问效率及加强安全性

? 可以在应用程序级别使用事务

? 通过事务的级别控制，可以满足不同的业务方面的需求

? 使用存储过程优化查询，提高查询效率

? 操作元数据

? 可滚动的和可更新的结果集

? 批处理更新

? 字符大对象CLOB的用法

? 二进制大对象BLOB用法

独立实践

1、连接oracle数据库，建立个可更新的结果集，对scott用户下的emp表进行批处理更新年龄，姓名等字段。

2、连接sql 2000数据库，使用pubs数据库，建立一个带参数的方法，该方法通过输入表名，能动态打印出该表的记录（包括列名）。

3、写一个保存人简历的程序（有图片）。不要求显示输入和输出，全部通过代码来操作，但是要求从数据库可以看到记录。

4、通过事务操作来实现两个账户转账的过程。（要求自己建表）

5、综合所学知识，对scott用户下的emp表进行增、删、改、查操作。

第二十一章：XML基础

学习目标

? XML的概念

? 定义XML文档

? 命名空间（Naming Space）

? XML 文档规则

? DTD

? SCHEMA

? 样式表（XSL）

XML的概念

XML，称为可扩展标记语言（Extensible Markup Language），用来创建自定义标记的标记语言。它由万维网协会（W3C）创建，用来克服 HTML（即超文本标记语言（Hypertext Markup Language），它是所有网页的基础）的局限。和 HTML 一样，XML 基于 SGML ― 标准通用标记语言（Standard Generalized Markup Language）。XML 是为 Web 设计的。

XML是以数据为中心的，用来标记数据，说明数据是什么的。

应用领域为：

? 信息存储和交换领域，类似于数据管理系统，来存储数据。这种数据处理与硬件，软件没有太大的关系，就是一个文本文件，具有可移植性。处理XML数据的时候，通过JAVA代码写的解析器就可以存取XML数据。

? 在J2EE服务器用的比较多，在服务器端通过XML文件来进行处理数据业务。配置文件几乎全是XML文件。在EJB，Hibernate等JAVA热门技术领域，XML的应用更加重要。

XML与HTML相同点：

? XML与HTML都是基于文本的标记语言。

XML与HTML差别：

? 在功能上最大的区别就是XML是用来存储、传输以及交换数据的，HTML是用来格式化和显示数据的。

? 在内容上的最大的区别是HTML里面的标记（markup）都是定义好的，XML里面的标记都是自定义的。比如：对于那些HTML中的标记中形如"用斜体显示数据"（…）的地方，XML标签则表现为程序中的一个字段名。它为一个数据定义一个标记（label）来表示该数据。（如：andy lau）。注意：由于标识数据可以让你看出其中的意义（如何解释它，应该如何处理它），XML有时也被描述为一种能够指明数据意义（语义）的机制。

HTML是最成功的标记语言。您几乎可以在任何设备（从掌上电脑到大型机）上查看最简单的HTML标记，甚至可以用合适的工具将HTML标记转换成语音和其它格式。既然HTML成功了，为什么W3C（万维网协会）还要创建XML呢？为了回答这个问题，请查看下面这个文档：

张三

男

西安电子科技大学：电子信息工程

HTML的问题在于它是为人设计的。即使不用浏览器查看上面的HTML文档，您和我也会知道那是某个人的信息。作为高级动物---人来讲：您和我具有理解大多数文档的含义和意图的智慧。但是遗憾的是机器不能做到。尽管这个文档中的标记告诉浏览器如何显示该信息，但标记没有告诉浏览器信息是什么？！您和我都知道它是一个人的信息，但计算机并不知道。要显示HTML，浏览器只需遵守HTML文档中的指令即可。段标记告诉浏览器在新的一行显示，并且通常在前面有一个空行，而两个换行标记则告诉浏览器前进到下一行，并且行之间没有空行。尽管浏览器出色地将文档格式化，但计算机仍不知道这个代表某个人的信息。

如下图在浏览器里的显示：

为了完成对样本HTML文档的讨论，请考虑从该信息中提取出该人是学哪个专业的？请看下面的算法：

从该文档中找到有两个
标记的段落，那么学校就是第二个换行标记的后面的第一个冒号后面的内容，尽管该算法对该文档起作用，但是不具备通用性。如果文档格式一改变，那么该算法就不生效了。

现在让我们来看一个样本XML文档。使用XML，您可以给文档中的标记赋予某种涵义。更重要的是，计算机也容易处理这样的信息。

请看下例：

张三

男

西安电子科技大学

电子信息工程

现在算法编写又简单又具有通用性：

我们只需要找到和标记之间的内容（技术上称为元素），就可以从该文档抽取邮政编码。

定义XML文档

有三个通用术语用来描述XML文档的组成部分：标记，元素和属性。

? 标记是左尖括号（<）和右尖括号（>）之间的文本。有开始标记（例如：）和结束标记（例如：）。

? 元素是开始标记，结束标记以及位于二者之间的所有内容。在上面的样本中，元素包含四个子元素,,,.

? 属性是一个元素的开始标记中的名称-值对。如：

80 danwei 是元素的属性。

定义XML基本语法要求：

? XML文档必须包含在一个单一元素中。这个单一元素称为根元素，它包含文档中所有文本和所有其它元素。如：

play majiang

XML文档包含在一个单一元素中。

下面是一个不包含单一根元素的文档：

play pike

play majiang

不管该文档可能包含什么信息，XML解析器都会拒绝它。

? XML元素不能重叠。下面是一些不合乎规则的标记：

刘德华28

如果您在元素中开始了元素，则必须在元素中结束元素。

如：刘德华49

? 不能省去任何结束标记。在下面的XML文档里面标记是不合乎规则的。因为没有任何结束标记。

刘德华

? 空元素：如果一个元素根本不包含标记，则称为空元素。如：

和

是等价的。

? 元素是区分大小写的在HTML中，和是相同的；在XML中，它们是不同的。如果您试图用标记去结束元素，那么将会出错。

我爱深圳市计算机行业协会！ ---------错误

我爱深圳市计算机行业协会！ ---------正确

属性的规则：

? 属性必须有值

? 属性值必须用引号括起

请看下例：

---错误（属性无值）

--错误（属性值没有用引号括起）

----正确

----正确

属性值可以用单引号括起，也可以用双引号括起，但是要始终保持一致。如果属性值包含单引号或双引号，则您可以使用另一种引号来括起该值。如：

description="zhangsan's JAVA is very well",或者使用实体"代表双引号，使用实体'代表单引号。实体是一个符号（如："）,XML解析器会用其它文本代替该符号（如： "）。

XML声明：大多数XML文档以XML声明作为开始，它向解析器提供了关于文档的基本信息。XML 声明通常在XML 文档的第一行出现。XML 声明不是必选项，但是如果使用XML 声明，必须在文档的第一行，前面不得包含任何其他内容或空白。

? 下所示：

声明最多可以包含三个名称-值对。

? version是使用的XML版本；目前最新版本为1.1

? encoding是该文档所使用的字符集。如没有指定encoding,XML解析器会假定字符在utf-8字符集中，这是一个几乎支持世界上所有语言的字符和象形文字的unicode标准。

? standalone(可以是yes或no)定义了是否可以在不读取任何外部实体或外部DTD文档的情况下处理该文档。因为standalone="no"是缺省值，所以您很少会在XML声明中看到standalone。

? 注释可以出现在文档的任何位置；它们甚至可以出现在根元素的前面或后面。注释以结束。注释不能在结束部分以外包含双连字符 --;除此之外，注释可以包含任何内容。最重要的是，注释内的任何标记都忽略；如果您希望除去XML文档的一块较大部分，只需要用注释括住那个部分即可。（要恢复这个注释掉的部分，只需除去注释标记即可。）下面是包含注释的标记：

? 处理指令： XML文件还可以包含处理指令(PI Processing Instruction)，这些指令可以将命令或信息传给正在处理XML数据的应用。

通常它用来传递信息给解析器的下游程序。一般写法如下：

命名空间（Naming Space）

XML 命名空间提供了一种避免元素命名冲突的方法。

命名冲突

因为XML文档中使用的元素不是固定的，那么两个不同的XML文档使用同一个名字来描述不同类型的元素的情况就可能发生。而这种情况又往往会导致命名冲突。请看下面两个例子

这个 XML 文档在table元素中携带了水果的信息:

Apples Bananas

这个 XML 文档在table元素中携带了桌子的信息(家具，不能吃的哦):

African Coffee Table
80
120

如果上面两个XML文档片断碰巧在一起使用的话，那么将会出现命名冲突的情况。因为这两个片断都包含了
元素，而这两个table元素的定义与所包含的内容又各不相同。
使用前缀解决命名冲突问题
下面的XML文档在table元素中携带了信息:
Apples
Bananas
下面的XML文档携带了家具table的信息:
African Coffee Table
80
120
现在已经没有元素命名冲突的问题了，因为这两个文档对各自的table元素使用了不同的前缀，table元素在两个文档中分别是( 和)。
通过使用前缀，我们创建了两个不同的table元素。
使用命名空间
下面的XML文档在table元素中携带了信息:
Apples
Bananas

下面的XML文档携带了家具table的信息:
African Coffee Table
80
120
在上面两个例子中除了使用前缀外，两个table元素都使用了xmlns属性，使元素和不同的命名空间关联到一起。
命名空间属性
命名空间属性一般放置在元素的开始标记处，其使用语法如下所示:
xmlns:namespace-prefix="namespace"
在上面的例子中，命名空间定义了一个Internet 地址:
xmlns:f="http://www.w3s.com/furniture"
W3C 命名规范声明命名空间本身就是一个统一资源标示符，Uniform Resource Identifier (URI)。
当我们在元素的开始标记处使用命名空间时，该元素所有的子元素都将通过一个前缀与同一个命名空间相互关联。
注意：用来标识命名空间的网络地址并不被XML解析器调用，XML解析器不需要从这个网络地址中查找信息，该网络地址的作用仅仅是给命名空间一个唯一的名字，因此这个网络地址也可以是虚拟的，然而又很多公司经常把这个网络地址指向一个真实的Web页面，这个地址包含了关于当前命名空间更详细的信息。
可以访问http://www.w3.org/TR/html4/.
统一资源标识符
通用资源标识符Uniform Resource Identifier (URI)是一个标识网络资源的字符串。最普通的URI应该是统一资源定位符Uniform Resource Locator (URL)。URL用于标识网络主机的地址。另一方面，另一个不常用的URI是通用资源名字Universal Resource Name (URN)。在我们的例子中，一般使用的是URLs。
既然前面的例子使用的URL地址来标识命名空间，我们可以确信这个命名空间是唯一的。
默认的命名空间
定义一个默认的XML命名空间使得我们在子元素的开始标记中不需要使用前缀。他的语法如下所示:

下面的XML文档在table元素中包含了水果的信息:

Apples Bananas

下面的XML文档包含了家具table的信息:

African Coffee Table
80
120

使用命名空间

文档开始使用XSL的时候,就会发现命名空间使用的是如此频繁。XSL样式单主要用于将XML文档转换成类似于HTML文件的格式。

如果看一下下面的XSL文档，就会发现有很多标记都是HTML标记。那些标记并不是HTML标记，是加了前缀的XSL,这个XSL前缀由命名空间"http://www.w3.org/TR/xsl"所标识:

Title Artist

XML 文档规则

XML 文档规则是用来规定XML文档有那些标记组成，标记的多少，顺序，属性等方面的内容。也就是规定XML的格式及内容。目的是为了解析器解析该XML文档提供方便。XML的文档规则有两种：DTD和XML Schema

DTD（Document Type Definition）文档类型定义

DTD定义可以在XML文档中出现的元素，这些元素出现的次序，它们可以如何相互嵌套以及XML文档结构的其它详细信息。

XML Schema

模式可以定义您能在DTD中使用的所有文档结构，还可以定义数据类型和比DTD更复杂的规则。

因此XML 文档可以分为三个类型：

? 格式良好的：满足XML的基本的语法特点，但是不遵守DTD或者XML Schema。

? 有效的文档：即满足了XML的基本的语法特点，又遵守DTD或者 XML Schema。

? 无效的文档：不满足XML的基本的语法特点。或者该文档不遵守DTD或者XML Schema

首先我们介绍下DTD（Document Type Definition）文档类型定义

XML强大之处在于可以定制自己的标记来替代预先定义的标记集。这里的最大问题在于如何让处理器明白这些自定义的标记，同时我们常说XML要求文档结构完整，这意味着我们必须在提供XML文件时提供它的语法规范。为此，XML需要有一个文档来定义标记的含义，元素相关的属性等，这样解析器就能够检查输入的数据是否正确。

DTD可以包含在XML文档中，也可以独立为一个文件。一个符合DTD验证的XML文档是有效的文档。

请看下例：(student.dtd)

该DTD定义了样本文档中使用的所有元素。它定义了三个元素

? 元素包含零个或者多个元素。

? 元素包含一个,一个,一个
,和一个可选的元素。也就是说,,
元素必须出现，而〈phone〉元素可有可无，但是这些元素必须按先后顺序出现。

? 包含文本的元素：（#PCDATA）表明该元素必须包含经过解析的字符数据，经过解析的字符数据实质上就是不是标记的任何文本，即该元素不能包含自己的子元素）

? 其中元素有个可选的属性xusui.

尽管DTD相当简单，但它清楚地说明了什么样的元素组合是合乎规则的。元素出现在元素之前就是不合乎规则的。另外，请注意，DTD语法不同于普通的XML语法。（XML Schema 文档本身就是XML）。尽管DTD的语法不同，但您仍可以将普通的注释放到DTD中。

下面的XML文档是满足上面DTD的文档：

andy

49

luohu luohukejidasha

goudan

当年减出生年加1">28

shanxi xi an

02988755660

当然也可以把dtd文档写到XML文档内部：

xusui CDATA #IMPLIED>

]>

andy

49

luohu luohukejidasha

goudan

当年减出生年加1">28

shanxi xi an

02988755660

下面分析把DTD文档写在XML文档内部和写在外部的对比：

如果采用外部DTD的话，就需要有两个文档，第一个文档就是关于DTD的文档，第二个文档就是遵守DTD格式的内容文档。实际上，我们可以建立无穷多个遵守该DTD格式的文档。我们在构造关系数据库中的表的时候，需要定义好表的结构（也就是表包含的字段集合），然后就可以往这个表中放入记录，记录的个数从理论上讲可以是无穷多个的。这里关于表的结构就类似于DTD文档，记录类似于遵守DTD格式的内容文档。

外部DTD的好处是：它可以方便高效地被多个XML文件所共享。你只要写一个DTD文件，就可以被多个XML文件所引用。事实上，当许多组织需要统一他们的数据交换格式时，他们就是通过外部DTD来完成的。这样做不仅简化了输入工作，还保证当你需要对DTD做出改动时，只需改动一个公用的DTD文件，而不用一一去改动每个应用了它的XML文件。不过需要注意，如果DTD的改动不是"向后兼容"的，这时原先根据该DTD编写的那些XML文件可能就会出现问题了。所以在改动DTD时，一定要尽量兼容以前的文档，除非解析器变了。(类似于JAVA的JDK的发展，JDK的每个版本的发布都会兼容以前的版本，这样在换JDK时，以前的程序就不要改动了。目前的最新JDK的版本是1.6也叫6.0)

由以上的例子可知，建立合法XML文件的要点之一就是要定义好DTD，然后所有的内容就按照DTD格式进行编写。DTD实际上表现了一个层次关系，你也可以把它理解成一棵树的结构。树中的节点实际就是一个个元素（ELEMENT）,一个元素包含其他的元素。

对于一个DTD的定义，最关键的在于它内部的元素和属性的定义。按上面例子的理解，一个DTD文档实际上就是元素定义的集合，而元素可能包含属性，也可能不包含属性。属性可以通过以下的语法进行定义：

AttributeName Type Default

AttributeName Type Default

…

>

ATTLIST是一个XML语言的保留关键字，ElementName表示元素的名称，它相当于程序设计语言中变量的名称。一个元素可以包含多个属性，一个属性由三部分构成：AttributeName,Type和Default。AttributeName表示该属性的名字，Type表明该属性的类型，Default表明该属性的特点。我们先来看一下XML所定义的属性类型的种类，如下表：

类型具体的含义说明

CDATA 这个类型表明该属性只能包含字符数据，比如”刘德华”，“hibernate”,”小罗”等等

ID 该属性的取值必须是唯一的，就像我们每个人都有的身份证号码是唯一的一样，在一个文档内两个ID属性的值不能一样

IDREF，IDREFS 这个属性的值实际上就像C++中的指针一样，它是一个指向文档中其他地方声明的ID值，所以，如果在具体的文档中该属性的取值和它所指向的ID值不匹配的话，就会返回错误。IDREFS和IDREF类似，但是可以具有由空格分隔的多个引用

ENTITY,ENTITIES ENTITY属性的值必须对应一个在DTD文档内声明的但还没有分析过的实体。ENTITIES属性和ENTITY类似，不同的是它可以包含多个实体，外部实体，参数实体和外部参数实体。可以把实体理解为程序设计语言中的变量

NMTOKEN，NMTOKENS NMTOKEN是CDATA的一个子集，它所使用的字符必须是字母，数字，句点，破折号，下划线或冒号。NMTOKENS和NMTOKEN类似，不同之处在于它可以包含多个值，每个值之间用空格进行分隔

NOTATION NOTATION的值必须引用已在DTD文档其他地方声明过的某注解名称

NOTATION（enumerated）该属性的值必须匹配NOTATION名称列表中的某个名称。比如，我们已经存在两个NOTATION，一个为beauty,一个为beast;我们可以定义一个属性类型为NOTATION（beauty|beast）

Enumerated 该属性几乎和C++中的枚举变量一样（JDK1.5里面也有枚举类型），我们事先定义好一些值，该属性的值必须匹配所列出的这些值。比如现在有值为美丽，魅力，温柔，体贴，该属性的类型就可以表现为（美丽|魅力|温柔|体贴），实际内容文档必须从这些值中取一个，值之间用“|”进行分隔

Default属性特点可以有四种形式：#REQUIRED,#IMPLIED,#FIXED value,Defaultvalue.下表对这四种形式进行了详细介绍：

值含义

#REQUIRED 用来告诉XML解析程序，该元素的所有实例都必须有该属性的值，就像数据表中某一个字段为NOT NULL一样

#IMPLIED 表示如果该元素的实例中没有指定该元素的值的话，就忽略该属性，就像在数据表中某一个字段的值可以为NULL一样

#FIXED value 表示包含该属性的元素实例必须在指定列出的值中，比如一个属性名称为学员：学员 CDATA #FIXED “刘德华”

表示属性值只能去“刘德华”

Defaultvalue 为属性提供一个默认的值比如一个属性名称为学员：学员 CDATA “刘德华”如果在该属性的实例中没有包含这个属性的话，解析器就认为该属性的值就是“刘德华”，如果在该属性的实例中包含了这个属性并赋值了的话，就采用这个赋值

下面的DTD例子用来说明属性类型IDREF/IDREFS的使用：

如下例：

relID ID #REQUIRED

parentID IDREFS #IMPLIED

name CDATA #REQUIRED

>

请注意：这里的parentID的类型为IDREFS，这个表明该属性的值必须在XML文档中出现过。如果该属性的值没在XML文档中出现过的话，解析器就认为该文档是不合法的。比如，下面的文档就是一个不合法的文档：

李雨春" />

狗蛋" />

张曼玉" />

小罗" />

原因是parentID中出现了值 "p6",而这个值并没有在文档中出现过。

元素的定义语法为：

这里ELEMENT是XML语言的关键字，NAME表示元素的名称，CONTENT表示元素的类型。它指定了元素起始标记和结束标记之间允许包含的东西。CONTENT可以以下几种形式出现，如下表：

内容解释

EMPTY 如果一个元素的CONTENT被声明为EMPTY的话，表示该元素不能包含任何子元素和文本

ANY 表示该元素中可以包含任何在DTD中定义的元素内容

#PCDATA 表明该元素可以包含任何字符数据，但是不能在其中包含任何子元素。

假设我们定义元素学员：

则下面的实例是正确的：

比耳盖茨

而下面的实例就是错误的：

比耳盖茨

因为在其中包含了子元素

一般如果定义元素的CONTENT为#PCDATA,最好在其中只加入纯文本字符数据

其他类型最通常的情况是一个元素本身是由其他元素的集合构成的

在前面的一些例子中，大家一定注意到了"|","+","*"等这些符号，这些符号具体的含义及使用方法见下表：

符号符号类型描述示例示例说明

() 括号用来给元素分组（刘德华|张学友），（小罗|卡罗斯），盖茨分成三组

| 竖条表明在列出的对象中选折一个（爱人|朋友）表示爱人和朋友必须出现，且只能出现一个

+ 加号表示该对象最少出现一次，可以出现多次（student+）表示student必须出现，可以出现多次

* 星号表示该对象允许出现任意多次，也可以是零次（爱好*）爱好可以出现零次到多次

? 问号表示该对象可以出现，但只能出现一次（爱人?）爱人可以出现一次或零次

, 逗号表示对象必须按指定的顺序出现 (name,sex,age) 表示name,sex,age必须顺序出现

有时我们还会在DTD中遇到一些实体的定义，一般分为以下两种情况：

内部实体：

〉

外部实体：

它们在XML文档中的使用是统一的：

〈computer〉&texing;

最后，我们在看个例子：〈shenzhen.dtd>

下面是满足上面DTD的XML文档：

质料整理\xml\shenzhen.dtd">

&miaoshu;

XML Schema

上面我们讨论了用DTD来验证XML文档，虽然DTD胜任对XML文档结构的验证，但是它有很多局限。为此，微软提出了Schema的方案来改进DTD。Schema从字面意义上来说，可以翻译成架构，它的基本意思是为XML文档制定一种模式。Schema相对于DTD的明显好处是XML Schema文档本身也是XML文档，而不是像DTD一样使用自成一体的语法。这就方便了用户和开发者，因为可以使用相同的工具来处理XML Schema和其他XML信息，而不必专门为Schema使用特殊的工具。Schema简单易懂，懂得XML语法规则的人都可以立刻理解它。Schema的概念提出已久，但W3C的标准最近才出来，相应的应用支持尚未完善，但采用Schema已成为XML发展的一个趋势。

请看下例：

elementFormDefault="qualified" attributeFormDefault="unqualified">

张艺谋

刘德华

xsi:noNamespaceSchemaLocation="D:\java\xml\movie.xsd">

张艺谋

刘德华

从上例可看出这两个XML文当格式完全是一样的。只不过采用的模式文档不一样，一个是DTD 一个是 XML Schema。

在XML Schema中，元素是通过它的名字和类型来确定的。名称就是该元素的名字，类型就像JAVA中的一个变量，有基本类型（int double char等），有复杂类型（类类型）。在Schema中也是一样，类型（type）可以分为两种形式,一种是简单类型，一种是复合类型。简单类型不能包含元素和属性。复杂类型不仅可以包含属性，而且可以在其中嵌套其他的元素，或者可以和其他元素中的属性相关联。

Schema和DTD的区别：

XML从SGML中继承了DTD，并用它来定义内容的模式，验证和组织元素。同时，它也有很多局限，如下所述：

? DTD不遵守XML语法；

? DTD不可扩展；

? DTD不支持命名空间的应用；

? DTD没有提供强大的数据类型支持，只能表示很简单的数据类型。

Schema完全克服了这些弱点，使得基于Web的应用系统交换XML数据更为容易。下面是它所展现的一些新特性：

? Schema完全基于XML语法，不需要再学习特殊的语法；

? Schema能用处理XML文档的工具处理，而不需要特殊的工具；

? Schema大大扩充了数据类型，支持boolean,number,date and times,URI,integer,decimal number 等等

? Schema支持原型，也就是元素的继承。如：我们定义了一个"狗"数据类型，然后可以根据它产生"狼狗"和"纯狗"两种数据类型；

? Schema支持属性组。我们一般声明一些公共属性，然后可以应用于所有的元素，属性组允许把元素，属性关系放于外部定义，组合；

? 开放性。原来的DTD只能有一个DTD应用于一个XML文档，现在可以有多个Schema运用于一个XML文档。

Schema的数据类型

基本数据类型

下表列出的是最基本的数据类型，被W3C组织所承认：如下表：

数据类型相关特性描述

string length,pattern,maxLength,minLength,enumeration,

whiteSpace 表示字符串

boolean pattern,whiteSpace 布尔型

decimal enumeration,pattern,minInclusive,minExclusive,

maxInclusive,maxExclusive 代表特定精度的数字

float pattern,enumeration,minInclusive,minExclusive,

maxInclusive,maxExclusive 表示单精度32位浮点数

double pattern,enumeration,minInclusive,minExclusive,

maxInclusive,maxExclusive 表示双精度64位浮点数

duration pattern,enumeration,minInclusive,minExclusive,

maxInclusive,maxExclusive 表示持续时间

dateTime pattern,enumeration,minInclusive,minExclusive,

maxInclusive,maxExclusive 代表特定的时间

time pattern,enumeration,minInclusive,minExclusive,

maxInclusive,maxExclusive 代表特定的时间，但是是每天重复的

date pattern,enumeration,minInclusive,minExclusive,

maxInclusive,maxExclusive 代表日期

hexBinary length,pattern,maxLength,minLength,enumeration 代表十六进制数

anyURL length,pattern,maxLength,minLength,enumeration 代表一个URL,用来定位文件

NOTATION length,pattern,maxLength,minLength,enumeration 代表NOTATION类型

扩展数据类型

下面这些类型是微软扩充的数据类型，并没有被W3C组织完全采纳。

数据类型相关特性描述

ID length,enumeration,pattern,maxLength,

minLength 用于唯一标识元素

IDREF length,enumeration,pattern,maxLength,

minLength 参考ID类型的元素或属性

ENTITY length,enumeration,pattern,maxLength,

minLength，whiteSpace 实体类型

NMTOKEN length,enumeration,pattern,maxLength,

minLength NMTOKEN类型

NMTOKENS length,enumeration ,maxLength,

minLength，whiteSpace NMTOKEN类型集

long enumeration,pattern,fractionDigits,

minInclusive,minExclusive,maxInclusive,

maxExclusive,totalDigits,whiteSpace 表示整型数，大小介于-9223372036854775808和9223372036854775807之间

int enumeration,pattern,fractionDigits,

minInclusive,minExclusive,maxInclusive,

maxExclusive,totalDigits,whiteSpace 表示整型数，大小介于-2147483648和2147483647之间

short enumeration,pattern,fractionDigits,

minInclusive,minExclusive,maxInclusive,

maxExclusive,totalDigits,whiteSpace 表示整型数，大小介于-32768和32767之间

byte enumeration,pattern,fractionDigits,

minInclusive,minExclusive,maxInclusive,

maxExclusive,totalDigits,whiteSpace 表示整型数，大小介于-128和127之间

数据类型的相关特性

前面这些数据类型说明中都有一列相关特性，用于说明该列的类型的一些扩充应用。下面是对它们应用的描述：

enumeration

指定的数据集中选折，主要的目的是为了能限定用户的选值。

fractionDigits

限定最大的小数位，主要用于控制精度。

length

指定数据的长度单元

maxExclusive

指定数据的最大值。其他值必须小于它

maxInclusive

指定最大值，其他值可以小于等于它

maxLength

指定长度的最大值

minExclusive

指定最小值，其他值必须大于它。

minInclusive

指定最小值，其他值可以大于等于它。

minLength

指定长度的最小值

pattern

规范数据的显示规范，使得数据必须匹配它的显示方式。

Schema的元素类型

Schema 比DTD中的元素类型丰富得多，这可使用户和程序都更容易确定元素的种类，下面的表，只是列出了最常用的元素类型。

元素类型描述

schema 包含一个已经定义的schema

element 声明一个元素

group 把一组元素声明组合在一起，以便它们能够一起被复合类型应用

attribute 声明一个属性

attributeGroup 把一组属性声明组合在一起，以便他们能够一起被复合类型应用

choice 允许唯一的一个元素从一个组中被选择

simpleType 定义一个简单类型，它决定了元素和属性值的约束和相关信息

simpleContent 应用于complexType,对它的内容进行约束和扩展等

complexType 定义一个复合类型，它决定了一组元素和属性值的约束和相关信息

list 从一个特定数据类型的集合中选择定义一个简单类型元素

union 从一个特定简单数据类型的集合中选择定义一个简单类型元素

unique 定义一个属性或元素值，它必须在一个特定范围内

squence 给一组元素一个特定的序列

restriction 定义一个约束条件

Schema的样例如下：

elementFormDefault="qualified" attributeFormDefault="unqualified">

其中xs命名空间指定的是W3C组织的定义，也就是遵循它的标记集规范。目标命名空间是全局的，指定目标命名元素符合本Schema的定义。elementFormDefault的取值有两个选择：

unqualified和qualified,前者表示目标命名空间不一定遵循本Schema，后者则必须遵循。attributeFormDefault类似。

elementFormDefault="qualified" attributeFormDefault="unqualified">

在element中有些常用的属性：

name 代表该元素的名字，不能和ref同时使用；

type 代表该元素的类型，可以是已有的简单类型，也可以自定义复合类型，或者应用其他命名空间中的类型定义，不能和ref同时使用；

minOccurs 表示该元素出现的最少次数；

maxOccurs 表示该元素出现的最大次数；

ref 表示该元素参考已经定义的元素；

fixed 表示该元素的值是不能改变的，不能与default一起使用；

default 表示该元素的缺省值；

substitutionGroup 表示这个元素的父类，如狼狗也属于狗这一类。

样式表（XSL）

XML是一种程序交换原始数据的简单而标准的方法，然而基于XML的数据本身并不包含数据显示的信息。为了使数据便于阅读理解，我们需要将信息更好地显示。类似于MVC模式，XML文档是M的部分，样式表就是V的部分，也就是说，同一个XML文档可以有多个显示效果（样式表）。样式表就是这样一种为XML文档"化妆"的文档，它是一种专门描述结构文档表现方式的文档，即可以描述这些文档如何在屏幕上显示，也可以描述它们的打印效果，甚至声音效果。使用样式表定义XML文档数据的显示方式，将XML数据与其表达形式分离的做法符合业界提倡的数据和表示层分开的思想（MVC）。这样一来，XML格式文档不会重蹈某些HTML文档（以显示数据为主）结构混杂，内容繁乱的覆辙，XML的编写者也可以集中精力于数据本身，而不受显示方式的细枝末节的影响。不仅如此，样式表还带来另一个好处，即定义不同的样式表可以使相同的数据呈现不同的显示外观，从而适合于不同应用，甚至能够在不同的显示设备上显示。这样，XML数据就可以得到最大程度上的重用性，满足不同的应用需求。迄今为止，W3C（WWW标准化组织）已经给出了两种样式表语言的推荐标准：一种是级联样式表CSS（Cascading Style Sheets），另一种是可扩展样式表语言XSL（eXtensible Stylesheet Language）。下面，我们就来讲述这两种样式表。

CSS样式表

级联样式表CSS是一种样式描述规则，是一种针对HTML而提出的样式表语言，现在同样可以很好地应用与描述XML文档的显示。利用CSS，我们可以定义HTML或XML文档中元素的显示效果，包括元素的位置，颜色，背景，边框，字体，排版格式等等。

请看下面的一个XML文档：

andy

49

中国香港铜锣弯

我们定义显示上面XML文档的CSS样式表（test.css），如下：

person

{

margin-top:.7in;

margin-bottom:.7in;

margin-left:1.5in;

margin-right:1in;

background-color:blue;

display:block

}

name

{

display:block;

font-family:Arial,Helvetica,sans-serif;

font-size:32pt;

width:10em;

color:red

}

age

{

display:block;

font-size=x-large;

color:yellow

}

address

{

display:block;

font-size:20pt;

color:cyan

}

显示效果如下图：

在XML中引用一个级联样式表，我们使用如下的处理指令：

样式表路径"?>

我们在示例XML的文档的第二句，引入了样式表。

XML解析器解析XML文档和CSS文件，并执行如下任务：

解析"person.xml",抽取其元素；

使用"test.css"文件，应用样式格式化XML文档中的元素。

XSL样式表

XSL是一种用来转换XML文档的样式表，它包含转换和格式化XML文档的规则。XSL在转换XML文档时分为明显的两个过程：首先转换文档结构，然后将文档格式化输出：如下图：

这两个步骤可以分离开来单独处理，因此在XSL发展过程中逐渐分裂为两种分支：XSLT（结构转换）和XSL-FO（格式化输出）。其中XSL-FO的作用类似于CSS在HTML中的作用，由于其发展缓慢而不成熟，W3C至今还未能出台一个得到多方认可的XSL-FO，而且目前主流的浏览器大都不支持XSL-FO，本书不对其做讲解。前面学习XML时，我们已经知道XML是一个完整的树形结构文档。在转换XML文档时可能需要处理其中的一部分（节点）数据，那么如何查找和定位XML文档中的信息呢？XPath就是一种专门用来在XML文档中查找信息的语言，用来描述如何识别，选择，匹配XML文档中的各个构成元件，包括元素，属性，文字内容等。XPath隶属XSLT，因此，我们通常会将XSLT语法和XPath语法混在一起说。用一种比较好理解的解释：如果将XML文档看作一个数据库，XPath就是SQL查询语言；如果将XML文档看成DOS目录结构，XPath就是cd,dir等目录操作命令的集合。XSL包含XSLT和XPath的强大功能，从而可以把XML文档转换成任何一种其它格式的文档，例如XML文档，HTML文档，XHTML文档等等，限于目前浏览器的支持能力，在大多数情况下，XSL将XML文档转换为一个HTML文档进行显示，本节中我们主要讲述怎样使用XSL样式表将XML文档转换为HTML文档。

XSL的基本结构

为了让大家能够对XSL有一个感性认识，并很快地掌握它的精髓，我们先看一个简单例子。通过剖析这个例子，来掌握XSL的基本结构和一些基本语法。

请看下面的XML文档：

李明

男

97

69

76

张一强

男

92

83

62

王亮

男

74

91

71

赵三金

女

89

93

67

下面是上面的XML文档所引用的teststudents.xsl:

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:fo="http://www.w3.org/1999/XSL/Format">

第一期东北JAVA班部分学员

成绩单

姓名性别 java oracle mssql

显示结果如下图：现在我们来分析一下这段XML代码的执行过程：

在作为XML声明和XSL声明之后，样式表利用声明XSL模板，并调用该模板。

根据,系统最先匹配XML源树的根节点。根节点用"/"表示，它的匹配方法在一对括起的源码中声明。按照这段代码，首先生成带有样式信息的HTML文档的开头一段代码。

第一期东北JAVA班部分学员

成绩单

下面，系统看到了的指示，于是，它在XML源树中寻找标记为"students"的节点进行匹配。就像函数调用一样，现在系统跳到了用括起的"函数"中继续生成下面的HTML代码。

现在，系统又接到了新的指示。这条指示要求系统寻找标记为"student"的子节点,对于每一个"student"子树中的内容，系统为其生成表中一行的内容。每一行包含四列，分别把标记为"name","sex","java","oracle","mssql"的节点的内容填进去。对应到本例中的XML数据，生成的HTML代码：
< td >97 < td >69< td >76
< td >92 < td >83< td >62
< td >74 < td >91< td >71
< td >89 < td >93< td >67
处理完中的内容，系统继续生成HTML代码：

姓名性别 java oracle mssql

李明男

张一强男

王亮男

赵三金男

至此，系统已经处理完中的所有内容，可以"函数返回"了。系统返回到括起的源码中，完成HTML最后两行代码的生成：

把上面的HTML代码串起来，就是生成的转换结果文件。

分析上面的例子，我们可以看出一个XSL文件基本上由几部分组成：

因为XSL文档本身是XML文档，因此文档的第一句就是XML声明：

接下来就是XSL声明：

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:fo="http://www.w3.org/1999/XSL/Format">

输出模板--

在XSL声明中包含模板，模板中定义XML的输出格式。

XSL文档本身是结构完整的XML文档，所以在书写时要注意标签的匹配问题。既是XSL的声明语句，也是根元素，必须位于文件的首部，通常也要利用xmlns属性指明XSL的命名空间。样式表中所有的模板都由标签标明，模板可以说明处理的对象（元素，属性），处理的方式或是转换的结果。此时，我们可以把该标签类似地理解为编程语言中函数的概念。

XSL的基本语法

通过对上面XSL转换XML文档为HTML文档的简单例子的分析，相信大家对XSL的基本语法有了一个初步的认识，下面我们再来详细分析一下XSL的元素语法。

XSL模板：

模板是XSL中最重要的概念之一，XSL文件就是由一个一个的模板组成的，任何一个XSL文件至少包含一个模板。可以把XSL的设计细化成一个个模板，最后再将这些模板组合成一个完整的XSL。这种方法如同程序中模块化设计逐步细化一样，可以使你先从整体上考虑整个XSL的设计，然后将一些表现形式细化成不同的模板，再具体设计这些模块，最后将它们整合在一起。模板中两个主要的元素为：和, 这两个元素相结合，就如同编程中的函数调用：前者是调用指令，而后者就是函数体。

定义一个模板的基本语法是：

输出模板-->

属性match则控制模板的匹配模式，确定在什么情况下执行此模板。属性match的取值把模板规则与指定的元素或属性相比较，只有指定的节点才会被处理。其中最上层的模板即根节点必须将match取值设定为"/"。

输出根节点的模板-->

如果属性match的取值为"*"，那么表示该规则适用于所有的未单独指定处理的元素节点。比如下例中的第二个模板就表示要处理除元素之外的所有节点。

输出模板-->

输出模板-->

此外，XSL中还可以使用路径指示符来指定一些特殊位置的元素与模板相匹配。"//"代表任意深度位置，如用来匹配文档中任何位置的元素；而如果是,则表明是匹配元素的后继节点中所有元素。另外一个路径指示符是"/"，表示直接的父子节点关系。将刚才例子中的"//"换为"/"，就意味着匹配的是元素子节点中的元素。XSL在输出模板中描述输出格式，这些格式可以是各种字符串，标签符号，节点值或者是一些XSL语法结构，如条件判断，循环处理等。模板定义完毕后，就可以在XSL中调用该模板，调用一个模板的语法为：

用来说明哪一个节点被模板具体处理。你可以将它理解为程序中调用子函数。Select属性用来定义确切的节点名称。总是包含在元素中，像这样：

这段代码说明模板匹配整个文档（根节点），具体执行时处理根节点下所有students元素。对于不同的元素需要调用不同的模板进行处理。为了激活样式表中的模板规则，要在根元素模板规则中使用元素，这样就会层层作用使整个样式表文件生效。直接使用表示不加区分地对当前节点的所有子节点应用模板，而在select属性中书写匹配式则能够限定作用对象：

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:fo="http://www.w3.org/1999/XSL/Format">

上述第一个模板与XML文档中的根元素相匹配，并对根节点以下的所有元素应用模板规则。然后，一旦遇到标签，就对元素和元素分别应用模板规则。最后，经过转换显示的结果是学生姓名和java成绩。

节点选择语句

在许多应用场合中，输出模板中需要使用节点的取值，此时可以根据需要使用语句输出节点值，最直接的使用方式是使用空元素，这样可以输出当前节点及其后继节点的取值。而如果仅仅是想输出指定节点的取值，可以利用select属性进行限定（select属性可以是任意合法的路径表达式）。

上述第一个表达式匹配的对象是当前节点的所有子节点中名称为的元素，第二个表达式匹配的对象则是当前节点中所有后继节点中名为的元素。注意：在XSL样式表中必须有一个模板规则与根元素相匹配。例如想在输出文档中显示学生成绩单XML源文档中的name元素的值，可以这样写XSL代码：

其中match="student"定义模板匹配student节点，xsl:value-of语法说明需要输出一个节点的值，而select="name"则定义需要被输出的元素为name。这个过程类似于在数据库里查询一个人的名字。

循环判断语句

在XML文档中，如果存在两条以上的数据，必须使用元素指定上层的节点元素，再用设定要输出的内容，才能显示整个XML文档数据。这种循环结构能够遍历整个结果集合，而不必针对每一条结果都单独书写转换规则。它的标准语法格式为：

….

条件判断语句

语句是简单地对条件进行判断，结果为真就执行条件内部的规则，因此可以把if条件与简单的布尔表达式联合使用。

有三种不同的用法，如果要用元素的名称作为匹配条件，语法是：

元素名称" >

下面的例子对"name"元素的内容用红色显示：

xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

xmlns:fo="http://www.w3.org/1999/XSL/Format">

第一期东北JAVA班部分学员

成绩单

姓名性别 java oracle mssql

显示的XML文件为：

如果用元素内容作为匹配条件，语法是：

元素名称[.='元素内容']" >

注意："."表示当前元素。请看下例，如果名字是叫李明的显示红颜色。

李明']">

内容总结

? 会写XML文档

? 理解XML命名空间概念

? 掌握DTD，SCHEMA的用法

? 会通过使用XSL进行XML的显示

? 知道XML的作用

? 正确使用XML技术

独立实践

? 写一个关于学生课程信息的DTD和SHEMA文档

? 根据上面的DTD，SCHEMA文档写出XML文档，并定义XSL显示该XML

? 写一个数据库连接的DTD和SHEMA文档

? 根据数据库连接的DTD和SHEMA文档，写出XML文档，为下一章解析XML，创建数据库连接做准备

? 以下XML 文件不是一個有效的文件，為什麼？

]>

理工图书馆

理工大道一号

文法商图书馆

文管大道一号

总图书馆

如何当个称职的职场新鲜人

如何管理資料库

JAVA 十天速成手冊

修改上面的代码并写出相应的Schema

第二十二章：使用Java解析XML

学习目标

? 解析器的介绍

? 文档对象模型（DOM）解析实例

? SAX解析实例

? DOM4J解析实例

? JDOM解析实例

? JAVA操纵XML 实例讲解

解析器的介绍

XML解析器是读取XML文档并分析其结构的代码。这一部分将介绍XML解析器是如何工作的。将讨论不同类型的XML解析器及何时使用它。

一般而言使用解析器需要以下步骤：

? 创建一个解析器对象

? 使解析器指向您的XML文档

? 处理结果

显然第三步最为复杂。一旦知道了XML文档的内容，比方说，您可能希望生成一个Web页面，创建一个订单或者做一个饼图。这里讨论的常见XML解析工具使这项工作大大简化。

解析器有不同的分类方法：

? 验证和非验证解析器

? 支持一种或多种XML Schema语言的解析器

? 支持Document Object Model (DOM)的解析器

? 支持Simple API for XML (SAX)的解析器

我们已知有三种不同类型的XML文档：

? 结构良好的文档：这类文档符合XML基本规则（属性必须放在引号中，标签必须正确嵌套等）。

? 有效文档：这些结构良好的文档同时还符合文档类型定义（DTD）或XML Schema所定义的规则。

? 无效文档：除以上两种文档外的所有其他文档。

如果您有一个XML文档符合XML的基本规则，那么它就是一个结构良好的文档。如果该文档还满足您的公司所定义的支出帐目文档规则，那么它也是有效的。如果XML解析器发现XML文档不是结构良好的，XML Specification要求解析器报告一个致命错误。

验证解析器：在解析时验证XML文档，而非验证解析器：不验证文档。换句话说，如果一个XML文档是结构良好的，那么非验证解析器并不关心文档是否符合DTD或模式中定义的规则，甚至不关心该文档是否符合DTD或模式中定义的规则，甚至不关心该文档是否有这样的规则。（多数验证解析器都默认关闭验证功能。）

那么为什么要使用非验证解析器呢？有两个很好的理由：速度和效率。XML解析器读取DTD或者模式，建立规则引擎保证XML文档中的每个元素和属性都遵循这些规则，需要做大量的工作。如果您确信一个XML文档是有效的，那么就可以完全跳过验证。根据文档规则复杂程度的不同，这样可以节约相当可观的时间和内存。如果您的代码不够健壮，它从XML文档中得到输入数据，并且该代码要求文档遵循特定的DTD或者模式，那么您可能就不得不验证所有的内容，不论代价多么高，多么浪费时间。

DOM是W3C推荐的正式标准。它定义了一个接口，程序能够访问和更新XML文档的结构。如果一个XML解析器声称支持DOM，就意味着它实现了该标准中定义的接口。目前，有三个级别的DOM是正式的推荐标准，被命名为DOM Level 1,DOM Level 2 和DOM Level 3。本章中所讨论的DOM功能都是DOM Level 2的一部分。

DOM解析器：当你使用DOM解析器解析一个XML文档时，您得到一棵结构树，它表示XML文档的内容。所有的文本，元素和属性，都在这个树结构中

解析的过程：

解析后的XML文档。 DOM还提供各种不同的功能，可用于分析和操作树的内容和结构。DOM是处理XML数据的传统方法。使用DOM时，数据以树状结构的形式被加载到内存中，所以，DOM解析是一个比较耗费内存的操作。如上图所示，矩形框表示元素节点，椭圆表示文本节点。DOM使用父子关系。例如，在这个例子中，student是具有五个孩子的根元素：三个文本节点（空白），以及两个元素节点name和age。要认识到的一件重要事情是，name 和 age节点实际上具有null值。相反，它们具有文本节点（goudan 和 28）作为孩子。

DOM以及广义的基于树的处理具有几个优点

首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。

另一方面，在内存中构造这样的树涉及大量的开销。大型文件完全占用系统内存容量的情况并不鲜见。此外，创建一棵DOM树可能是一个缓慢的过程。为了满足该缺点，我们使用SAX（Simple API for XML）API处理XML文档内容。它的设计目标是占用更少的内存，把更多的工作交给程序员。SAX和DOM是互补的，有各自的适用环境。请看下图解析过程：

当使用SAX解析器解析一个XML文档时，解析器在读取文档的过程中会生成一系列的事件。至于如何处理这些事件则取决于您的需求。下面列出了一小部分您在XML文档时可能遇到的事件：

? startDocument事件

? 对于每个元素，在元素开始时有startElement事件，元素结束时有endElement事件

? 如果元素包含内容，对于文本将出现characters事件，对于子元素将出现startElement和endElement事件，依此类推

? endDocument事件

如下代码及过程：

goudan

28

分析这个代码片段的SAX处理器，一般情况下将产生以下事件：

startDocument

startElement (person)

characters (white space)

startElement (name)

characters (goudan)

endElement (name)

characters (white space)

startElement (age)

characters (28)

endElement (age)

characters (white space)

endElement (person)

endDocument

这种处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。

另一方面，由于应用程序没有以任何方式存储数据，使用SAX来更改数据或在数据流中往后移是不可能的。尽管SAX和DOM提供了许多有用的功能，对于程序员而言有些任务还是太复杂了。延续开源社群有需要就创建工具的历史传统，Java技术专家Jason Hunter 和Brett McLaughlin缔造了JDOM，这个Java库极大简化了XML文档的处理。和DOM类似，JDOM也提供一个对象树表示XML文档，但是这些对象工作的方式对Java程序员更直观。要记住，JDOM在背后包含使用普通SAX或DOM 解析器的适配器； JDOM对所有主要的（和几个次要的）Java XML解析器都提供了适配器，因此不必担心您的Java XML解析器是否支持JDOM，JDOM在幕后使用的解析器不需要您的干涉。

一般来说以下情况应使用DOM解析器：

? 需要详细了解文档的结构

? 需要改变文档的结构（也许您需要对元素排序，增加新的元素等等）

? 需要多次引用解析的信息

进一步推广，在以下情况中应使用SAX解析器：

? 内存少

? 只需要XML文档中少量元素或属性

? 解析的信息只使用一次

JDOM的内存使用比DOM少，但是不如SAX好。此外，如果您希望进行验证，JDOM要求您设置底层的解析器，JDOM本身不进行验证。就是说，如果JDOM能够完成您所需要的所有功能，而且速度满足您的需要，它可以简化您的编码工作。

文档对象模型（DOM）解析实例

DOM主要包含下列内容：

DOM文档是以层次结构组织的节点或信息片段的集合。这个层次结构允许开发人员从树中导航寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。

DOM解析过程（下图）：

利用JAXP把xml文档的内容解析到一个个的Java对象中，只需几行代码就能做到这一点。首先，我们需要建立一个解析器工厂，以利用这个工厂来获得一个具体的解析器对象：

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

我们在这里使用DocumentBuilderFacotry的目的是为了创建与具体解析器无关的程序，当DocumentBuilderFactory类的静态方法newInstance()被调用时，它根据一个系统变量来决定具体使用哪一个解析器。又因为所有的解析器都服从于JAXP所定义的接口，所以无论具体使用哪一个解析器，代码都是一样的。所以当在不同的解析器之间进行切换时，只需要更改系统变量的值，而不用更改任何代码。这就是工厂所带来的好处。这个工厂模式的具体实现，可以参看下面的类图

DocumentBuilder db = dbf.newDocumentBuilder();

当获得一个工厂对象后，使用它的静态方法newDocumentBuilder()方法可以获得一个DocumentBuilder对象，这个对象代表了具体的DOM解析器。但具体是哪一种解析器，微软的或者IBM的，对于程序而言并不重要。然后，我们就可以利用这个解析器来对XML文档进行解析了：

Document doc = db.parse("d:/xml/message.xml");

DocumentBuilder的parse()方法接受一个XML文档名作为输入参数，返回一个Document对象，这个Document对象就代表了一个XML文档的树模型。以后所有的对XML文档的操作，都与解析器无关，直接在这个Document对象上进行操作就可以了。而具体对Document操作的方法，就是由DOM所定义。

使用Document对象的getElementsByTagName()方法，我们可以得到一个NodeList对象，一个Node对象代表了一个XML文档中的一个标签元素，而NodeList对象，所代表的是一个Node对象的列表：

NodeList nl = doc.getElementsByTagName("message");

我们通过这样一条语句所得到的是XML文档中所有标签对应的Node对象的一个列表。然后，我们可以使用NodeList对象的item()方法来得到列表中的每一个Node对象：

Node my_node = nl.item(0);

当一个Node对象被建立之后，保存在XML文档中的数据就被提取出来并封装在这个Node中了。在这个例子中，要提取Message标签内的内容，我们通常会使用Node对象的getNodeValue()方法：

String message = my_node.getFirstChild().getNodeValue();

请注意，这里还使用了一个getFirstChild()方法来获得message下面的第一个子Node对象。虽然在message标签下面除了文本外并没有其它子标签或者属性，但是我们坚持在这里使用getFirseChild()方法，这主要和W3C对DOM的定义有关。W3C把标签内的文本部分也定义成一个Node，所以先要得到代表文本的那个Node，我们才能够使用getNodeValue()来获取文本的内容。

DOM对象

DOM的基本对象有5个：Document，Node，NodeList，Element和Attr。下图表示了基本对象间的关系

Document对象代表了整个XML的文档，所有其它的Node，都以一定的顺序包含在Document对象之内，排列成一个树形的结构，程序员可以通过遍历这颗树来得到XML文档的所有的内容，这也是对XML文档操作的起点。我们总是先通过解析XML源文件而得到一个Document对象，然后再来执行后续的操作。此外，Document还包含了创建其它节点的方法，比如createAttribute()用来创建一个Attr对象。它所包含的主要的方法有： createAttribute(String)：用给定的属性名创建一个Attr对象，并可在其后使用setAttributeNode方法来放置在某一个Element对象上面。createElement(String)：用给定的标签名创建一个Element对象，代表XML文档中的一个标签，然后就可以在这个Element对象上添加属性或进行其它的操作。

createTextNode(String)：用给定的字符串创建一个Text对象，Text对象代表了标签或者属性中所包含的纯文本字符串。如果在一个标签内没有其它的标签，那么标签内的文本所代表的Text对象是这个Element对象的唯一子对象。

getElementsByTagName(String)：返回一个NodeList对象，它包含了所有给定标签名字的标签。

getDocumentElement()：返回一个代表这个DOM树的根节点的Element对象，也就是代表XML文档根元素的那个对象。

Node对象是DOM结构中最为基本的对象，代表了文档树中的一个抽象的节点。在实际使用的时候，很少会真正的用到Node这个对象，而是用到诸如Element、Attr、Text等Node对象的子对象来操作文档。Node对象为这些对象提供了一个抽象的、公共的根。虽然在Node对象中定义了对其子节点进行存取的方法，但是有一些Node子对象，比如Text对象，它并不存在子节点。Node对象所包含的主要的方法有：

appendChild(org.w3c.dom.Node)：为这个节点添加一个子节点，并放在所有子节点的最后，如果这个子节点已经存在，则先把它删掉再添加进去。

getFirstChild()：如果节点存在子节点，则返回第一个子节点，对等的，还有getLastChild()方法返回最后一个子节点。

getNextSibling()：返回在DOM树中这个节点的下一个兄弟节点，对等的，还有getPreviousSibling()方法返回其前一个兄弟节点。

getNodeName()：根据节点的类型返回节点的名称。

getNodeType()：返回节点的类型。

getNodeValue()：返回节点的值。

hasChildNodes()：判断是不是存在有子节点。

hasAttributes()：判断这个节点是否存在有属性。

getOwnerDocument()：返回节点所处的Document对象。

insertBefore(org.w3c.dom.Node new，org.w3c.dom.Node ref)：在给定的一个子对象前再插入一个子对象。

removeChild(org.w3c.dom.Node)：删除给定的子节点对象。

replaceChild(org.w3c.dom.Node new，org.w3c.dom.Nodeold)：用一个新的Node对象代替给定的子节点对象。

NodeList对象，代表了一个包含一个或者多个Node的列表。可以简单的把它看成一个Node的数组，我们可以通过方法来获得列表中的元素：

getLength()：返回列表的长度。

item(int)：返回指定位置的Node对象。

Element对象代表的是XML文档中的标签元素，继承于Node，亦是Node的最主要的子对象。在标签中可以包含有属性，因而Element对象中有存取其属性的方法，而任何Node中定义的方法，也可以用在Element对象上面。

getElementsByTagName(String)：返回一个NodeList对象，它包含了在这个标签中其下的子孙节点中具有给定标签名字的标签。

getTagName()：返回一个代表这个标签名字的字符串。getAttribute(String)：返回标签中给定属性名称的属性的值。在这儿需要主要的是，应为XML文档中允许有实体属性出现，而这个方法对这些实体属性并不适用。这时候需要用到getAttributeNodes()方法来得到一个Attr对象来进行进一步的操作。

getAttributeNode(String)：返回一个代表给定属性名称的Attr对象。Attr对象代表了某个标签中的属性。Attr继承于Node，但是因为Attr实际上是包含在Element中的，它并不能被看作是Element的子对象，因而在DOM中Attr并不是DOM树的一部分，所以Node中的getparentNode()，getpreviousSibling()和getnextSibling()返回的都将是null。也就是说，Attr其实是被看作包含它的Element对象的一部分，它并不作为DOM树中单独的一个节点出现。这一点在使用的时候要同其它的Node子对象相区别。

请看下面例子：（message.xml）

sohu

http://www.sohu.com

zhangzhaoyang

2

1

2004

zhangzhaoyang's website

Java

http://java.sun.com

Sun Microsystems

3

1

2001

Sun Microsystem's website.

microsoft

http://www.microsoft.com

bill gates

4

1

2000

bill's website

DOM解析的例子：

下面代码使用DOM解析XML文件

package com.app;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

public class DOMXMLReader {

public static void main(String args[]) {

try {

DocumentBuilderFactory factory = DocumentBuilderFactory

.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();

Document doc = builder.parse("url.xml");

doc.normalize();

NodeList links = doc.getElementsByTagName("link");

for (int i = 0; i < links.getLength(); i++) {

Element link = (Element) links.item(i);

System.out.print("Content: ");

System.out.println(link.getElementsByTagName("text").item(0)

.getFirstChild().getNodeValue());

System.out.print("URL: ");

System.out.println(link.getElementsByTagName("url").item(0)

.getFirstChild().getNodeValue());

System.out.print("Author: ");

System.out.println(link.getElementsByTagName("author").item(0)

.getFirstChild().getNodeValue());

System.out.print("Date: ");

Element linkdate = (Element) link.getElementsByTagName("date")

.item(0);

String day = linkdate.getElementsByTagName("day").item(0)

.getFirstChild().getNodeValue();

String month = linkdate.getElementsByTagName("month").item(0)

.getFirstChild().getNodeValue();

String year = linkdate.getElementsByTagName("year").item(0)

.getFirstChild().getNodeValue();

System.out.println(day + "-" + month + "-" + year);

System.out.print("Description: ");

System.out.println(link.getElementsByTagName("description")

.item(0).getFirstChild().getNodeValue());

System.out.println();

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

下面代码修改XML文件：

package com.app;

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.Text;

public class DOMXMLWriter {

public static void main(String args[]) {

try {

DocumentBuilderFactory factory = DocumentBuilderFactory

.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();

Document doc = builder.parse("url.xml");

doc.normalize();

// ---取得变量----

String text = "itjob";

String url = "www.5itjob.com";

String author = "xsw";

String discription = "a good website for it job!";

// -------------

Text textseg;

Element link = doc.createElement("link");

Element linktext = doc.createElement("text");

textseg = doc.createTextNode(text);

linktext.appendChild(textseg);

link.appendChild(linktext);

Element linkurl = doc.createElement("url");

textseg = doc.createTextNode(url);

linkurl.appendChild(textseg);

link.appendChild(linkurl);

Element linkauthor = doc.createElement("author");

textseg = doc.createTextNode(author);

linkauthor.appendChild(textseg);

link.appendChild(linkauthor);

java.util.Calendar rightNow = java.util.Calendar.getInstance();

String day = Integer.toString(rightNow

.get(java.util.Calendar.DAY_OF_MONTH));

String month = Integer.toString(rightNow

.get(java.util.Calendar.MONTH));

String year = Integer.toString(rightNow

.get(java.util.Calendar.YEAR));

Element linkdate = doc.createElement("date");

Element linkdateday = doc.createElement("day");

textseg = doc.createTextNode(day);

linkdateday.appendChild(textseg);

Element linkdatemonth = doc.createElement("month");

textseg = doc.createTextNode(month);

linkdatemonth.appendChild(textseg);

Element linkdateyear = doc.createElement("year");

textseg = doc.createTextNode(year);

linkdateyear.appendChild(textseg);

linkdate.appendChild(linkdateday);

linkdate.appendChild(linkdatemonth);

linkdate.appendChild(linkdateyear);

link.appendChild(linkdate);

Element linkdiscription = doc.createElement("description");

textseg = doc.createTextNode(discription);

linkdiscription.appendChild(textseg);

link.appendChild(linkdiscription);

doc.getDocumentElement().appendChild(link);

TransformerFactory tFactory = TransformerFactory.newInstance();

Transformer transformer = tFactory.newTransformer();

DOMSource source = new DOMSource(doc);

StreamResult result = new StreamResult(new java.io.File("url.xml"));

transformer.transform(source, result);

System.out.println("write complete!");

} catch (Exception e) {

e.printStackTrace();

}

}

}

SAX解析实例

//以下代码统计url.xml文件中每个标签出现的次数

package com.app;

import java.io.File;

import java.util.Enumeration;

import java.util.Hashtable;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

public class TagCounter extends DefaultHandler {

// Hashtable用来记录tag出现的次数

private Hashtable tags;

public void startDocument() throws SAXException {

tags = new Hashtable();

}

// 解析完成后的工作

public void endDocument() throws SAXException {

Enumeration e = tags.keys();

while (e.hasMoreElements()) {

String tag = (String) e.nextElement();

int count = ((Integer) tags.get(tag)).intValue();

System.out.println("Tag <" + tag + "> occurs " + count + " times");

}

}

// 对每一个开始元属进行处理

public void startElement(String namespaceURI, String localName,

String rawName, Attributes atts) throws SAXException {

String key = rawName;

Object value = tags.get(key);

if (value == null) {

// 如果是新标签，把它添加在Hastable中

tags.put(key, new Integer(1));

} else {

// 如果以前碰到过，得到其计数值，并加1

int count = ((Integer) value).intValue();

count++;

tags.put(key, new Integer(count));

}

}

static public void main(String[] args) {

String filename = null;

filename = "url.xml";

SAXParserFactory spf = SAXParserFactory.newInstance();

SAXParser saxParser = null;

try {

// 创建解析器SAXParser对象

saxParser = spf.newSAXParser();

saxParser.parse(new File(filename), new TagCounter());

} catch (Exception ex) {

ex.printStackTrace();

}

}

}

//以下程序解析url.xml

package com.app;

import java.io.File;

import java.io.IOException;

import java.util.Stack;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

public class SAXXMLReader extends DefaultHandler {

Stack tags = new Stack();

// 用于保存解析出来的信息

String text = null;

String url = null;

String author = null;

String description = null;

String day = null;

String year = null;

String month = null;

public void endDocument() throws SAXException {

System.out.println("------解析结束--------");

}

public void startDocument() throws SAXException {

System.out.println("------解析开始--------");

}

public void startElement(String p0, String p1, String p2, Attributes p3)

throws SAXException {

tags.push(p2);

}

public void endElement(String p0, String p1, String p2) throws SAXException {

tags.pop();

if (p2.equals("link"))

parser();

}

public void characters(char[] p0, int p1, int p2) throws SAXException {

// 察看栈顶元素，根据元素名称给对应的变量赋值

String tag = (String) tags.peek();

if (tag.equals("text"))

text = new String(p0, p1, p2);

else if (tag.equals("url"))

url = new String(p0, p1, p2);

else if (tag.equals("author"))

author = new String(p0, p1, p2);

else if (tag.equals("day"))

day = new String(p0, p1, p2);

else if (tag.equals("month"))

month = new String(p0, p1, p2);

else if (tag.equals("year"))

year = new String(p0, p1, p2);

else if (tag.equals("description"))

description = new String(p0, p1, p2);

}

private void parser() {

System.out.print("Content: ");

System.out.println(text);

System.out.print("URL: ");

System.out.println(url);

System.out.print("Author: ");

System.out.println(author);

System.out.print("Date: ");

System.out.println(day + "-" + month + "-" + year);

System.out.print("Description: ");

System.out.println(description);

System.out.println();

}

static public void main(String[] args) {

String filename = "url.xml";

SAXParserFactory spf = SAXParserFactory.newInstance();

SAXParser saxParser = null;

try {

saxParser = spf.newSAXParser();

saxParser.parse(new File(filename), new SAXXMLReader());

} catch (Exception ex) {

ex.printStackTrace();

}

}

}

DOM4J解析实例

《D:\\wuhan\\test.xml》

A1234A1234aaaaaaaaaa深圳罗湖

　　 B1234

　　深圳南山

　　 B1234xxxx

　　深圳xxxxx

Java 代码

package com.xml;

import java.io.*;

import java.util.*;

import org.dom4j.*;

import org.dom4j.io.*;

public class Dom4j {

public static void main(String arge[]) {

long lasting = System.currentTimeMillis();

try {

File f = new File("D:\\wuhan\\test.xml");

SAXReader reader = new SAXReader();

Document doc = reader.read(f);

Element root = doc.getRootElement();

Element foo;

for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {

foo = (Element) i.next();

System.out.print("车牌号码:" + foo.elementText("NO"));

System.out.println("车主地址:" + foo.elementText("ADDR"));

}

} catch (Exception e) {

e.printStackTrace();

}

}

}

JDOM解析实例

package com.xml;

import java.io.*;

import java.util.*;

import org.jdom.Document;

import org.jdom.Element;

import org.jdom.input.SAXBuilder;

public class JDom {

public static void main(String arge[]) {

long lasting = System.currentTimeMillis();

try {

SAXBuilder builder = new SAXBuilder();

Document doc = builder.build(new File("D:\\wuhan\\test.xml"));

Element foo = doc.getRootElement();

List allChildren = foo.getChildren();

for(int i = 0;i < allChildren.size();i++) {

System.out.print("车牌号码:" + ((Element)allChildren.get(i)).getChild("NO").getText());

System.out.println("车主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText());

}

} catch (Exception e) {

e.printStackTrace();

}

}}

JAVA操纵XML 实例讲解

JDBC开发中需要连接到不同的数据库，利用XML文件保存不同类型数据库的连接参数，并使用统一的程序解析XML以取得相应的连接参数。

<>

Oracle

oracle.jdbc.driver.OracleDriver

jdbc:oracle:thin:@localhost:1521:goudan

pubuser1

11111111

mysql

org.git.mm.mysql.Driver

jdbc:mysql://localhost:3306/BookDB

pubuser2

11111111

sqlserver com.microsoft.jdbc.sqlserver.SQLServerDriver

jdbc:Microsoft:sqlserver://127.0.0.1:1433

pubuser3

11111111

<>

package test.xml;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

public class DBTest {

public DBTest(String type) {

// this.type = type ;

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

try {

DocumentBuilder db = dbf.newDocumentBuilder();// 创建解析器

Document doc = db.parse("Db.xml");// 解析地址

NodeList n1 = doc.getElementsByTagName("DB");// 得到含有DB标签的一个列表

for (int i = 0; i < n1.getLength(); i++) {

Element myNode = (Element) n1.item(i);// 通过item方法获得每个对象

if (myNode.getElementsByTagName("type").item(0).getFirstChild()

.getNodeValue().equals(type)) {

String driver = myNode.getElementsByTagName("driver").item(

0).getFirstChild().getNodeValue();

String url = myNode.getElementsByTagName("url").item(0)

.getFirstChild().getNodeValue();

String user = myNode.getElementsByTagName("user").item(0)

.getFirstChild().getNodeValue();

String password = myNode.getElementsByTagName("password")

.item(0).getFirstChild().getNodeValue();

System.out.println(driver + " " + url + " " + user + " "

+ password);

break;

}

}

} catch (ParserConfigurationException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

public static void main(String[] rag) {

DBTest dbt1 = new DBTest("Oracle");

DBTest dbt2 = new DBTest("mysql");

DBTest dbt3 = new DBTest("sqlserver");

}

}

通过JAVA写数据到XML里面

<>

andy

45

13632940025

m

<>

package test.xml;

import java.io.File;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.TransformerException;

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.NodeList;

import org.w3c.dom.Text;

import org.xml.sax.SAXException;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.Statement;

import java.util.ArrayList;

public class WriteXmlTest {

public static void main(String[] args) {

try {

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

DocumentBuilder db = dbf.newDocumentBuilder();

Document dc = db.parse("persons.xml");

fang(dc);

} catch (ParserConfigurationException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

public static void fang(Document doc) {

Element eleroots = doc.getDocumentElement();

Element eleroot = doc.createElement("person");// 创建gen元素

eleroots.appendChild(eleroot);

Element elename = doc.createElement("name");

Text text1 = doc.createTextNode("andy");

elename.appendChild(text1);

eleroot.appendChild(elename);

Element eleage = doc.createElement("age");

Text text2 = doc.createTextNode("45");

eleage.appendChild(text2);

eleroot.appendChild(eleage);

Element eletel = doc.createElement("tel");

Text text3 = doc.createTextNode("13632940025");

eletel.appendChild(text3);

eleroot.appendChild(eletel);

Element elesex = doc.createElement("sex");

Text text4 = doc.createTextNode("m");

elesex.appendChild(text4);

eleroot.appendChild(elesex);

TransformerFactory tff = TransformerFactory.newInstance();

Transformer tf = null;

try {

tf = tff.newTransformer();

} catch (TransformerConfigurationException e) {

e.printStackTrace();

}

DOMSource ds = new DOMSource(doc);

StreamResult sr = new StreamResult(new File("persons.xml"));

try {

tf.transform(ds, sr);

} catch (TransformerException e) {

e.printStackTrace();

}

}

}

内容总结

? 知道解析器的作用

? 理解DOM，SAX解析XML原理

? 了解DOM，SAX解析的优缺点

? 使用DOM，SAX解析XML文档

? 使用DOM4J解析XML文档

? 使用JDOM 解析XML文档

? 能够使用各种解析方式来处理应用程序

? 能够写出XML方式的连接池技术

独立实践

? 写一个XML文档：包括JDBC连接所需要的驱动，url，用户名，密码等

? 使用SAX或者DOM解析上面的XML建立数据库的连接

? 使用DOM4J解析一个判断用户的登陆的操作，用户信息存在XML文档里

? 使用JDOM解析上一章的一个关于学生课程信息的XML文档，并在控制台显示数据

? 使用任何一种解析方式对学生课程信息的XML文档进行写一行增加课程信息的数据。

第二十三章：HTML基础

学习目标

? HTML文档是由HTML元素组成的文本文件，是预定义的正在使用的HTML标签

? HTML中最重要的标签是定义标题元素，段落和换行的标签

? 掌握格式化元素比如加粗和倾斜文本

? 了解HTML中的特殊实体

? 掌握超链接、锚的用法

? 掌握表格的画法以及如何添加表的标题、表头等

? 掌握无序、有序及自定义列表

? 了解并掌握图像标签、alt属性、src属性，以及如何利用图像创建超链接

? 掌握如何在标签中设置网页背景

知识要点

HTML元素

HTML文档是由HTML元素组成的文本文件。

HTML元素是预定义的正在使用的HTML标签。

________________________________________HTML标签

HTML标签用来组成HTML元素。

HTML标签两端有两个包括字符：“<”和“>”,这两个包括字符被称为角括号。

HTML标签通常成对出现，比如和。一对标签的前面一个是开始标签，第二个是结束标签,在开始和结束标签之间的文本是元素内容。

HTML标签是大小写无关的，跟表示的意思是一样的。________________________________________

回忆一下上一页的HTML例子：

Title of page

This is my first homepage.

This text is bold

下面是一个HTML元素：

This text is bold

此HTML元素以开始标签起始，内容是：This text is bold，以结束标签中止。标签的目的是定义一个需要被显示成粗体的HTML元素。

下面也是一个HTML元素：

This is my first homepage.

This text is bold

此HTML标签以开始标签起始，终止于结束标签。标签的目的是定义一个HTML元素，使其包含HTML文档的主体。________________________________________为什么使用小写标签？

HTML标签是大小写无关的：跟含义相同。当你上网的时候，你会注意到多数教程在示例中使用大写的HTML标签，我们总是使用小写标签。为什么？

假如你想投入到下一代HTML中，你应该开始使用小写标签。W3C在他们的HTML4建议中提倡使用小写标签，XHTML（下一代HTML）也需要小写标签。________________________________________

标签属性

标签可以拥有属性。属性能够为页面上的HTML元素提供附加信息。

标签定义了HTML页面的主体元素。使用一个附加的bgcolor属性，你可以告诉浏览器：你页面的背景色是红色的，就像这样：

标签
定义了一个HTML表格。使用一个附加的border属性，你可以告诉浏览器：这个表格是没有边框的，代码是：

属性通常由属性名和值成对出现，就像这样：name="value"。属性通常是附加给HTML元素的开始标签的。
引号样式
属性值应该被包含在引号中。双引号是最常用的，但是单引号也可以使用。
在很少情况下，比如说属性值本身包含引号，使用单引号就很必要了。
比如：name='John "ShotGun" Nelson'。
注意：中文引号跟英文引号是不一样的。上面所指的引号都是英文状态下的引号。
HTML基本标签
HTML中最重要的标签是定义标题元素，段落和换行的标签。
学习HTML的最好方法是编辑运行示例代码。
请自己尝试一下这个例子
一个非常简单的HTML文档：
The content of the body element is displayed in your browser.
这个例子是一个非常简单的HTML文档，拥有很少的几个HTML标签。它说明了一个主体元素中的文本是如何在浏览器中显示的。
简单的段落：
This is a paragraph.
This is a paragraph.
This is a paragraph.
Paragraph elements are defined by the p tag.
这个例子说明了段落元素中的文本是如何在浏览器中显示的。
标题元素
标题元素由标签
到
定义。
定义了最大的标题元素，
定义了最小的。

This is a heading

This is a heading

This is a heading

This is a heading

This is a heading

This is a heading

HTML自动在一个标题元素前后各添加一个空行。

段落

段落是用
标签定义的。

This is another paragraph

HTML自动在一个段落前后各添加一个空行。

换行

当需要结束一行，并且不想开始新段落时，使用
标签。
标签不管放在什么位置，都能够强制换行。

This

is a para

graph with line breaks

标签是一个空标签，它没有结束标记。

注释

注释标签用来在HTML源文件中插入注释。注释会被浏览器忽略。你可以使用注释来解释你的代码，这可以在你以后编辑代码的时候帮助你。

注意：你需要在左括号“<”后面跟一个感叹号，右括号不用。

技巧

当你写下HTML文本的时候，你不能确知在另外一个浏览器中，这些文本将被如何显示。有人用着大的显示器，有的人用的小一些。每次用户调整窗口大小的时候，文本都将被重新格式化。不要想在编辑器中写一些空行和空格来协助排版。

HTML将截掉你文本中的多余空格。不管多少个空格，处理起来只当一个。一点附加信息：在HTML里面，一个空行也只被当作一个空格来处理。

使用空段落
来插入空白行是一个坏习惯，请使用
标签来替代。（但是不要用
标签来创建列表，我们后面会专门学习HTML列表的。）

你也许注意到了段落可以不写结束标记
。别依赖它，HTML的下一个版本将不准你漏掉任何一个结束标签。

HTML自动在某些元素前后增加额外的空行，就像在段落和标题元素的前后一样。

我们使用了水平线（
标签）来分隔我们教程的章节。

例如：

多个段落

This paragraph contains a lot of lines in the source code, but the

browser ignores it.

This paragraph contains a lot of spaces in the source code, but the

browser ignores it.

The number of lines in a paragraph depends on the size of your

browser window. If you resize the browser window, the number of lines

in this paragraph will change.

这个例子说明了段落的一些默认行为。

换行

To break

lines

in a

paragraph,

use the br tag.

这个例子说明了在HTML文档中换行的使用。

格式

My Bonnie lies over the ocean. My Bonnie lies over the sea. My Bonnie

lies over the ocean. Oh, bring back my Bonnie to me.

Note that your browser simply ignores your formatting!

这个例子说明了HTML显示格式的一些问题。

标题元素

This is heading 1

This is heading 2

This is heading 3

This is heading 4

This is heading 5

This is heading 6

Use heading tags only for headings. Don't use them just to make

something bold. Use other tags for that.

这个例子说明了在HTML中显示标题元素的标签。

居中的标题元素

This is heading 1

The heading above is aligned to the center of this page. The heading

above is aligned to the center of this page. The heading above is

aligned to the center of this page.

这个例子显示了一个居中的标题元素。

水平线

The hr tag defines a horizontal rule:

This is a paragraph

This is a paragraph

This is a paragraph

这个例子说明了如何插入水平线。

隐藏的注释

This is a regular paragraph

这个例子说明了在HTML文档中如何插入隐藏的注释。

背景色

Look: Colored Background!

这个例子说明了如何给页面设置背景色。

HTML格式

HTML定义了很多元素用来格式化输出，比如加粗和倾斜文本。

例如：

格式化文字

This text is bold

This text is strong

This text is big

This text is emphasized

This text is italic

This text is small

This text contains

_subscript

This text contains

superscript

这个例子说明了在HTML里面可以怎样格式化文本。

预格式化文本

This is

preformatted text.

It preserves both spaces

and line breaks.

The pre tag is good for displaying computer code:

for i = 1 to 10

print i

next i

这个例子说明了可以怎样用pre标签来控制换行和空格。

“计算机输出”标签

Computer code

Keyboard input

Teletype text

Sample text

Computer variable

Note: These tags are often used to display

computer/programming code.

这个例子说明了“计算机输出”标签在显示上的不同。

地址

Donald Duck

BOX 555

Disneyland

USA

这个例子说明了如何用HTML书写一个地址。

缩写和首字母缩略法

UN

WWW

The title attribute is used to show the spelled-out version when

holding the mouse pointer over the acronym or abbreviation.

This only works for the acronym element in IE 5.

This works for both the abbr and acronym element in Netscape 6.2.

这个例子说明了如何处理缩写和首字母缩略。

文字方向

If your browser supports bi-directional override (bdo), the next line

will be written from the right to the left (rtl):

Here is some Hebrew text

这个例子说明了如何改变文字方向。

块引用

Here comes a long quotation:

This is a long quotation. This is a long quotation. This is a long

quotation. This is a long quotation. This is a long quotation.

Here comes a short quotation:

This is a short quotation

With the block quote element, the browser inserts line breaks and

margins, but the q element does not render as anything special.

这个例子说明了如何处理大段引用和小块引用。

删除和插入文字

a dozen is

twenty

twelve

pieces

Most browsers will overstrike deleted text and underline inserted

text.

Some older browsers will display deleted or inserted text as plain

text.

这个例子说明了如何标记被删除或者插入的文本。

查看HTML源文件

在浏览器菜单中选择查看——源文件，将弹出一个窗口，这个页面的HTML代码就在其中。

HTML实体

有些字符，比如说“<”字符，在HTML中有特殊的含义，因此不能在文本中使用。

想要在HTML中显示一个小于号“<”，需要用到字符实体。

字符实体

在HTML中，有些字符拥有特殊含义，比如小于号“<”定义为一个HTML标签的开始。假如我们想要浏览器显示这些字符的话，必须在HTML代码中插入字符实体。

一个字符实体拥有三个部分：一个and符号（&），一个实体名或者一个实体号，最后是一个分号（;）

想要在HTML文档中显示一个小于号，我们必须这样写：<或者<

使用名字相对于使用数字的优点是容易记忆，缺点是并非所有的浏览器都支持最新的实体名，但是几乎所有的浏览器都能很好地支持实体号。

注意：实体名是大小写敏感的。

下面这个例子能够让你针对HTML实体实践一下。

This is a character entity: {

不可拆分的空格

在HTML中，最常见的字符实体就是不可拆分空格。

通常，HTML会合并你文档中的空格。假如在你的HTML文本中连续写了10个空格，其中9个会被去掉。想要在HTML中插入空格，可以使用实体：

常用的字符实体

显示结果描述实体名实体号

不可拆分的空格

< 小于 < <

> 大于 > >

& and符号 & &

" 引号 " "

' 单引号 '

其它字符实体

显示结果描述实体名实体号

￠分 ¢ ¢

￡英镑 £ £

￥人民币元 ¥ ¥

§ 章节 § §

? 版权 © ©

? 注册 ® ®

× 乘号 × ×

÷ 除号 ÷ ÷

HTML链接

HTML使用超级链接来连接到网络上的其他页面。

例如

创建链接

This text is a link to a page on this Web

site.

This text is a link to a

page on the World Wide Web.

这个例子说明了在HTML文档中如何创建链接

图片作为链接

You can also use an image as a link:

这个例子说明了在HTML文档中如何用图片作为链接。

锚标签和href属性

HTML使用锚标签（）来创建一个连接到其他文件的链接。锚可以指向网络上的任何资源：HTML页面，图像，声音，影片等等。

创建一个锚的语法：

Text to be displayed

锚可以指向网络上的任何资源：HTML页面，图像，声音，影片等等。

标签被用来创建一个链接指向的锚，href属性用来指定连接到的地址，在锚的起始标签和结束标签中间的部分将被显示为超级链接。

这个锚定义了一个到W3Schools的链接：

Visit W3Schools!

target属性

使用target属性，你可以定义从什么地方打开链接地址。

下面这段代码打开一个新的浏览器窗口来打开链接：

Visit W3Schools!

锚标签和name属性

name属性用来创建一个命名的锚。使用命名锚以后，可以让链接直接跳转到一个页面的某一章节，而不用用户打开那一页，再从上到下慢慢找。

下面是命名锚的语法：

Text to be displayed

你可以为锚随意指定名字，只要你愿意。下面这行代码定义了一个命名锚：Useful Tips Section

你应该注意到了：命名锚的显示方式并没有什么与众不同的。

想要直接链接到“tips”章节的话，在URL地址的后面加一个“#”和这个锚的名字，就像这样：

Jump to the Useful Tips Section

一个链接到本页面中某章节的命名锚是这样写的：Jump to the Useful Tips Section

技巧

尽量在子目录路径后面加一个左斜杠。假如你像下面这样写：href="http://www.w3schools.com/html"，将会产生向服务器产生两个HTTP请求，因为服务器会在后面追加一个左斜杠，产生一个新的请求，就像这样：href="http://www.w3schools.com/html/"。

命名锚通常用来在大型文档的开头创建章节表。这个页面的每个章节被加上一个命名锚，到这些锚的链接被放在页面的顶端。

如果浏览器无法找到指定的命名锚，它将转到这个页面的顶部，而不显示任何错误提示。

例如：

在新浏览器窗口中打开链接

Last Page

If you set the target attribute of a link to "_blank", the link will

open in a new window.

这个例子说明了怎样用打开新窗口的方式来链接到其他页面，这样，访问者不用离开你的页面。

链接到本页面的某个位置

See also Chapter 4.

Chapter 1

This chapter explains ba bla bla

Chapter 2

This chapter explains ba bla bla

Chapter 3

This chapter explains ba bla bla

Chapter 4

This chapter explains ba bla bla

Chapter 5

This chapter explains ba bla bla

Chapter 6

This chapter explains ba bla bla

Chapter 7

This chapter explains ba bla bla

Chapter 8

This chapter explains ba bla bla

Chapter 9

This chapter explains ba bla bla

Chapter 10

This chapter explains ba bla bla

Chapter 11

This chapter explains ba bla bla

Chapter 12

This chapter explains ba bla bla

Chapter 13

This chapter explains ba bla bla

Chapter 14

This chapter explains ba bla bla

Chapter 15

This chapter explains ba bla bla

Chapter 16

This chapter explains ba bla bla

Chapter 17

This chapter explains ba bla bla

这个例子说明了如何跳转到一个文档的某部分。

跳出框架

Locked in a frame?

Click here!

这个例子说明了假如你的页面在框架中，如何跳出框架。

创建一个邮件链接

This is a mail link:

Send Mail

Note: Spaces between words should be replaced by %20 to

ensure that the browser will display your text properly.

这个例子说明了如何链接到一个邮件信息（只有安装了邮件程序才有效）。

创建一个邮件链接2

This is another mailto link:

href="mailto:[email protected][email protected][email protected]&subject=Summer%20Party&body=You%20are%20invited%20to%20a%20big%20summer%20party!">Send

mail!

Note: Spaces between words should be replaced by %20 to

ensure that the browser will display your text properly.

这个例子显示了一个完成度更高的邮件链接。

HTML表格

使用HTML可以创建表格。

例如：

Each table starts with a table tag. Each table row starts with a tr

tag. Each table data starts with a td tag.

One column:

100

One row and three columns:

100

200

300

Two rows and three columns:

100

200

300

400

500

600

这个例子说明了如何在HTML页面中创建表格。

表格边框

With a normal border:

First

Row

Second

Row

With a thick border:

First

Row

Second

Row

With a very thick border:

First

Row

Second

Row

这个例子显示了不同的表格边框。

表格

表格是用
标签定义的。表格被划分为行（使用标签），每行又被划分为数据单元格（使用，，标签，因为浏览器对它们的支持不好。希望这个在XHTML的未来版本中得到改变。
________________________________________
例如：
没有边框的表格

This table has no borders:

标签）。td表示“表格数据”（Table Data），即数据单元格的内容。数据单元格可以包含文本，图像，列表，段落，表单，水平线，表格等等。

row 1, cell 1

row 1, cell 2

row 2, cell 1

row 2, cell 2

在浏览器中显示如下：

row 1, cell 1 row 1, cell 2

row 2, cell 1 row 2, cell 2

表格和border属性

如果不指定border属性，表格将不显示边框。有时候这很有用，但是多数时候我们希望显示边框。

想要显示一个有边框的表格，需要使用border属性。

Row 1, cell 1

Row 1, cell 2

表格头

表格头使用
标签指定。

Heading

Another Heading

row 1, cell 1

row 1, cell 2

row 2, cell 1

row 2, cell 2

在浏览器中显示如下：

Heading Another Heading

row 1, cell 1 row 1, cell 2

row 2, cell 1 row 2, cell 2

表格中的空单元格

在多数浏览器中，没有内容的单元格显示得不太好。

row 1, cell 1

row 1, cell 2

row 2, cell 1

在浏览器中显示如下：

row 1, cell 1 row 1, cell 2

row 2, cell 1

注意一下空单元格的边框没有显示出来。为了避免这个，可以在空单元格里加入不可分空格来占位，这样边框能正常显示。

row 1, cell 1

row 1, cell 2

row 2, cell 1

在浏览器中显示如下：

row 1, cell 1 row 1, cell 2

row 2, cell 1

技巧

通常很少使用

100

200

300

400

500

600

And this table has no borders:

100

200

300

400

500

600

这个例子显示了一个没有边框的表格。

表格头

Table headers:

Name

Telephone

Telephone

Bill Gates

555 77 854

555 77 855

Vertical headers:

First Name:

Bill Gates

Telephone:

555 77 854

Telephone:

555 77 855

这个例子说明了如何显示表格头。

空单元格

Some text

Some text

Some text

As you can see, one of the cells has no border. That is because it is

empty. Try to insert a space in the cell. Still it has no border.

The trick is to insert a no-breaking space in the cell.

No-breaking space is a character entity. If you don't know what a

character entity is, read the chapter about it.

The no-breaking space entity starts with an ampersand ("&"),then the

letters "nbsp", and ends with a semicolon (";")

这个例子说明了如何使用“ ”来支撑没有内容的单元格。

有标题的表格

This table has a caption,and a thick border:

My Caption

100

200

300

400

500

600

这个例子说明了如何创建一个有标题的表格。

单元格跨行（列）的表格

Cell that spans two columns:

Name

Telephone

Bill Gates

555 77 854

555 77 855

Cell that spans two rows:

First Name:

Bill Gates

Telephone:

555 77 854

555 77 855

这个例子显示了如何定义跨行或者跨列的单元格。

表格内的其他标签

This is a paragraph

This is another paragraph

This cell contains a table:

A

B

C

D

This cell contains a list

apples

bananas

pineapples

HELLO

这个例子说明了如何在元素中显示其他元素。

cellpadding属性

Without cellpadding:

First

Row

Second

Row

With cellpadding:

First

Row

Second

Row

这个例子说明了如何使用cellpadding属性在表格内容和边框之间留出更多空白。

cellspacing属性

Without cellspacing:

First

Row

Second

Row

With cellspacing:

First

Row

Second

Row

这个例子说明了如何使用cellspacing属性来增加单元格间距。

给表格增加背景色或者背景图像

A background color:

First

Row

Second

Row

A background image:

First

Row

Second

Row

这个例子说明了如何给表格增加背景。

给表格增加背景色或者背景图像

Cell backgrounds:

First

Row

Second

Row

这个例子说明了如何给一个或多个单元格增加背景。

给单元格内容设置对齐方式

Money spent on....

January

February

Clothes

$241.10

$50.20

Make-Up

$30.00

$44.45

Food

$730.40

$650.00

Sum

$1001.50

$744.65

这个例子说明了如何使用“align”属性来设置单元格的对齐方式，让表格好看一些。

frame属性

If you see no frames around the tables in these examples, your

browser is too old, or does not support it.

With frame="border":

First

Row

Second

Row

With frame="box":

First

Row

Second

Row

With frame="void":

First

Row

Second

Row

With frame="above":

First

Row

Second

Row

With frame="below":

First

Row

Second

Row

With frame="hsides":

First

Row

Second

Row

With frame="vsides":

First

Row

Second

Row

With frame="lhs":

First

Row

Second

Row

With frame="rhs":

First

Row

Second

Row

这个例子说明了如何使用“frame”属性来控制表格周围的边框。

HTML列表

HTML支持有序、无序和自定义列表。

例如：

一个无序列表

An Unordered List:

Coffee

Tea

Milk

这个例子显示了一个无序列表。

有序列表

An Ordered List:

Coffee

Tea

Milk

这个例子显示了一个有序列表。

无序列表

无序列表是一个项目的序列。各项目前加有标记（通常是黑色的实心小圆圈）。

无序列表以
标签开始。每个列表项目以
开始。

Coffee

Milk

在浏览器中显示如下：

? Coffee

? Milk

无序列表的项目中可以加入段落、换行、图像，链接，其他的列表等等。

有序列表

有序列表也是一个项目的序列。各项目前加有数字作标记。

有序列表以
标签开始。每个列表项目以
开始。

Coffee

Milk

在浏览器中显示如下：

1. Coffee

2. Milk

有序列表的项目中可以加入段落、换行、图像，链接，其他的列表等等。

自定义列表

自定义列表不是一个项目的序列，它是一系列条目和它们的解释。

有序列表以
标签开始，自定义列表条目以
开始，自定义列表的定义以
开始。

Coffee

Black hot drink

Milk

White cold drink

在浏览器中显示如下：

Coffee

Black hot drink

Milk

White cold drink

自定义列表的定义（标签
）中可以加入段落、换行、图像，链接，其他的列表等等。

例如：

有序列表的不同类型

Numbered list:

Apples

Bananas

Lemons

Oranges

Letters list:

Apples

Bananas

Lemons

Oranges

Lowercase letters list:

Apples

Bananas

Lemons

Oranges

Roman numbers list:

Apples

Bananas

Lemons

Oranges

Lowercase Roman numbers list:

Apples

Bananas

Lemons

Oranges

这个例子显示了有序列表的不同类型。

无序列表的不同类型

Disc bullets list:

Apples

Bananas

Lemons

Oranges

Circle bullets list:

Apples

Bananas

Lemons

Oranges

Square bullets list:

Apples

Bananas

Lemons

Oranges

这个例子显示了无序列表的不同类型。

嵌套列表

A nested List:

Coffee

Tea

Black tea

Green tea

Milk

这个例子说明了可以怎样嵌套列表。

嵌套列表2

A nested List:

Coffee

Tea

Black tea

Green tea

China

Africa

Milk

这个例子说明了如何创建一个更复杂化的嵌套列表。

自定义列表：

A Definition List:

Coffee

Black hot drink

Milk

White cold drink

这个例子说明了如何创建一个自定义列表。

HTML图像

使用HTML可以在文档中显示图像。

例如：

插入图像

An image:

A moving image:

Note that the syntax of inserting a moving image is no different from

that of a non-moving image.

这个例子说明了如何在网页中显示图像。

插入非本地图像

An image from W3Schools:

height="68">

这个例子说明了如何在网页中显示非本地图像。

Img标签和src属性

在HTML里面，图像是由标签定义的。

是空标签，意思是说，它只拥有属性，而没有结束标签。

想要在页面上显示一个图像，需要使用src属性。“src”表示“源”的意思。“src”属性的值是所要显示图像的URL。

插入图像的语法：

URL指向图像存储的地址。网站“www.w3schools.com”子目录“images”中的图像“boat.gif”的URL如下： “http://www.w3schools.com/images/boat.gif”。

当浏览器在文档中遇到img标签时，就放置一个图像。如果把img标签放在两个段落之间，就会先显示一个段落，然后是这个图像，最后是另外一个段落。

alt属性

alt属性用来给图像显示一个“交互文本”。alt属性的值是由用户定义的。

“alt”属性在浏览器装载图像失败的时候告诉用户所丢失的信息，此时，浏览器显示这个“交互文本”来代替图像。给页面上的图像都加上alt属性是一个好习惯，它有助于更好地显示信息，而且，对纯文本浏览器很有用。

技巧

如果一个HTML文档包含10个图像，那么为了正确显示这个页面，需要加载11个文件。加载图像是需要时间的，所以请谨慎使用图像。

例如：

背景图像

Look: A background image!

Both gif and jpg files can be used as HTML backgrounds.

If the image is smaller than the page, the image will repeat itself.

这个例子说明了在HTML页面中如何添加背景图像。

对齐图像

An image

in the text

An image

in the text

An image

in the text

Note that bottom alignment is the default alignment

An image

in the text

An image before the text

An image after the text

这个例子说明了在文字中如何对齐图像。

浮动图像

A paragraph with an image. The align attribute of the image is set to

"left". The image will float to the left of this text.

A paragraph with an image. The align attribute of the image is set to

"right". The image will float to the right of this text.

这个例子说明了如何让图像浮动在段落的旁边。

调整图像大小

You can make a picture larger or smaller changing the values in the

"height" and "width" attributes of the img tag.

这个例子说明了如何改变图像的大小。

图像的交互文本

Text-only browsers will only display the text in the "alt" attribute,

which is "Last Page".Note that if you hold the mouse pointer over the

image it will display the text.

这个例子说明了如何为图像创建交互文本。将鼠标放在图像上，将能够看到这个文本。

图像链接：

You can also use an image as a link:

这个例子说明了如何使用图像作为链接。

图像地图

Click on one of the planets to watch it closer:

usemap="#planetmap">

href="mercury.htm">

Note: We use both an

id and a

name attribute in the map tag because some versions of

Netscape don't understand the id attribute.

这个例子说明了如何创建带有可点击区域的图像地图。每个可点击区域是一个超级链接。

将图像转化为图像地图

Move the mouse over the image, and look at the status bar to see how

the coordinates change.

width="146" height="126">

这个例子说明了如何将图像转化为图像地图。将鼠标在图像上移动，状态栏将显示坐标。

HTML背景

好的背景能够让网站变得很美妙。

例如：

好的背景和文字颜色

This is a paragraph. This is a paragraph. This is a paragraph. This

is a paragraph. This is a paragraph.

This is another paragraph. This is another paragraph. This is another

paragraph. This is another paragraph.

一个背景色和文字颜色让页面文本更易读的例子。

差的背景和文字颜色

This is a paragraph. This is a paragraph. This is a paragraph. This

is a paragraph. This is a paragraph.

This is another paragraph. This is another paragraph. This is another

paragraph. This is another paragraph.

一个背景色和文字颜色让页面文本不便阅读的例子。

背景

标签有两个属性可以指定背景。背景可以是颜色，也可以是图像。

bgcolor

bgcolor属性将背景设置为颜色，它的值可以是一个十六进制数、RGB值或者一种颜色名称。

上面三条语句都可以把页面背景设置成黑色。

background

background属性将背景设置为图像，它的值是你所要使用图像的URL地址。如果这个图像的大小不及浏览器窗口，它将平铺占满窗口。

URL地址可以是相对地址（上面第一条语句），也可以是绝对地址（上面第二条语句）。

________________________________________注意：如果打算使用背景图像，应该牢记：

? 这个图像会使页面加载时间过长吗？小技巧：图像文件的容量尽量不要超过10K。

? 这个图像跟页面上其他图像协调吗？

? 这个图像跟页面上的文字颜色协调吗？

? 这个图像平铺了以后看起来还可以吗？

? 这个图像吸引了文字的注意力，喧宾夺主了吗？

________________________________________

技巧

标签的bgcolor、background和text属性在最新的HTML标准（HTML4和XHTML）中已被废弃。W3C在他们的推荐中已删除这些属性。在HTML的未来版本中，层叠样式表（CSS）将被用来定义HTML元素的布局和显示属性。

一般的网站很少使用背景图像。

最常用的背景颜色是黑色、白色和灰色。

例如：

好的背景图像

Image Background

Both gif and jpg files can be used as HTML backgrounds.

If the image is smaller than the page, the image will repeat itself.

一个背景图像和文字颜色让页面文本易于阅读的例子。

好的背景图像2

Image Background

Both gif and jpg files can be used as HTML backgrounds.

If the image is smaller than the page, the image will repeat itself.

另一个背景图像和文字颜色让页面文本易于阅读的例子。

差的背景图像

Image Background

Both gif and jpg files can be used as HTML backgrounds.

If the image is smaller than the page, the image will repeat itself.

一个背景图像和文字颜色让页面文本不便阅读的例子。

内容总结

? 掌握HTML中最重要的标签是定义标题元素，段落和换行的标签，格式化元素比如加粗和倾斜文本，了解HTML中的特殊实体

? 掌握超链接、锚的用法，表格的画法以及如何添加表的标题、表头等。无序、有序及自定义列表。以及如何在标签中设置网页背景。

? 了解并掌握图像标签、alt属性、src属性，以及如何利用图像创建超链接

独立实践

? 写一个自己简历的HTML文档。

? 写一个用表格显示本班学生的HTML文档。

? 通过点击简历的小头像，可以看到显示完整相片的HTML文档。

? 在上面三个HTML文档里用不同的背景图片

? 定义一个个人主页的HTML文档

第二十四章：HTML进阶

学习目标

? 掌握表单的创建方法、提交方式以及表单所包含的文档对象

? 掌握框架的创建方法、框架大小的调整以及如何在不同框架之间创建链接

? 掌握IFrame的使用，如何利用IFame引入其它页面，以及如何在IFrame和包含IFrame的页面之间通信

知识要点

HTML表单

HTML表单用来选择不同种类的用户输入。

例如：

文本框

First name:

Last name:

这个例子说明了在HTML页面中如何创建文本框。在文本框中，用户可以输入文本。

密码框

Username:

Password:

Note that when you type characters in a password field, the browser

displays asterisks or bullets instead of the characters.

这个例子说明了在HTML页面中如何创建密码框。

表单

表单是一个能够包含表单元素的区域。

表单元素是能够让用户在表单中输入信息的元素（比如文本框，密码框，下拉菜单，单选框，复选框等等）。

表单是用
元素定义的。

Input

最常用的表单标签是标签。Input的类型用type属性指定。最常用的input类型解释如下：

文本框

在表单中，文本框用来让用户输入字母、数字等等。

First name:

Last name:

________________________________________注意，表单本身并不可见。另外，在多数浏览器中，文本框的宽度默认是20个字符。________________________________________

单选按钮

当需要用户从有限个选项中选择一个时，使用单选按钮。

Male

Female

在浏览器中显示如下：

Male

Female

________________________________________注意，各选项中只能选取一个。________________________________________

复选框

当需要用户从有限个选项中选择一个或多个时，使用复选框。

I have a bike

I have a car

在浏览器中显示如下：

I have a bike

I have a car

表单的action属性和提交按钮

当用户点击提交按钮的时候，表单的内容会被提交到其他文件。表单的action属性定义了所要提交到的目的文件，该目的文件收到信息后通常进行相关的处理。

Username:

如果在上面这个文本框中输入一些字符，按下提交按钮以后，输入的字符将被提交到页面“action.asp”。

例如：

复选框

I have a bike:

I have a car:

这个例子说明了在HTML页面中如何创建复选框。用户可以选中，也可以取消选择复选框。

单选按钮

Male:

Female:

When a user clicks on a radio-button, the button becomes checked, and

all other buttons with the same name become unchecked

这个例子说明了在HTML页面中如何创建单选按钮。

简单的下拉列表

这个例子说明了在HTML页面如何创建下拉列表。下拉列表是可以选择的列表。

预选的下拉列表

这个例子说明了如何创建一个含有预先选定元素的下拉列表。

文本域

This example demonstrates a text-area.

 The cat was playing in the garden. 

这个例子说明了如何创建文本域（多行文本），用户可以在其中输入文本。在文本域中，字符个数不受限制。

创建按钮

这个例子说明了如何创建按钮。按钮上的文字可以自己定义。

数据周围的标题边框

Health information:

Height

Weight

If there is no border around the input form, your browser is too old.

这个例子说明了如何在数据周围画带有标题的边框。

含有文本框和提交按钮的表单：

Enter your first name:

Enter your last name:

If you click the "Submit" button, you will send your input to a new

page called action.asp.

这个例子说明了在HTML页面中加入表单。这个表单包含了两个文本框和一个提交按钮。

含有复选框的表单

I have a bike:

I have a car:

If you click the "Submit" button, you send your input to a new page

called action.asp.

这个表单包含了两个复选框和一个提交按钮。

含有单选按钮的表单

Male:

Female:

If you click the "Submit" button, you will send your input to a new

page called action.asp.

这个表单包含了两个单选按钮和一个提交按钮。

从表单发送电子邮件

enctype="text/plain">

This form sends an e-mail to W3Schools.

Name:

Mail:

Comment:

这个例子说明了如何从一个表单发送电子邮件。

HTML框架

使用框架，可以在一个浏览器窗口中显示不止一个页面。

例如：

垂直分栏

这个例子说明了如何创建一个有三个页面的垂直分栏。

水平分栏

这个例子说明了如何创建一个有三个页面的水平分栏。

如何使用

这个例子说明了如何使用