当您正在建立企业信息系统时，需要确保以某种有效的方式存储、检索和显示企业数据。对于所有业务而言，数据都是独一无二的最大资产。所有软件系统都涉及数据，因此，数据的重要性是无论如何强调都不过分的。

应用程序的数据管理功能包括四个基本操作，通常也需要对企业数据执行这四个操作，它们是： 建立、检索、更新和 删除（即 CRUD）。管理在企业系统的数据涉及在很长一段时间范围之内，始终如一地、成功地执行 CRUD 操作，而不必频繁地更改实际执行这些操作的代码。换句话说，管理数据意味着开发稳健的、可扩展和可维护的软件系统，以确保成功地进行 CRUD 操作，在软件的生命期中能够以一致的方式执行操作。

本文讨论了 J2EE 中的两种可用数据管理策略：Java 对象序列化和 Java 数据库连接（JDBC）。我们将查看这两种方法的优缺点。这两种数据管理策略实质上不存在孰优孰劣。在特定实现中，策略的可用性取决于项目的 范围（出现在系统环境中的活动的活动范围），系统的 上下文（驱动系统 / 子系统运行时的值的集合），以及其他的外部因素。然而，Java 序列化并不适合于企业系统，其数据需要用一种定义良好的结构（如 RDBMS）来组织。我们首先将快速浏览 Java 对象序列化，然后查看 JDBC 更重要的一些方面，从而了解后者是如何实现前者所缺乏的一些关键特性的。

本文并不打算对 Java 对象序列化或者 JDBC 进行全面介绍。有关这两项技术的更多信息，请回顾 参考资料小节。

Java 对象序列化

对象序列化是最简单的 Java 持久性策略。对象序列化是一个将 对象图平面化为一个字节的线性序列的过程。对象图是作为对象继承、关联和聚合的结果而实现的一些关系式。对象的非暂态实例属性以字节的形式被写入到持久存储中。实例属性的值就是执行时间序列化时内存中的值。如果一个 Java 对象是可序列化的，那么它至少必须实现 java.io.Serializable接口，该接口具有如下所示的结构：

 package java.io; 
 public interface Serializable 
 {} 

您可以看到， java.io.Serializable接口并没有声明任何方法。它是一个 记号或者 标记接口。它告诉 Java 运行时环境，该实现类是可序列化的。列表 1 显示实现该接口的一个示例类。

 import java.io.Serializable; 
 public class MySerializableObject extends MySuperClass implements Serializable 
 { 
	 private String property1 = null; 
 private String property2 = null; 
 public String getProperty1() 
 { 
	 return property1; 
 } 
 public void setProperty1(String val) 
 { 
	 property1 = val; 
 } 
 public String getProperty2() 
 { 
	 return property2; 
 } 
 public void setProperty2(String val) 
 { 
      property2 = val; 
 } 
      private void writeObject(ObjectOutputStream out) 
      throws IOException 
      { 
      	 out.writeObject (getProperty1 ()); 
     	 out.writeObject (getProperty2 ()); 
      } 
      private void readObject (ObjectInputStream in) 
      throws IOException, ClassNotFoundException 
      { 
       setProperty1 ((String) in.readObject ()); 
       setProperty2 ((String) in.readObject ()); 
      } 
 } 

无需自己实现 writeObject(...)和 readObject(...)方法来执行序列化；Java 运行时环境具有使这些方法可用的默认实现。然而，您可以重写这些方法，提供如何存储对象状态的您自己的实现。

关于序列化，您需要记住一些要点。首先，在序列化期间，整个对象图（即，所有父类和被引用类）都将被序列化。其次， Serializable类的所有实例变量自身都应该是可序列化的，除非已经特别声明它们为暂态，或者已经重写 writeObject(...)和 readObject(...)来只序列化那些可序列化的实例变量。如果违反了后一规则，在运行时将出现一个异常。

每个后续 J2SE 版本都对对象序列化系统进行少量的增加。J2SE 1.4 也相应地向 ObjectOutputStreamand ObjectInputStream增加 writeUnshared()and readUnshared()方法。通常，一个序列化的流只包含任何给定对象的一个序列化实例，并且共享对该对象引用的其他对象可以对它进行后向引用。通常期望序列化一个对象独立于其他对象可能维护的任何引用。非共享的读写方法允许对象作为新的、独一无二的对象被序列化，从而获得一个类似于对象克隆但开销更少的效果。

Java 对象序列化存在的问题

序列化涉及到将对象图从内存具体化到持久存储（例如硬盘）中。这涉及到大量 I/O 开销。通常，对应用程序而言，序列化并不是最佳选择：

• 管理几十万兆字节的存储数据
• 频繁地更新可序列化对象

对存储企业数据而言，序列化是一个错误选择，因为：

• 序列化的字节流只对 Java 语言是可读的。这是一个重大缺陷，因为企业系统通常是异构的，许多应用程序要与其他应用程序共同处理相同的数据。
  
  
• 对象检索涉及大量的 I/O 开销。
  
  
• 没有一个用来从序列化对象图中检索获取数据的查询语言。
  
  
• 序列化没有内置的安全机制。
  
  
• 序列化本身并不提供任何事务控制机制，因此不能在那些需要并发访问从而不使用辅助 API 的应用程序中使用它。

回页首

Java 数据库连接（JDBC）

Java 数据库连接（JDBC）是一个标准的 API，它使用 Java 编程语言与数据库进行交互。诸如 JDBC 的调用级接口是编程接口，它们允许从外部访问 SQL 命令来处理和更新数据库中的数据。通过提供与数据库连接的库例程，它们允许将 SQL 调用集成到通用的编程环境中。特别是，JDBC 有一个使接口变得极其简单和直观的例程的丰富收集。

在下面几个小节中，我们将查看通过 JDBC 与数据库连接所涉及的一些步骤。我们将特别关注与 Java 对象序列化相比，JDBC 是如何成为一个企业数据管理策略的。

建立一个数据库连接

在利用 JDBC 做任何其他事情之前，需要从驱动程序供应商那里获取数据库驱动程序，并且将该库添加到类路径中。一旦完这项工作，就可以在 Java 程序中使用类似于下面所示的代码来实现实际的连接。

 Class.forName(<your driver class Name>); 
 Java.sql.Connection conn = DriverManager.getConnection(<connection URL>); 

Java 对象序列化并不需要这个该步骤，因为使用序列化来执行持久性操作并不需要 DBMS。 序列化是一个基于文件的机制；因此，在序列化一个对象之前，需要在目标文件系统中打开一个 I/O 流。

创建 JDBC Statement 和 PreparedStatement

可以用 JDBC Statement对象将 SQL 语句发送到数据库管理系统（DBMS），并且不应该将该对象与 SQL 语句混淆。 JDBC Statement对象是与打开连接有关联，而不是与任何单独的 SQL 语句有关联。可以将 JDBC Statement对象看作是位于连接上的一个通道，将一个或多个（您请求执行的）SQL 语句传送给 DBMS。

为了创建 Statement对象，您需要一个活动的连接。通过使用我们前面所创建的 Connection对象 con——下面的代码来完成这项工作。

    Statement stmt = con.createStatement(); 

到目前为止，我们已经有了一个 Statement对象，但是还没有将对象传递到 DBMS 的 SQL 语句。

当数据库接收到语句时，数据库引擎首先会分析该语句并查找句法错误。一旦完成对语句的分析，数据库就必须计算出执行它的最有效方法。在计算上，这可能非常昂贵。数据库会检查哪些索引可以提供帮助，如果存在这样的索引的话，或者检查是否应该完全读取表中的所有行。数据库针对数据进行统计，找出最佳的执行方式。一旦创建好 查询计划，数据库引擎就可以执行它。

生成这样一个计划会占用 CPU 资源。理想情况是，如果我们两次发送相同的语句到数据库，那么我们希望数据库重用第一个语句的访问计划，我们可以使用 PreparedStatement对象来获得这种效果。

这里有一个主要的特性是，将 PreparedStatement与其超类 Statement区别开来：与 Statement不同，在创建 PreparedStatement时，会提供一个 SQL 语句。然后了立即将它发送给 DBMS，在那里编译该语句。因而， PreparedStatement实际上是作为一 个通道与连接和被编译的 SQL 语句相关联的。

那么，它的优势是什么呢？如果需要多次使用相同的查询或者不同参数的类似查询，那么利用 PreparedStatement，语句，只需被 DBMS 编译和优化一次即可。与使用正常的 Statement相比，每次使用相同的 SQL 语句都需要重新编译一次。

还可以通过 Connection方法创建 PreparedStatement。下面代码显示了如何创建一个带有三个输入参数的参数化了的 SQL 语句。

   PreparedStatement prepareUpdatePrice = con.prepareStatement( 
      "UPDATE Sells SET price = ? WHERE bar = ? AND beer = ?"); 

注意，Java 序列化不支持类似于 SQL 的查询语言。使用 Java 序列化访问对象属性的惟一途径就是反序列化该对象，并调用该对象上的 getter/accessor 方法。反序列化一个完整的对象在计算上可能很昂贵，尤其是在程序的生命期中，应用程序需要重复执行它。

在执行 PreparedStatement之前，需要向参数提供值。通过调用 PreparedStatement中定义的 setXXX()方法可以实现它。最常使用的方法是 setInt()， setFloat()， setDouble()，以及 setString()。每次执行已准备的声明之前，都需要设置这些值。

执行语句和查询

执行 JDBC 中的 SQL 语句的方式是根据 SQL 语句的目的而变化的。DDL（数据定义语言）语句（例如表建立和表更改语句）和更新表内容的语句都是通过使用 executeUpdate()执行的。列表 2 中包含 executeUpdate()语句的实例。

   Statement stmt = con.createStatement(); 
   stmt.executeUpdate("CREATE TABLE Sells " + 
      "(bar VARCHAR2(40), beer VARCHAR2(40), price REAL)" ); 
   stmt.executeUpdate("INSERT INTO Sells " + 
      "VALUES ('Bar Of Foo', 'BudLite', 2.00)" ); 
   String sqlString = "CREATE TABLE Bars " + 
      "(name VARCHAR2(40), address VARCHAR2(80), license INT)" ; 
   stmt.executeUpdate(sqlString); 

我们将通过先前插入的参数值（如上所示）执行 PreparedStatement，然后在这之上调用 executeUpdate()，如下所示：

      int n = prepareUpdatePrice.executeUpdate() ; 

相比之下， 查询期望返回一个行作为它的结果，并且并不改变数据库的状态。这里有一个称为 executeQuery()的相对应的方法，它的返回值是 ResultSet对象，如列表 3 所示。

   String bar, beer ; 
   float price ; 
   ResultSet rs = stmt.executeQuery("SELECT * FROM Sells"); 
   while ( rs.next() ) { 
      bar = rs.getString("bar"); 
      beer = rs.getString("beer"); 
      price = rs.getFloat("price"); 
      System.out.println(bar + " sells " + beer + " for " + price + " Dollars."); 
   } 

由于查询而产生的行集包含在变量 rs中，该变量是 ResultSet的一个实例。集合对于我们来说并没有太大用处，除非我们可以访问每一个行以及每一个行中的属性。 ResultSet提供了一个光标，可以用它依次访问每一个行。光标最初被设置在正好位于第一行之前的位置。每个方法调用都会导致光标向下一行移动，如果该行存在，则返回 true，或者如果没有剩余的行，则返回 false。

我们可以使用适当类型的 getXXX()来检索某一个行的属性。在前面的实例中，我们使用 getString()和 getFloat()方法来访问列值。注意，我们提供了其值被期望用作方法的参数的列的名称；我们可以指定用列号来代替列名。检索到的第一列的列号为 1，第二列为 2，依次类推。

在使用 PreparedStatement时，可以通过先前插入的参数值来执行查询，然后对它调用 executeQuery()，如下所示：

      ResultSet rs = prepareUpdatePrice.executeQuery() ; 

关于访问 ResultSet 的注释
JDBC 还提供一系列发现您在结果集中的位置的方法： getRow()， isFirst()， isBeforeFirst()， isLast()，以及 isAfterLast()。

这里还有一些使可滚动光标能够自由访问结果集中的任意行的方法。在默认情况下，光标只向前滚动，并且是只读的。在为 Connection创建 Statement时，可以将 ResultSet的类型更改为更为灵活的可滚动或可更新模型，如下所示：

Statement stmt = con.createStatement(ResultSet.TYPE_FORWARD_ONLY,
    ResultSet.CONCUR_READ_ONLY); 
ResultSet rs = stmt.executeQuery("SELECT * FROM Sells"); 

不同的类型选项： TYPE_FORWARD_ONLY、 TYPE_SCROLL_INSENSITIVE和 TYPE_SCROLL_SENSITIVE。可以通过使用 CONCUR_READ_ONLY和 CONCUR_UPDATABLE选项来选择光标是只读的还是可更新的。对于默认光标，可以使用 rs.next()向前滚动它。对于可滚动的光标，您有更多的选项，如下所示：

      rs.absolute(3);          // moves to the third retrieved row 
      rs.previous();           // moves back one row in the retrieved result set 
      rs.relative(2);          // moves forward two rows in the retrieved result set 
      rs.relative(-3);         // moves back three rows in the retrieved result set 

对于可滚动光标的工作方式，这里有更多的详细描述。尽管可滚动光标对于特定应用程序是有用的，但是它导致极大的性能损失，所以应该限制和谨慎使用。可以在 参考资料小节中找到关于可滚动 ResultSet的更多信息。

在序列化中不存在与 JDBC 的 ResultSet相对应的机制。序列化和 JDBC 观察底层的数据的角度不同。JDBC （通常）假定底层数据是关系型结构的；而序列化假定底层数据是一个对象图。两种技术的底层数据结构存在显著差异。JDBC 的 Set结构并不能自然地映射到序列化的对象图结构，反之亦然。当通过使用序列化语义将一个 Java 对象持久化时，数据的底层结构变成了一个字节流，该字节流展示了已经序列化了的核心对象的各种内部对象之间的关联。

JDBC 中的 ResultSet导航是从一个 Set元素移动到其他元素的过程，而在对象序列化中，这是不可能的，因为序列化涉及到对象关联，而不是将一组行封装到一个实体集合中。因此，Java 对象序列化无法向您提供用这种方式访问数据单独某个部分的能力。

事务

JDBC 允许将 SQL 语句组合到单独一个事务中。因此，我们可以通过使用 JDBC 事务特性来确保 ACID 属性。

Connection对象执行事务控制。当建立连接时，在默认情况下，连接是自动提交模式下。这意味着每个 SQL 语句自身都被看作是一个事务，并且一完成执行就会被提交。

可以用以下方法开启或关闭自动提交模式：

      con.setAutoCommit(false) ; 
      con.setAutoCommit(true) ; 

一旦关闭了自动提交，除非通过调用 commit()显式地告诉它提交语句，否则无法提交 SQL 语句（即，数据库将不会被持久地更新）。在提交之前的任何时间，我们都可以调用 rollback()回滚事务，并恢复最近的提交值（在尝试更新之前）。

我们还可以设置期望的事务隔离等级。例如，我们可以将设置事务隔离等级为 TRANSACTION_READ_COMMITTED，这使得在提交值之前，不允许对它进行访问。并且禁止脏读。在 Connection接口中为隔离等级提供了五个这样的值。默认情况下，隔离等级是可序列化的。JDBC 允许我们发现数据库所设置的是什么事务隔离等级（使用 Connection的 getTransactionIsolation()方法）以及设置适当的等级（使用 Connection的 setTransactionIsolation()方法）。

回滚通常与 Java 语言的异常处理能力结合在一起使用。这种结合为处理数据完整性提供一个简单高效的机制。在下一节中，我们将研究如何使用 JDBC 进行错误处理。

注意，Java 对象序列化并不直接支持事务管理。如果您正在使用序列化，则将需要借助其他的 API，例如 JTA，来获得这个效果。然而，为了获得事务隔离的效果，可以选择在执行一个更新操作时同步该序列化对象，如下所示：

		 Synchronized(my_deserialized_object) { 
		 //Perform the updates etc... 
		 } 

利用异常处理错误

软件程序中总是出现一些错误。通常，数据库程序是关键性应用程序，而且适当地捕获和处理错误是有必要的。程序应该恢复并且让数据库处于某种一致的状态下。将回滚与 Java 异常处理程序结合使用是达到这种要求的一种简便方法。

访问服务器（数据库）的客户（程序）需要能够识别从服务器返回的所有错误。JDBC 通过提供两种等级的错误条件来访问这种信息： SQLException和 SQLWarning。 SQLException是 Java 异常，它（如果未被处理）将会终止该应用程序。 SQLWarning是 SQLException的子类，但是它们代表的是非致命错误或意想不到的条件，因此，可以忽略它们。

在 Java 代码中，希望抛出异常或者警告的语句包含于 try块中。如果在 try块中的语句抛出异常或者警告，那么可以在对应的某个 catch语句中捕获它。每个捕获语句都指出了它准备捕获的异常。

换句话说，如果数据类型是正确的，但是数据库大小超出其空间限制并且不能建立一个新表，则可能会抛出一个异常。 可以从 Connection， Statement，以及 ResultSet对象中获取 SQLWarning。每个对象都只是存储最近 SQLWarning。因此，如果通过 Statement对象执行其他语句，则将放弃所有早期的警告。列表 4 举例说明了 SQLWarning的使用。

      ResultSet rs = stmt.executeQuery("SELECT bar FROM Sells") ; 
      SQLWarning warn = stmt.getWarnings() ; 
      if (warn != null) 
         System.out.println("Message: " + warn.getMessage()) ; 
      SQLWarning warning = rs.getWarnings() ; 
      if (warning != null) 
         warning = warning.getNextWarning() ; 
      if (warning != null) 
         System.out.println("Message: " + warn.getMessage()) ; 

实际上， SQLWarning在某种程度上比 SQLException更为罕见。最常见的是 DataTruncation警告，它表示在从数据库读或写数据时存在问题。

Java 并没有提供序列化所使用的特定的异常类。使用序列化时发生的大多数异常都与执行的 I/O 操作有关，因此，在这些情况中 I/O 异常类将满足要求。

批处理

JDBC 2.0 提供一个用于批处理的强大 API。批处理允许积累一组 SQL 语句，并且将它们一起发送并处理。一个典型的批处理就是银行应用程序，该应用程序每隔一刻钟就要更新许多账号。在减少从 Java 代码到数据库的往返次数方面，批处理是一个强大功能。

Statement接口提供 addBatch(String)方法，将 SQL 语句添加到一个批处理中。一旦已经将所有的 SQL 语句都增加到该批处理中，就可以使用 executeBatch()方法一起执行它们。

然后，用 executeBatch()方法执行 SQL 语句，并返回 int值的一个数组。该数组包含受每条语句影响的行数。将 SELECT语句或者其他返回 ResultSet的 SQL 语句放在一个批处理中会导致 SQLException。

列表 5 中列出了利用 java.sql.Statement进行批处理的一个简单实例。

 Statement stmt = conn.createStatement(); 
 stmt.insert("DELETE FROM Users"); 
 stmt.insert("INSERT INTO Users VALUES('rod', 37, 'circle')"); 
 stmt.insert("INSERT INTO Users VALUES('jane', 33, 'triangle')"); 
 stmt.insert("INSERT INTO Users VALUES('freddy', 29, 'square')"); 
 int[] counts = stmt.executeBatch(); 

在您不知道特定语句将运行的次数时，批处理是一个处理 SQL 代码的好方法。例如，如果在不使用批处理的情况下试图插入 100 条记录，那么性能可能会受到影响。如果编写一个脚本，增加 10000 条记录，那么情况会变得更糟。添加批处理可以帮助提高性能，后者甚至能够提高代码的可读性。

Java 对象序列化并不支持批处理。通常，会在某个对象的范围（联系图）上运用序列化，在这种情况下，批处理没有意义。因此，批处理在数据更新的定时和分组方面为您提供一定的灵活性，而这些对于序列化来说不一定是可用的。

回页首

从 Java 代码调用存储过程

存储过程是一组 SQL 语句，它们建立了一个逻辑单元，并执行特定任务。可以用存储过程来封装一个操作或者查询的集合，这些操作或查询都将在一个数据库服务器上执行。存储过程是在数据库服务器中被编译和存储的。因此，每次调用存储过程时，DBMS 都将重用已编译的二进制代码，因此执行速度会更快。

JDBC 允许您从 Java 应用程序中调用数据库存储过程。第一步是创建 CallableStatement对象。与 Statement和 PreparedStatement对象一样，这项操作是用一个打开的 Connection对象完成的。 CallableStatement对象包含对存储过程的调用；但它并不包含存储过程自身。列表 6 中的第一行代码使用 con连接建立了对存储过程 SHOW_ACCOUNT的调用。波形括号中括住的部分是存储过程的转义语法。当驱动程序遇到 {call SHOW_ACCOUNT}时，它将该转义语法翻译成数据库所使用的本地 SQL，从而调用名为 SHOW_ACCOUNT的存储过程。

 CallableStatement cs = con.prepareCall("{call SHOW_ACCOUNT(?)}"); 
 cs.setInt(1,myaccountnumber); 
 ResultSet rs = cs.executeQuery(); 

假设 Sybase 中的存储过程 SHOW_ACCOUNT包含列表 7 中所示的代码。

 CREATE PROCEDURE SHOW_ACCOUNT (@Acc int) 
 AS 
 BEGIN 
	 Select balance from USER_ACCOUNTS where Account_no = @Acc 
 END 

ResultSet rs看起来类似于：

 balance 			
 ---------------- 		
 12000.95 

注意，用来执行 cs的方法是 executeQuery()，由于 cs调用的存储过程只包含一个查询，所以只产生一个结果集。如果该过程只包含一个更新或者一个 DDL 语句，则将使用 executeUpdate()方法。然而，有时候存在存储过程包含多个 SQL 语句的情况，在这种情况下，它将产生多个结果集、多个更新计数，或者结果集和更新计数的某种结合。因此，应该使用 execute()方法执行 CallableStatement。

CallableStatement类是 PreparedStatement的子类，因此 CallableStatement对象可以接受与 PreparedStatement对象相同的参数。而且， CallableStatement对象可以接受输出参数，并将该参数用于输入和输出。 INOUT参数和 execute()方法通常很少使用。要想处理 OUT参数，需要通过使用 registerOutParameter(int, int)方法将 OUT参数注册到存储过程。

举例说明，我们假设 GET_ACCOUNT过程包含列表 8 中的代码。

 CREATE PROCEDURE GET_ACCOUNT (@Acc int, @balance float OUTPUT) 
 AS 
 BEGIN 
 Select @balance = balance from USER_ACCOUNTS where Account_no = 	 @Acc 
 END 

在这个实例中，参数 balance被声明是一个 OUT参数。现在，调用该过程的 JDBC 代码如列表 9 所示。

 CallableStatement csmt = con.prepareCall("{GET_ACCOUNT(?,?)"); 
 csmt.setInt(1,youraccountnumber); 
 csmt.registerOutParamter(2,java.sql.Types.FLOAT); 
 csmt.execute(); 

正使用 Java 序列化时，并不需要访问任何外部的系统，如 DBMS。换句话说，序列化是一个纯 Java 语言现象，它不涉及执行一个外部环境中的已编译代码。因此，在序列化中不存在与 CallableStatement对象相对应的机制。这意味着您不能将数据处理转移到外部系统或者组件中，尽管这些系统或者组件可能更适合它。

回页首

包装

在读完本文之后，我们希望您赞同：对于数据管理和持久化而言， JDBC 是比 Java 对象序列化要好得多的方法。

JDBC 是一个用来访问数据存储的极好的 API。 JDBC 最好的东西是它提供单一的 API 集合来访问多种数据源。用户只需要学习一个 API 集合，就可以访问任何数据源，这些数据源可以是关系型的、层次型的或者任何其他格式。您需要的只是一个 JDBC 驱动程序，用它连接到目标数据源。JDBC 做了大量工作，将所有技术细节都封装到了一个实现软件包中，从而将程序员从供应商特定的桎梏中解放出来。

表 1 对比了 JDBC 和 Java 对象序列化的各种特性。

表 1. JDBC 对 Java 序列化

Java 对象序列化和 JDBC 是 Java 技术领域中许多数据持久化机制中的两种。在需要在多个 JVM 之间以 Java 语言特定格式共享数据（例如用 RMI 的按值传递机制共享数据）时，序列化最适合不过。然而，Java 序列化并不适用于企业数据，需要以一种定义良好的结构对这些数据进行组织。在这样的企业系统中，需要在多个系统和子系统之间共享数据，而这些系统并不一定都与 Java 语言兼容。在这种情况中，对象序列化根本不能工作。

JDBC 提供一个公用 API 来访问异构的数据存储。它是 JVM 和目标 DBMS 之间的粘合剂。它提供了一个使用 Java 平台访问数据存储和维护企业数据的纲领性方法。然而，执行 CRUD 操作所需的所有代码都是由开发人员编写。

为了在企业环境中最有效地使用 JDBC，架构设计人员需要分析其企业中的数据，并开发一个用于数据持久性的框架。由于使用 JDBC 持久化数据的机制与系统想要解决的商业问题无关，因此强烈建议将数据持久性层与应用程序的商业逻辑相分离。设计模式对设计这种框架非常有帮助。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
  
  
• 有关 JDBC 的更多信息，请参阅 " Use JDBC for industrial-strength performance," Lennart Jorelid（ developerWorks,2000 年 2 月）。
  
  
• 请参阅 " Object persistence and Java," Arsalan Saljoughy （ JavaWorld,1997 年 5 月）。
  
  
• 有关 Java 序列化和 JavaBeans 技术的讨论，请参阅 " Serialization and the JavaBeans specification," Mark Johnson （ JavaWorld,1998 年 2 月）。
  
  
• IBM 维护一张对比 遗留的 JDBC 驱动程序与通用的 JDBC 驱动程序之间的行为差异的表。
  
  
• 有关可滚动结果集的详细讨论，请参阅另一篇 IBM 的文档，" Specifying updatability and scrollability for ResultSets in JDBC applications。"
  
  
• 有关 JDO 和 EJB 技术的对比，请参阅 " J2EE 探险者：持久数据管理，第 2 部分," Kyle Gabhart（ developerWorks,2003 年 5 月）。
  
  
• 您可以从两本 Java.sun.com 指南中发现有关可滚动 ResultSet的更多信息，" JDBC fundamentals" 和 " Paging with Scrollable ResultSets。"
  
  
• 请查阅 java.sql.Types接口的 API 文档。
  
  
• 请访问 开发者书店，获得技术书籍的完整列表，其中包括数百本 Java 相关的图书。
  
  

作者简介

为本文评分

评论

回页首

内容

• Java 对象序列化
• Java 数据库连接（JDBC）
• 从 Java 代码调用存储过程
• 包装
• 参考资料
• 作者简介
• 建议