模块 java.sql.rowset
包 javax.sql.rowset

接口 CachedRowSet

所有父级接口：
AutoCloseable , Joinable , ResultSet , RowSet , Wrapper
所有已知的子接口：
FilteredRowSet , JoinRowSet , WebRowSet
public interface CachedRowSet extends RowSet , Joinable
CachedRowSet 的所有标准实现必须实现的接口。

Oracle公司提供的CachedRowSet接口的参考实现是标准实现。开发人员可以按原样使用这个实现，他们可以扩展它，或者他们可以选择编写他们自己的这个接口的实现。

CachedRowSet 对象是数据行的容器，将其行缓存在内存中，这使得无需始终连接到其数据源即可进行操作。此外，它是一个 JavaBeans 组件并且是可滚动的、可更新的和可序列化的。 CachedRowSet 对象通常包含结果集中的行，但它也可以包含来自任何具有表格格式的文件（例如电子表格）的行。参考实现仅支持从 ResultSet 对象获取数据，但开发人员可以扩展 SyncProvider 实现以提供对其他表格数据源的访问。

应用程序可以修改 CachedRowSet 对象中的数据，然后这些修改可以传播回数据源。

CachedRowSet 对象是断开连接行集，这意味着它仅短暂地使用到其数据源的连接。它在读取数据以用行填充自身时连接到其数据源，并在将更改传播回其基础数据源时再次连接到其数据源。其余时间，CachedRowSet 对象断开连接，包括修改其数据时。断开连接使 RowSet 对象更精简，因此更容易传递给另一个组件。例如，断开连接的 RowSet 对象可以被序列化并通过线路传递到瘦客户端，例如个人数字助理 (PDA)。

1.0 创建一个CachedRowSet对象

以下代码行使用参考实现 (RI) 中提供的 CachedRowSet 默认构造函数来创建默认 CachedRowSet 对象。 
   CachedRowSetImpl crs = new CachedRowSetImpl();
这个新的 CachedRowSet 对象会将其属性设置为 BaseRowSet 对象的默认属性，此外，它将有一个 RIOptimisticProvider 对象作为其同步提供程序。 RIOptimisticProvider 是 RI 中包含的两个 SyncProvider 实现之一，是在未指定同步提供程序时 SyncFactory 单例将提供的默认提供程序。

SyncProvider 对象为 CachedRowSet 对象提供了一个读取器（一个 RowSetReader 对象），用于从数据源读取数据以用数据填充自身。可以实现读取器以从 ResultSet 对象或具有表格格式的文件中读取数据。 SyncProvider 对象还提供了一个编写器（RowSetWriter 对象），用于同步对 CachedRowSet 对象数据所做的任何修改，同时它与基础数据源中的数据断开连接。

编写器可以实施为在检查冲突和避免冲突时行使不同程度的注意。 （当数据源中的值在行集用该值填充自身后发生更改时会发生冲突。）RIOptimisticProvider 实现假定几乎没有或没有冲突，因此不设置锁。只有在没有冲突的情况下，它才会使用 CachedRowSet 对象中的值更新数据源。可以实现其他编写器，以便它们始终将修改后的数据写入数据源，这可以通过不检查冲突来实现，或者在频谱的另一端，通过设置足以防止数据源中的数据被篡改的锁来实现变了。还有其他编写器实现可以介于两者之间。

CachedRowSet 对象可以使用任何已在 SyncFactory 单例中注册的 SyncProvider 实现。应用程序可以通过调用以下代码行找出已注册的SyncProvider 实现。

   java.util.Enumeration providers = SyncFactory.getRegisteredProviders();

CachedRowSet 对象可以通过两种方式指定它将使用哪个 SyncProvider 对象。

  • 向构造方法提供实现的名称
    以下代码行创建 CachedRowSet 对象crs2它使用默认值初始化，除了它的 SyncProvider 对象是指定的对象。 
         CachedRowSetImpl crs2 = new CachedRowSetImpl(
                 "com.fred.providers.HighAvailabilityProvider");
  • 使用CachedRowSet方法setSyncProvider设置SyncProvider
    以下代码行重置 SyncProvider 对象crs，使用默认构造函数创建的 CachedRowSet 对象。 
          crs.setSyncProvider("com.fred.providers.HighAvailabilityProvider");
有关详细信息，请参阅 SyncFactory 和 SyncProvider 的注释。

2.0 从 CachedRowSet 对象中检索数据

使用从 ResultSet 接口继承的 getter 方法从 CachedRowSet 对象检索数据。以下示例（其中 crs 是一个 CachedRowSet 对象）演示了如何遍历行，检索每行中的列值。第一个示例使用带有列号的 getter 方法版本；第二个示例使用带有列名的版本。当 RowSet 对象的命令的形式为 SELECT * FROM TABLENAME 时，通常使用列号；当命令按名称指定列时，最常使用列名。 
  while (crs.next()) {
    String name = crs.getString(1);
    int id = crs.getInt(2);
    Clob comment = crs.getClob(3);
    short dept = crs.getShort(4);
    System.out.println(name + " " + id + " " + comment + " " + dept);
  }
 
  while (crs.next()) {
    String name = crs.getString("NAME");
    int id = crs.getInt("ID");
    Clob comment = crs.getClob("COM");
    short dept = crs.getShort("DEPT");
    System.out.println(name + " " + id + " " + comment + " " + dept);
  }

2.1 检索 RowSetMetaData

应用程序可以通过调用 RowSetMetaData 对象上的 ResultSetMetaData 和 RowSetMetaData 方法来获取有关 CachedRowSet 对象中列的信息。以下代码片段，其中crs是一个CachedRowSet对象，说明了这个过程。第一行创建一个 RowSetMetaData 对象，其中包含有关列的信息crs.方法 getMetaData 继承自 ResultSet 接口，返回一个 ResultSetMetaData 对象，在分配给变量之前转换为 RowSetMetaData 对象RSMD.第二行找出有多少列jrs有，第三行获取存储在 jrs 的第二列中的 JDBC 类型的值。 
   RowSetMetaData rsmd = (RowSetMetaData)crs.getMetaData();
   int count = rsmd.getColumnCount();
   int type = rsmd.getColumnType(2);
RowSetMetaData 接口在两个方面不同于 ResultSetMetaData 接口。
  • 它包括 setter 方法：当 RowSet 对象被来自不同 ResultSet 对象的数据填充时，它会在内部使用这些方法。
  • 它包含更少的 getter 方法：某些 ResultSetMetaData 方法不适用于 RowSet 对象。例如，检索列值是可写还是只读的方法不适用，因为 RowSet 对象的所有列都是可写或只读的，具体取决于行集是否可更新。
注意：为了返回一个 RowSetMetaData 对象，实现必须覆盖 java.sql.ResultSet 中定义的 getMetaData() 方法并返回一个 RowSetMetaData 对象。

3.0 更新一个CachedRowSet对象

更新 CachedRowSet 对象类似于更新 ResultSet 对象，但由于行集在更新时未连接到其数据源，因此它必须采取额外的步骤来影响其基础数据源中的更改。在调用方法 updateRow 或 insertRow 之后，CachedRowSet 对象还必须调用方法 acceptChanges 才能将更新写入数据源。以下示例，其中光标位于 CachedRowSet 对象中的一行crs，显示更新当前行中的两个列值以及更新 RowSet 对象的基础数据源所需的代码。 
   crs.updateShort(3, 58);
   crs.updateInt(4, 150000);
   crs.updateRow();
   crs.acceptChanges();

下一个示例演示移动到插入行，在插入行上构建新行，将其插入行集中，然后调用方法 acceptChanges 将新行添加到基础数据源。请注意，与 getter 方法一样，updater 方法可能采用列索引或列名来指定正在处理的列。

   crs.moveToInsertRow();
   crs.updateString("Name", "Shakespeare");
   crs.updateInt("ID", 10098347);
   crs.updateShort("Age", 58);
   crs.updateInt("Sal", 150000);
   crs.insertRow();
   crs.moveToCurrentRow();
   crs.acceptChanges();

注意：insertRow() 方法插入 CachedRowSet 对象的插入行内容的位置是实现定义的。 CachedRowSet 接口的参考实现会在当前行之后立即插入一个新行，但它可以实现为在任意数量的其他位置插入新行。

关于这些示例的另一件事是它们如何使用方法 acceptChanges 。正是这种方法将 CachedRowSet 对象中的更改传播回基础数据源，在内部调用 RowSet 对象的编写器以将更改写入数据源。为此，作者必须承担与该数据源建立连接的费用。前面两个代码片段在调用 updateRow 或 insertRow 之后立即调用方法 acceptChanges 。但是，当有多行被更改时，在对 updateRow 和 insertRow 的所有调用都已完成后调用 acceptChanges 会更有效。如果只调用一次acceptChanges，则只需要建立一个连接。

4.0 更新底层数据源

执行方法 acceptChanges 时，将在后台调用 CachedRowSet 对象的编写器，即 RowSetWriterImpl 对象，以将对行集所做的更改写入基础数据源。实现编写器以连接到数据源并向其写入更新。

如第 1 节“创建 CachedRowSet 对象”中所述，通过 SyncProvider 接口的实现可以使用编写器。默认参考实现提供程序 RIOptimisticProvider 已将其编写器实现为使用乐观并发控制机制。也就是说，当行集与数据库断开连接时，它不会在底层数据库中维护任何锁，并在将数据写入数据源之前简单地检查是否存在任何冲突。如果有任何冲突，它不会向数据源写入任何内容。

SyncProvider 类提供的读写器设施是可插入的，允许自定义数据检索和更新。如果需要不同的并发控制机制，可以使用方法 setSyncProvider 插入 SyncProvider 的不同实现。

为了使用乐观并发控制例程，RIOptimisticProvider 保持其当前值和原始值（紧接在当前值之前的值）。请注意，如果未对 RowSet 对象中的数据进行任何更改，则其当前值和原始值相同，都是最初填充 RowSet 对象的值。然而，一旦RowSet对象中的任何值被改变，当前值和原始值将不同，尽管在这个阶段，原始值仍然是初始值。随着对 RowSet 对象中数据的任何后续更改，其原始值和当前值仍将不同，但其原始值将是以前的当前值。

跟踪原始值允许作者将 RowSet 对象的原始值与数据库中的值进行比较。如果数据库中的值与 RowSet 对象的原始值不同，这意味着数据库中的值已更改，则存在冲突。编写器是否检查冲突、检查的程度如何以及如何处理冲突都取决于它是如何实现的。

5.0 注册和通知监听

作为 JavaBeans 组件，所有行集都参与 JavaBeans 事件模型，从 BaseRowSet 类继承用于注册监听器和通知它们更改的方法。 CachedRowSet 对象的监听器是一个组件，它希望在行集中发生更改时得到通知。例如，如果 CachedRowSet 对象包含查询结果并且这些结果显示在表格和条形图中，则表格和条形图可以注册为行集的监听器，以便它们可以更新自己以反映变化。要成为监听器，表格和条形图类必须实现 RowSetListener 接口。然后可以将它们添加到 CachedRowSet 对象的监听器列表中，如以下代码行所示。 
  crs.addRowSetListener(table);
  crs.addRowSetListener(barGraph);
移动光标或更改数据的每个 CachedRowSet 方法也会将更改通知注册的监听器，因此当 crs 发生更改时，table 和 barGraph 将收到通知。

6.0 将数据传递给瘦客户端

使用 CachedRowSet 对象的主要原因之一是在应用程序的不同组件之间传递数据。因为它是可序列化的，所以可以使用 CachedRowSet 对象，例如，通过网络将在服务环境中运行的企业 JavaBeans 组件执行的查询结果发送到在 Web 浏览器中运行的客户端。

虽然 CachedRowSet 对象已断开连接，但它比具有相同数据的 ResultSet 对象要精简得多。因此，它特别适合将数据发送到瘦客户端（如 PDA），由于资源限制或安全考虑，在这种情况下不适合使用 JDBC 驱动程序。因此，CachedRowSet 对象提供了一种无需实现完整 JDBC API 即可“获取行”的方法。

7.0 滚动和更新

CachedRowSet 对象的第二个主要用途是为本身不提供这些功能的 ResultSet 对象提供滚动和更新。换句话说，当 DBMS 不提供对滚动和更新的完全支持时，CachedRowSet 对象可用于增强支持 JDBC 技术的驱动程序（以下称为“JDBC 驱动程序”）的功能。要实现使不可滚动和只读的 ResultSet 对象可滚动和可更新的效果，程序员只需创建一个 CachedRowSet 对象并填充该 ResultSet 对象的数据。这在以下代码片段中进行了演示，其中 stmt 是一个 Statement 对象。 
  ResultSet rs = stmt.executeQuery("SELECT * FROM EMPLOYEES");
  CachedRowSetImpl crs = new CachedRowSetImpl();
  crs.populate(rs);

对象 crs 现在包含来自表 EMPLOYEES 的数据，就像对象 rs 一样。不同之处在于，即使 rs 的游标只能向前移动，crs 的游标也可以向前移动、向后移动或移动到特定行。此外，即使 rs 不是，crs 也是可更新的，因为默认情况下，CachedRowSet 对象既可滚动又可更新。

总之，可以将 CachedRowSet 对象简单地视为一组断开连接的行，这些行被缓存在数据源之外。由于是瘦的和可序列化的，它可以很容易地通过线路发送，并且非常适合将数据发送到瘦客户端。但是，CachedRowSet 对象确实有一个限制：它的大小受一次可以存储在内存中的数据量的限制。

8.0 获取通用数据访问

CachedRowSet 类的另一个优点是它可以从关系数据库以外的来源检索和存储数据。可以实现行集读取器，以使用来自任何表格数据源（包括电子表格或平面文件）的数据读取和填充其行集。因为 CachedRowSet 对象及其元数据都可以从头开始创建，所以充当行集工厂的组件可以使用此功能创建包含来自非 SQL 数据源的数据的行集。然而，预计大多数时候，CachedRowSet 对象将包含使用 JDBC API 从 SQL 数据库中获取的数据。

9.0 设置属性

所有行集都维护一组属性，这些属性通常使用工具进行设置。行集具有的属性的数量和种类会有所不同，具体取决于行集的作用及其获取数据的方式。例如，从 ResultSet 对象获取数据的行集需要设置建立数据库连接所需的属性。如果行集使用 DriverManager 设施建立连接，它需要为标识适当驱动程序的 JDBC URL 设置一个属性，并且它需要设置提供用户名和密码的属性。另一方面，如果行集使用 DataSource 对象建立连接（这是首选方法），则不需要设置 JDBC URL 的属性。相反，它需要为数据源的逻辑名称、用户名和密码设置属性。

注意：为了使用 DataSource 对象建立连接，DataSource 对象必须已注册到使用 Java 命名和目录接口 (JNDI) API 的命名服务。该注册通常由以系统管理员身份行事的人员完成。

为了能够用数据库中的数据填充自身，行集需要设置一个命令属性。此属性是一个查询，它是一个 PreparedStatement 对象，它允许查询具有在运行时设置的参数占位符，而不是设计时。为了用值设置这些占位符参数，行集提供了用于设置每种数据类型的值的设置方法，类似于PreparedStatement接口提供的设置方法。

以下代码片段说明了 CachedRowSet 对象 crs 可能如何设置其命令属性。请注意，如果使用工具来设置属性，则这是该工具将使用的代码。


  crs.setCommand("SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS " +
          "WHERE CREDIT_LIMIT > ? AND REGION = ?");

将用于设置命令占位符参数的值包含在 RowSet 对象的 params 字段中，这是一个 Vector 对象。 CachedRowSet 类提供了一组设置方法，用于设置其 params 字段中的元素。以下代码片段演示了在上一示例的查询中设置两个参数。

  crs.setInt(1, 5000);
  crs.setString(2, "West");

params 字段现在包含两个元素，每个元素都是一个长度为两个元素的数组。第一个元素是参数号；第二个是要设置的值。在这种情况下，params 的第一个元素是 1、5000，第二个元素是2、"West"。当应用程序调用方法 execute 时，它将依次调用此 RowSet 对象的读取器，后者将依次调用其 readData 方法。作为其实现的一部分，readData 将获取 params 中的值并使用它们来设置命令的占位符参数。以下代码片段让读者了解在获得 Connection 对象 con 后如何执行此操作。


  PreparedStatement pstmt = con.prepareStatement(crs.getCommand());
  reader.decodeParams();
  // decodeParams figures out which setter methods to use and does something
  // like the following:
  //  for (i = 0; i < params.length; i++) {
  //    pstmt.setObject(i + 1, params[i]);
  //  }

此时，crs 的命令是查询 "SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS WHERE CREDIT_LIMIT > 5000 AND REGION = "West"。在 readData 方法使用以下代码行执行此命令后，它将使用来自 rs 的数据来填充 crs 。


   ResultSet rs = pstmt.executeQuery();

前面的代码片段给出了幕后发生的事情的概念；它们不会出现在应用程序中，应用程序不会调用 readData 和 decodeParams 等方法。相反，以下代码片段显示了应用程序可能执行的操作。它设置行集的命令、设置命令的参数并执行命令。只需调用 execute 方法，crs 就会使用表 CUSTOMERS 中的请求数据填充自身。


  crs.setCommand("SELECT FIRST_NAME, LAST_NAME, ADDRESS FROM CUSTOMERS" +
          "WHERE CREDIT_LIMIT > ? AND REGION = ?");
  crs.setInt(1, 5000);
  crs.setString(2, "West");
  crs.execute();

10.0 分页数据

因为 CachedRowSet 对象将数据存储在内存中，所以它在任何时候可以包含的数据量由可用内存量决定。为了绕过这个限制，CachedRowSet 对象可以从数据块中的 ResultSet 对象中检索数据，称为页数.为利用此机制，应用程序使用方法 setPageSize 设置要包含在页面中的行数。换句话说，如果页面大小设置为五，则一次将从数据源中获取五行数据的块。应用程序还可以选择设置一次可以获取的最大行数。如果最大行数设置为零，或者未设置最大行数，则一次可以获取的行数没有限制。

设置属性后，CachedRowSet 对象必须使用方法 populate 或方法 execute 填充数据。以下代码行演示如何使用方法 populate 。请注意，此版本的方法采用两个参数，ResultSet 句柄和 ResultSet 对象中开始检索行的行。

   CachedRowSet crs = new CachedRowSetImpl();
   crs.setMaxRows(20);
   crs.setPageSize(4);
   crs.populate(rsHandle, 10);
当这段代码运行时，crs将填充四行来自rs句柄从第十行开始。

下一个代码片段显示使用方法 execute 填充 CachedRowSet 对象，该方法可能会或可能不会将 Connection 对象作为参数。此代码传递 execute Connection 对象控制台句柄.

请注意，以下代码片段与前一个代码片段有两处不同。首先，方法 setMaxRows 没有被调用，所以没有为行数设置限制crs可能含有。 （记住，crs总是有它可以存储在内存中的数据量的压倒性限制。）第二个区别是你不能传递方法 execute ResultSet 对象中的行数，从中开始检索行。此方法始终从第一行开始。

   CachedRowSet crs = new CachedRowSetImpl();
   crs.setPageSize(5);
   crs.execute(conHandle);
这段代码运行后，crs将包含命令生成的 ResultSet 对象中的五行数据crs.作者为crs将使用控制台句柄连接到数据源并执行命令crs.然后应用程序能够对中的数据进行操作crs与它对任何其他 CachedRowSet 对象中的数据进行操作的方式相同。

要访问下一页（数据块），应用程序调用方法 nextPage 。此方法创建一个新的 CachedRowSet 对象并用下一页数据填充它。例如，假设 CachedRowSet 对象的命令返回一个 ResultSet 对象rs有 1000 行数据。如果页面大小已设置为 100，则第一次调用方法 nextPage 将创建一个包含前 100 行的 CachedRowSet 对象rs.在对前 100 行中的数据执行所需的操作后，应用程序可以再次调用方法 nextPage 来创建另一个 CachedRowSet 对象，其中的后 100 行来自rs.第一个 CachedRowSet 对象的数据将不再在内存中，因为它被第二个 CachedRowSet 对象的数据替换。在第十次调用方法 nextPage 之后，第十个 CachedRowSet 对象将包含来自的最后 100 行数据rs存储在内存中。在任何给定时间，只有一个 CachedRowSet 对象的数据存储在内存中。

只要当前页面不是行的最后一页，nextPage 方法就会返回 true，如果没有更多页面，则返回 false。因此，它可以在 while 循环中使用以检索所有页面，如以下代码行所示。

   CachedRowSet crs = CachedRowSetImpl();
   crs.setPageSize(100);
   crs.execute(conHandle);

   while(crs.nextPage()) {
     while(crs.next()) {
       . . . // operate on chunks (of 100 rows each) in crs,
          // row by row
     }
   }
运行此代码片段后，应用程序将遍历所有 1000 行，但内存中一次不会超过 100 行。

CachedRowSet 接口还定义了方法 previousPage 。正如nextPage 方法类似于ResultSet 方法next，方法previousPage 类似于ResultSet 方法previous。与方法 nextPage 类似，previousPage 创建一个 CachedRowSet 对象，其中包含设置为页面大小的行数。因此，例如，方法 previousPage 可以在前面代码片段末尾的 while 循环中使用，以从最后一页导航回第一页。 previousPage 方法也类似于 nextPage，因为它可以在 while 循环中使用，不同之处在于它返回 true 只要前面有另一页，当前面没有更多页时返回 false。

通过将光标定位在每一页的最后一行之后，如以下代码片段中所做的那样，previous 方法从每一页的最后一行导航到第一行。该代码还可以将光标留在每一页的第一行之前，然后在 while 循环中使用方法 next 将每一页从第一行导航到最后一行。

以下代码片段假定是前一个代码片段的延续，这意味着第十个 CachedRowSet 对象的游标位于最后一行。代码将光标移动到最后一行之后，以便第一次调用方法 previous 会将光标放回最后一行。在浏览完最后一页中的所有行之后（CachedRowSet 对象crs)，然后代码进入 while 循环以到达第九页，向后遍历行，转到第八页，向后遍历行，依此类推到达第一页的第一行。

   crs.afterLast();
   while(crs.previous()) {
     . . . // navigate through the rows, last to first
   {
   while(crs.previousPage()) {
     crs.afterLast();
     while(crs.previous()) {
       . . . // go from the last row to the first row of each page
     }
   }
自从：
1.5

  • 字段详细信息

    • COMMIT_ON_ACCEPT_CHANGES

      @Deprecated static final boolean COMMIT_ON_ACCEPT_CHANGES
      已弃用。
      因为这个字段是最终的（它是接口的一部分），所以它的值不能改变。
      导致 CachedRowSet 对象的 SyncProvider 在调用 acceptChanges() 时提交更改。如果设置为 false，更改将not提交，直到调用 CachedRowSet 接口事务方法之一。
      参见：

  • 方法详情

    • populate

      void populate(ResultSet  data) throws SQL异常
      使用来自给定 ResultSet 对象的数据填充此 CachedRowSet 对象。

      当应用程序连接到打开的 ResultSet 对象时，此方法可用作 execute 方法的替代方法。使用方法 populate 比使用不带参数的 execute 方法更有效，因为它不会打开新连接并重新执行此 CachedRowSet 对象的命令。与使用带有 ResultSet 对象的 execute 版本相比，使用 populate 方法更加方便。

      参数：
      data - 包含要读入此 CachedRowSet 对象的数据的 ResultSet 对象
      抛出：
      SQLException - 如果提供了空的 ResultSet 对象或此 CachedRowSet 对象无法检索关联的 ResultSetMetaData 对象
      参见：

    • execute

      void execute(Connection  conn) throws SQL异常
      用数据填充此 CachedRowSet 对象，使用给定的连接生成将从中读取数据的结果集。此方法应关闭它创建的所有数据库连接，以确保此 CachedRowSet 对象断开连接，除非它正在从其数据源读取数据或将数据写入其数据源。

      这个 CachedRowSet 对象的读者将使用康恩建立与数据源的连接，以便它可以执行行集的命令并将生成的 ResultSet 对象中的数据读取到此 CachedRowSet 对象中。这个方法也关闭康恩在它填充了这个 CachedRowSet 对象之后。

      如果在已填充实现时调用此方法，则会（重新）设置内容和元数据。此外，如果在调用方法 acceptChanges 以提交未完成的更新之前调用此方法，则这些更新将丢失。

      参数：
      conn - 具有有效属性的标准 JDBC Connection 对象
      抛出：
      SQLException - 如果提供了无效的 Connection 对象或在建立与数据源的连接时发生错误
      参见：

    • acceptChanges

      void acceptChanges() throws SyncProviderException
      将对此 CachedRowSet 对象所做的行更新、插入和删除更改传播到基础数据源。

      此方法调用此 CachedRowSet 对象的编写器来完成幕后工作。标准 CachedRowSet 实现应该使用 SyncFactory 单例来获得一个 SyncProvider 实例，提供一个 RowSetWriter 对象（编写器）。编写器将尝试将在此 CachedRowSet 对象中所做的更改传播回数据源。

      当方法acceptChanges执行成功时，除了将更改写入数据源之外，它还使当前行中的值成为原始行中的值。

      根据所使用的 SyncProvider 实现的同步级别，编写器会将原始值与数据源中的值进行比较以检查是否存在冲突。当存在冲突时，RIOptimisticProvider 实现，例如，抛出一个 SyncProviderException 并且不向数据源写入任何内容。

      应用程序可以选择捕获 SyncProviderException 对象并检索它包含的 SyncResolver 对象。 SyncResolver 对象逐行列出冲突，并在数据源上设置锁以避免在解决当前冲突时进一步发生冲突。此外，对于每个冲突，它都提供了检查冲突和设置应保留在数据源中的值的方法。解决所有冲突后，应用程序必须再次调用 acceptChanges 方法以将已解决的值写入数据源。如果数据源中的所有值都已经是要持久化的值，则acceptChanges方法什么都不做。

      一些提供者实现可能使用锁来确保没有冲突。在这种情况下，可以保证编写器在调用方法 acceptChanges 时成功将更改写入数据源。该方法可以在 updateRow 、 insertRow 或 deleteRow 方法调用后立即调用，但在所有更改完成后只调用一次更高效，这样只需要建立一个连接。

      注意：acceptChanges() 方法将确定 COMMIT_ON_ACCEPT_CHANGES 是否设置为真。如果设置为true，则同步中的所有更新都提交到数据源。否则，申请必须根据需要显式调用 commit() 或 rollback() 方法。

      抛出：
      SyncProviderException - 如果底层同步提供程序的编写器无法将更新写回数据源
      参见：

    • acceptChanges

      void acceptChanges(Connection  con) throws SyncProviderException
      使用指定的 Connection 对象将所有行更新、插入和删除更改传播到支持此 CachedRowSet 对象的数据源，以建立与数据源的连接。

      acceptChanges 方法的另一个版本未传递连接，因为它使用已在 RowSet 对象中定义的 Connection 对象，这是最初用于填充它的连接。

      acceptChanges 方法的这种形式类似于不带参数的形式；但是，与其他形式不同的是，只有当底层数据源是 JDBC 数据源时，才能使用这种形式。 SyncProvider 必须使用更新的 Connection 属性来重置 RowSetWriter 配置，以确保正确同步 CachedRowSet 对象的内容。

      当方法acceptChanges执行成功时，除了将更改写入数据源之外，它还使当前行中的值成为原始行中的值。

      根据所使用的 SyncProvider 实现的同步级别，编写器会将原始值与数据源中的值进行比较以检查是否存在冲突。当存在冲突时，RIOptimisticProvider 实现，例如，抛出一个 SyncProviderException 并且不向数据源写入任何内容。

      应用程序可以选择捕获 SyncProviderException 对象并检索它包含的 SyncResolver 对象。 SyncResolver 对象逐行列出冲突，并在数据源上设置锁以避免在解决当前冲突时进一步发生冲突。此外，对于每个冲突，它都提供了检查冲突和设置应保留在数据源中的值的方法。解决所有冲突后，应用程序必须再次调用 acceptChanges 方法以将已解决的值写入数据源。如果数据源中的所有值都已经是要持久化的值，则acceptChanges方法什么都不做。

      一些提供者实现可能使用锁来确保没有冲突。在这种情况下，可以保证编写器在调用方法 acceptChanges 时成功将更改写入数据源。该方法可以在 updateRow 、 insertRow 或 deleteRow 方法调用后立即调用，但在所有更改完成后只调用一次更高效，这样只需要建立一个连接。

      注意：acceptChanges() 方法将确定 COMMIT_ON_ACCEPT_CHANGES 是否设置为真。如果设置为true，则同步中的所有更新都提交到数据源。否则，申请必须根据需要显式调用 commit 或 rollback 方法。

      参数：
      con - 标准 JDBC Connection 对象
      抛出：
      SyncProviderException - 如果底层同步提供程序的编写器无法将更新写回数据源
      参见：

    • restoreOriginal

      void restoreOriginal() throws SQL异常
      将此 CachedRowSet 对象恢复为其原始值，即最后一组更改之前的值。如果行集没有更改或只有一组更改，则原始值是填充此 CachedRowSet 对象的值；否则，原始值是它在当前值之前的值。

      调用此方法时，CachedRowSet 实现必须确保对当前行集实例的所有更新、插入和删除都替换为以前的值。此外，光标应重置为第一行，并且应触发 rowSetChanged 事件以通知所有已注册的监听器。

      抛出：
      SQLException - 如果发生错误，将此 CachedRowSet 对象的当前值回滚到其先前值
      参见：

    • release

      void release() throws SQL异常
      释放此 CachedRowSet 对象的当前内容，并向所有已注册的监听器发送 rowSetChanged 事件。调用此方法后，所有未完成的更新都将被丢弃，并且行集不包含任何行。与底层数据源没有交互，任何行集内容、元数据和内容更新都应该是不可恢复的。

      这个 CachedRowSet 对象应该锁定，直到它的内容和关联的更新被完全清除，从而防止持有对这个 RowSet 对象的引用的其他组件的“脏”读取。此外，在读取此 CachedRowSet 对象的所有组件完成读取之前，无法释放内容。此 CachedRowSet 对象应在触发 rowSetChanged 事件后恢复正常行为。

      保留元数据（包括 JDBC 属性和同步 SPI 属性）以供将来使用。重要的是，command 属性等属性与最初建立此 CachedRowSet 对象的原始数据源相关。

      此方法清空行集，与 close 方法相反，后者将整个行集标记为可恢复，以允许垃圾收集器使用行集的 Java VM 资源。

      抛出：
      SQLException - 如果发生错误刷新此 CachedRowSet 对象的内容
      参见：

    • undoDelete

      void undoDelete() throws SQL异常
      取消删除当前行并通知监听某行已更改。调用该方法后，当前行不再被标记为删除。可以在行集的生命周期内随时调用此方法。

      此外，可以通过使用任何游标位置控制方法调整游标的位置来取消行删除的多个操作，例如：

      • CachedRowSet.absolute
      • CachedRowSet.first
      • CachedRowSet.last
      抛出：
      SQLException - 如果 (1) 当前行尚未删除或 (2) 光标位于插入行上、第一行之前或最后一行之后
      参见：

    • undoInsert

      void undoInsert() throws SQL异常
      如果已插入该行，则立即从此 CachedRowSet 对象中删除当前行，并通知监听器该行已更改。可以在行集的生命周期内随时调用此方法，并假设当前行在异常限制范围内（见下文），它会取消当前行的行插入。

      此外，可以通过使用任何游标位置控制方法调整游标的位置来多次取消行插入，例如：

      • CachedRowSet.absolute
      • CachedRowSet.first
      • CachedRowSet.last
      抛出：
      SQLException - 如果 (1) 当前行尚未插入或 (2) 光标位于第一行之前、最后一行之后或插入行上
      参见：

    • undoUpdate

      void undoUpdate() throws SQL异常
      如果行已被修改，则立即撤消上次更新操作。可以调用此方法来反转所有列的更新，直到一行中的所有更新都回滚到上次同步 (acceptChanges) 或填充之前的状态。在对插入行执行更新时也可以调用此方法。

      undoUpdate 可以在行集的生命周期内随时调用；但是，在发生同步后，此方法在对行集数据进行进一步修改之前无效。

      抛出：
      SQLException - 如果光标在此 CachedRowSet 对象中的第一行之前或最后一行之后
      参见：

    • columnUpdated

      boolean columnUpdated(int idx) throws SQL异常
      指示此 CachedRowSet 对象的当前行中的指定列是否已更新。
      参数：
      idx - 一个 int 标识要检查更新的列
      返回：
      true 如果指定的列已明显更新； false否则
      抛出：
      SQLException - 如果光标位于插入行上、第一行之前或最后一行之后
      参见：

    • columnUpdated

      boolean columnUpdated(String  columnName) throws SQL异常
      指示此 CachedRowSet 对象的当前行中的指定列是否已更新。
      参数：
      columnName - 一个 String 对象，给出要检查更新的列的名称
      返回：
      true 如果列已明显更新； false否则
      抛出：
      SQLException - 如果光标位于插入行上、第一行之前或最后一行之后
      参见：

    • toCollection

      Collection <?> toCollection() throws SQL异常
      将此 CachedRowSet 对象转换为包含此 CachedRowSet 对象的所有数据的 Collection 对象。由于 Collection 框架的抽象性质，实现在如何表示此 Collection 对象方面有一定的自由度。每行必须在通用 Collection 实现或专用 Collection 实现中完全表示，例如 TreeMap 对象或 Vector 对象。 SQL NULL 列值必须表示为 Java 编程语言中的 null。

      CachedRowSet 接口的标准参考实现使用 TreeMap 对象作为行集，每行中的值都包含在 Vector 对象中。预计大多数实现都会这样做。

      TreeMap 集合类型保证映射将按键升序排列，根据键类的自然顺序排序。每个键引用一个 Vector 对象，该对象对应于 RowSet 对象的一行。因此，每个 Vector 对象的大小必须正好等于 RowSet 对象中的列数。 TreeMap 集合使用的键由实现决定，它可以选择利用内部 RowSet 表格结构中可用的设置键，凭借已在 RowSet 对象本身或基础 SQL 数据上设置的键。

      返回：
      一个 Collection 对象，其中包含此 CachedRowSet 对象中每一行的值
      抛出：
      SQLException - 如果生成集合时发生错误
      参见：

    • toCollection

      Collection <?> toCollection(int column) throws SQL异常
      将此 CachedRowSet 对象中的指定列转换为 Collection 对象。由于 Collection 框架的抽象性质，实现在如何表示此 Collection 对象方面有一定的自由度。每个列值都应在通用 Collection 实现或专用 Collection 实现（例如 Vector 对象）中完全表示。 SQL NULL 列值必须表示为 Java 编程语言中的 null。

      标准参考实现使用 Vector 对象来包含列值，预计大多数实现都会这样做。如果使用 Vector 对象，它的大小必须正好等于该 CachedRowSet 对象中的行数。

      参数：
      column - 一个 int 指示其值将在 Collection 对象中表示的列
      返回：
      一个 Collection 对象，其中包含存储在此 CachedRowSet 对象的指定列中的值
      抛出：
      SQLException - 如果生成集合时发生错误或提供了无效的列 ID
      参见：

    • toCollection

      Collection <?> toCollection(String  column) throws SQL异常
      将此 CachedRowSet 对象中的指定列转换为 Collection 对象。由于 Collection 框架的抽象性质，实现在如何表示此 Collection 对象方面有一定的自由度。每个列值都应在通用 Collection 实现或专用 Collection 实现（例如 Vector 对象）中完全表示。 SQL NULL 列值必须表示为 Java 编程语言中的 null。

      标准参考实现使用 Vector 对象来包含列值，预计大多数实现都会这样做。如果使用 Vector 对象，它的大小必须正好等于该 CachedRowSet 对象中的行数。

      参数：
      column - 一个 String 对象，给出列的名称，其值将在集合中表示
      返回：
      一个 Collection 对象，其中包含存储在此 CachedRowSet 对象的指定列中的值
      抛出：
      SQLException - 如果生成集合时发生错误或提供了无效的列 ID
      参见：

    • getSyncProvider

      SyncProvider  getSyncProvider() throws SQL异常
      检索此 CachedRowSet 对象的 SyncProvider 实现。在内部，行集使用此方法触发行集和数据源之间的读取或写入操作。例如，行集可能需要从 SyncProvider 获取行集读取器（RowSetReader 对象）的句柄，以允许填充行集。 
         RowSetReader rowsetReader = null;
   SyncProvider provider =
     SyncFactory.getInstance("javax.sql.rowset.provider.RIOptimisticProvider");
     if (provider instanceof RIOptimisticProvider) {
       rowsetReader = provider.getRowSetReader();
     }
      假设行集阅读器是行集实现中的私有、可访问字段，当应用程序调用 execute 方法时，它又调用读取器的 readData 方法来填充 RowSet 对象。 
         rowsetReader.readData((RowSetInternal)this);

      此外，应用程序可以使用此方法返回的SyncProvider对象来调用返回有关SyncProvider对象信息的方法，包括有关供应商、版本、提供者标识、同步等级和当前已设置的锁的信息。

      返回：
      实例化行集时设置的 SyncProvider 对象，如果未设置，则为默认提供程序
      抛出：
      SQLException - 如果在返回 SyncProvider 对象时发生错误
      参见：

    • setSyncProvider

      void setSyncProvider(String  provider) throws SQL异常
      将此 CachedRowSet 对象的 SyncProvider 对象设置为指定的对象。此方法允许重置 SyncProvider 对象。

      CachedRowSet 实现应始终使用可用的 SyncProvider 机制进行实例化，但在某些情况下需要或需要重置 SyncProvider 对象。例如，应用程序可能希望使用默认的 SyncProvider 对象一段时间，然后选择使用最近可用且更适合其需求的提供程序。

      重置 SyncProvider 对象会导致 RowSet 对象从 SyncFactory 请求新的 SyncProvider 实现。这具有重置所有以前与原始数据源的连接和关系的效果，并且可能会彻底改变断开连接的行集的同步行为。

      参数：
      provider - 一个 String 对象，给出了 SyncProvider 实现的完全限定类名
      抛出：
      SQLException - 如果在尝试重置 SyncProvider 实现时发生错误
      参见：

    • size

      int size()
      返回此 CachedRowSet 对象中的行数。
      返回：
      行集中的行数

    • setMetaData

      void setMetaData(RowSetMetaData  md) throws SQL异常
      使用给定的 RowSetMetaData 对象设置此 CachedRowSet 对象的元数据。当 RowSetReader 对象读取行集的内容时，它会创建一个 RowSetMetaData 对象并使用 RowSetMetaData 实现中的方法对其进行初始化。参考实现使用 RowSetMetaDataImpl 类。当读取器完成读取行集内容时，将在内部调用此方法以将RowSetMetaData 对象传递给行集。
      参数：
      md - 一个 RowSetMetaData 对象，包含有关此 CachedRowSet 对象中列的元数据
      抛出：
      SQLException - 如果向行集提供了无效的元数据

    • getOriginal

      ResultSet  getOriginal() throws SQL异常
      返回包含此 CachedRowSet 对象的原始值的 ResultSet 对象。

      ResultSet 对象的光标应位于第一行之前。此外，返回的 ResultSet 对象应具有以下属性：

      • ResultSet.TYPE_SCROLL_INSENSITIVE
      • ResultSet.CONCUR_UPDATABLE

      RowSet 对象的原始值是它在上次与基础数据源同步之前的值。如果没有同步，则原始值将是填充 RowSet 对象的值。当应用程序调用方法 acceptChanges 并且已实现 SyncProvider 对象以检查冲突时，将在内部调用此方法。如果是这种情况，编写器会将原始值与数据源中当前的值进行比较，以检查是否存在冲突。

      返回：
      包含此 CachedRowSet 对象的原始值的 ResultSet 对象
      抛出：
      SQLException - 如果在生成 ResultSet 对象时发生错误

    • getOriginalRow

      ResultSet  getOriginalRow() throws SQL异常
      返回一个 ResultSet 对象，其中仅包含此 CachedRowSet 对象的当前行的原始值。

      ResultSet 对象的光标应位于第一行之前。此外，返回的 ResultSet 对象应具有以下属性：

      • ResultSet.TYPE_SCROLL_INSENSITIVE
      • ResultSet.CONCUR_UPDATABLE
      返回：
      该行的原始结果集
      抛出：
      SQLException - 如果没有当前行
      参见：

    • setOriginalRow

      void setOriginalRow() throws SQL异常
      将此 CachedRowSet 对象中的当前行设置为原始行。

      当当前行中的任何修改值与数据源同步后，内部将调用此方法。当前行必须标记为不再插入、删除或更新。

      对 setOriginalRow 的调用是不可逆的。

      抛出：
      SQLException - 如果没有当前行或重置原始行的内容时遇到错误
      参见：

    • getTableName

      String  getTableName() throws SQL异常
      返回用于创建此 CachedRowSet 对象的对象（表）的标识符。这个名称可以在多个场合设置，规范没有限制这可能发生的次数，也没有限制标准实现是否应该跟踪以前的表名。
      返回：
      一个 String 对象给出表的名称，该表是此 CachedRowSet 对象的数据源或 null 如果没有为表设置名称
      抛出：
      SQLException - 如果遇到错误返回表名
      参见：

    • setTableName

      void setTableName(String  tabName) throws SQL异常
      将派生此 CachedRowSet 对象的表的标识符设置为给定的表名。作者使用此名称来确定在同步尝试期间将数据源中的值与 CachedRowSet 对象的值进行比较时使用哪个表。表标识符还指示应将此 CachedRowSet 对象的修改值写入何处。

      此 CachedRowSet 对象的实现可以从 RowSetMetaDataImpl 对象内部获取名称。

      参数：
      tabName - 一个 String 对象，标识该 CachedRowSet 对象的派生表；不能是 null 但可以是空字符串
      抛出：
      SQLException - 如果在命名表时遇到错误或选项卡名称是null
      参见：

    • getKeyColumns

      int[] getKeyColumns() throws SQL异常
      返回一个包含一个或多个列号的数组，这些列号指示构成键的列，该键唯一标识此 CachedRowSet 对象中的一行。
      返回：
      包含一个或多个列号的数组，这些列号指示哪些列构成此 CachedRowSet 对象中一行的主键。如果没有列代表主键，则该数组应该为空。
      抛出：
      SQLException - 如果这个 CachedRowSet 对象是空的
      参见：

    • setKeyColumns

      void setKeyColumns(int[] keys) throws SQL异常
      使用给定的列号数组设置此 CachedRowSet 对象的 keyCols 字段，该字段构成用于唯一标识此 CachedRowSet 对象中的行的键。

      如果 CachedRowSet 对象成为 JoinRowSet 对象的一部分，如果指定为键列的列也成为匹配列，则将保留由此方法定义的键和生成的约束。

      参数：
      keys - int 的数组，指示构成此 CachedRowSet 对象的主键的列；数组中的每个元素都必须大于 0 且小于或等于此行集中的列数
      抛出：
      SQLException - 如果给定数组中的任何数字对此行集无效
      参见：

    • createShared

      RowSet  createShared() throws SQL异常
      返回由与此 CachedRowSet 对象相同的数据支持的新 RowSet 对象。实际上，两个 CachedRowSet 对象都有相同数据上的游标。因此，副本所做的任何更改对原始副本和任何其他副本都是可见的，就像原始副本所做的更改对其所有副本可见一样。如果重复项调用更改基础数据的方法，则它调用的方法会通知所有已注册的监听器，就像它被原始 CachedRowSet 对象调用时一样。

      此外，通过此方法创建的任何 RowSet 对象都将具有与此 CachedRowSet 对象相同的属性。例如，如果这个 CachedRowSet 对象是只读的，那么它的所有副本也将是只读的。如果将其更改为可更新，则副本也将变为可更新。

      注意：如果多个线程访问从 createShared() 方法创建的 RowSet 对象，则指定以下行为以保持共享数据的完整性：所有共享 RowSet 对象的读取和写入应在每个对象和单个底层表格结构之间连续进行。

      返回：
      一个新的共享 RowSet 对象，它与这个 CachedRowSet 对象具有相同的属性，并且在相同的数据上有一个游标
      抛出：
      SQLException - 如果发生错误或底层平台不支持克隆
      参见：

    • createCopy

      CachedRowSet  createCopy() throws SQL异常
      创建一个 RowSet 对象，它是此 CachedRowSet 对象中数据的深层副本。与从 createShared 调用生成的 RowSet 对象相反，对原始 RowSet 对象的副本所做的更新必须对原始 RowSet 对象不可见。此外，任何注册到原始 RowSet 的事件监听器的范围都不能超过新的 RowSet 副本。此外，必须维护建立的任何约束限制。
      返回：
      一个新的 RowSet 对象，它是此 CachedRowSet 对象的深层副本，并且完全独立于此 CachedRowSet 对象
      抛出：
      SQLException - 如果在生成此 CachedRowSet 对象的副本时发生错误
      参见：

    • createCopySchema

      CachedRowSet  createCopySchema() throws SQL异常
      创建一个 CachedRowSet 对象，它是此 CachedRowSet 对象的空副本。副本不得包含任何内容，而只能表示原始 CachedRowSet 对象的表结构。此外，原始 CachedRowSet 对象中设置的主键或外键约束必须在新的空 CachedRowSet 对象中同样强制执行。与从 createShared 方法调用生成的 RowSet 对象相比，使用 createCopySchema 方法对该 CachedRowSet 对象的副本所做的更新必须对其不可见。

      应用程序可以从此方法返回的 CachedRowSet 对象形成一个 WebRowSet 对象，以便将 RowSet 模式定义导出到 XML 以供将来使用。

      返回：
      此 CachedRowSet 对象的空副本
      抛出：
      SQLException - 如果在克隆此 CachedRowSet 对象的结构时发生错误
      参见：

    • createCopyNoConstraints

      CachedRowSet  createCopyNoConstraints() throws SQL异常
      创建一个 CachedRowSet 对象，它是此 CachedRowSet 对象数据的深层副本，但独立于它。与从 createShared 方法调用生成的 RowSet 对象相反，对此 CachedRowSet 对象的副本所做的更新必须对其不可见。此外，使用此 CachedRowSet 对象注册的任何事件监听器都不得具有新的 RowSet 对象的范围。此外，为这个 CachedRowSet 对象建立的任何约束限制必须not保存在副本中。
      返回：
      一个新的 CachedRowSet 对象，它是此 CachedRowSet 对象的深层副本，并且完全独立于此 CachedRowSet 对象
      抛出：
      SQLException - 如果在生成此 CachedRowSet 对象的副本时发生错误
      参见：

    • getRowSetWarnings

      RowSetWarning  getRowSetWarnings() throws SQL异常
      检索对此 RowSet 对象的调用报告的第一个警告。此 RowSet 对象的后续警告将链接到此方法返回的 RowSetWarning 对象。每次读取新行时都会自动清除警告链。不能在已关闭的 RowSet 对象上调用此方法；这样做会导致抛出 SQLException。
      返回：
      RowSetWarning 报告的第一个 RowSetWarning 对象，如果没有则为 null
      抛出：
      SQLException - 如果在关闭的 RowSet 上调用此方法
      参见：

    • getShowDeleted

      boolean getShowDeleted() throws SQL异常
      检索一个 boolean 指示标记为删除的行是否出现在当前行的集合中。如果返回 true，则删除的行与当前行一起可见。如果返回 false，则行对当前行集不可见。默认值为 false 。

      出于安全考虑或为了更好地适应某些部署场景，标准行集实现可能会选择限制此行为。这留作实现定义，并不代表标准行为。

      注意：允许删除的行保持可见会使某些标准 JDBC RowSet 实现方法的行为复杂化。然而，大多数行集用户可以简单地忽略这个额外的细节，因为只有非常专业的应用程序才可能想要利用这个特性。

      返回：
      true 如果删除的行可见； false否则
      抛出：
      SQLException - 如果行集实现无法确定标记为删除的行是否可见
      参见：

    • setShowDeleted

      void setShowDeleted(boolean b) throws SQL异常
      将属性 showDeleted 设置为给定的 boolean 值，该值确定标记为删除的行是否出现在当前行集中。如果该值设置为 true ，删除的行将立即与当前行集一起显示。如果该值设置为 false ，则删除的行将设置为对当前行集不可见。

      出于安全考虑或为了更好地适应某些部署场景，标准行集实现可能会选择限制此行为。这留作定义的实现，并不代表标准行为。

      参数：
      b - true 如果删除的行应该显示； false否则
      抛出：
      SQLException - 如果行集实现无法重置已删除的行是否应该可见
      参见：

    • commit

      void commit() throws SQL异常
      每个 CachedRowSet 对象的 SyncProvider 包含一个来自 ResultSet 或传递给它的构造函数的 JDBC 属性的 Connection 对象。此方法包装了 Connection 提交方法以允许灵活的自动提交或非自动提交事务控制支持。

      使自上次提交/回滚以来 acceptChanges() 方法执行的所有更改永久化。只有在禁用自动提交模式时才应使用此方法。

      抛出：
      SQLException - 如果发生数据库访问错误或此 CachedRowSet 中的此连接对象处于自动提交模式
      参见：

    • rollback

      void rollback() throws SQL异常
      每个 CachedRowSet 对象的 SyncProvider 包含一个来自原始 ResultSet 或传递给它的 JDBC 属性的 Connection 对象。

      撤消当前事务中所做的所有更改。只有在禁用自动提交模式时才应使用此方法。

      抛出：
      SQLException - 如果发生数据库访问错误或此 CachedRowSet 中的此连接对象处于自动提交模式。

    • rollback

      void rollback(Savepoint  s) throws SQL异常
      每个 CachedRowSet 对象的 SyncProvider 包含一个来自原始 ResultSet 或传递给它的 JDBC 属性的 Connection 对象。

      撤消当前事务中所做的所有更改回到最后一个 Savepoint 事务标记。只有在禁用自动提交模式时才应使用此方法。

      参数：
      s - 一个 Savepoint 交易标记
      抛出：
      SQLException - 如果发生数据库访问错误或此 CachedRowSet 中的此连接对象处于自动提交模式。

    • rowSetPopulated

      void rowSetPopulated(RowSetEvent  event, int numRows) throws SQL异常
      通知已注册的监听器，给定 RowSetEvent 对象中的 RowSet 对象已经填充了许多额外的行。 numRows 参数确保此事件只会在每个 numRow 时触发。

      可以使用方法 event.getSource 检索事件的来源。

      参数：
      event - 包含作为事件源的 RowSet 对象的 RowSetEvent 对象
      numRows - 填充时，CachedRowSet 填充应触发的行间隔数；默认值为零；不能小于 fetchSize 或零
      抛出：
      SQLException - numRows < 0 or numRows < getFetchSize()

    • populate

      void populate(ResultSet  rs, int startRow) throws SQL异常
      使用来自给定 ResultSet 对象的数据填充此 CachedRowSet 对象。虽然与 populate(ResultSet) 方法相关，但提供了一个附加参数以允许在 ResultSet 中的起始位置填充 CachedRowSet 实例。

      当应用程序连接到打开的 ResultSet 对象时，此方法可用作 execute 方法的替代方法。使用方法 populate 比使用不带参数的 execute 方法更有效，因为它不会打开新连接并重新执行此 CachedRowSet 对象的命令。与使用带有 ResultSet 对象的 execute 版本相比，使用 populate 方法更加方便。

      参数：
      rs - 包含要读入此 CachedRowSet 对象的数据的 ResultSet 对象
      startRow - ResultSet 中的位置，从这里开始填充此 CachedRowSet 中的记录
      抛出：
      SQLException - 如果提供了空的 ResultSet 对象或此 CachedRowSet 对象无法检索关联的 ResultSetMetaData 对象
      参见：

    • setPageSize

      void setPageSize(int size) throws SQL异常
      设置 CachedRowSet 对象的页面大小。 CachedRowSet 可以配置为在页面大小的行中填充自身。当调用 populate() 或 execute() 时，CachedRowSet 根据用于填充 RowSet 的原始 SQL 查询获取额外的页面。
      参数：
      size - CachedRowSet 的页面大小
      抛出：
      SQLException - 如果设置 CachedRowSet 页面大小时发生错误或页面大小小于 0。

    • getPageSize

      int getPageSize()
      返回 CachedRowSet 对象的页面大小
      返回：
      int 页面大小

    • nextPage

      boolean nextPage() throws SQL异常
      增加 CachedRowSet 的当前页面。这会导致 CachedRowSet 实现获取下一个页面大小的行并填充 RowSet，如果剩余的行仍在用于填充 RowSet 的原始 SQL 查询的范围内。
      返回：
      如果存在更多页面，则为真；如果这是最后一页则为 false
      抛出：
      SQLException - 如果获取下一页时出错，或者如果在填充或执行之前过早调用此方法。

    • previousPage

      boolean previousPage() throws SQL异常
      递减 CachedRowSet 的当前页。这会导致 CachedRowSet 实现获取先前页面大小的行并填充 RowSet。上一页中返回的行数必须始终保持在用于填充 RowSet 的原始 SQL 查询的范围内。
      返回：
      如果成功检索到上一页，则为 true；如果这是第一页，则为 false。
      抛出：
      SQLException - 如果获取上一页时发生错误，或者如果在填充或执行之前过早调用此方法。