前面的入门程序展示了如何从Result获取对象，然后进行对象的映射
这篇文章主要从下面的几个方面讲解：
ResultSet 接口从行检索出列值游标（Cursors）更新ResultSet 对象中行批量更新在ResultSet插入行
1.ResultSet 接口
ResultSet接口提供了检索和操作执行查询结果的方法，ResultSet对象可以具有不同的功能和特征。这些特性是类型、并发性和游标保持性。
-
ResultSet Types(结果集类型)
ResultSet对象的类型在两个方面决定了它的功能级别:游标操作的方式，以及对底层数据源的并发
ResultSet对象的灵敏度由三种不同的ResultSet类型之一决定:
TYPE_FORWARD_ONLY: 无法滚动结果集;它的光标仅向前移动，从第一行之前移动到最后一行之后TYPE_SCROLL_INSENSITIVE：滚动的结果集，光标可以向前移动或者向后移动到相对位置和绝对位置，结果集不敏感TYPE_SCROLL_SENSITIVE：滚动的结果集，光标可以向前移动或者向后移动到相对位置和绝对位置，结果集敏感
默认的结果集类型为： TYPE_FORWARD_ONLY，并不是所有的数据库都支持所有的结果集类型，如果调用 DatabaseMetaData.supportsResultSetType返回true则说明支持该结果集类型。
TYPE_SCROLL_INSENSITIVE和TYPE_SCROLL_SENSITIVE两者的区别:
TYPE_SCROLL_INSENSITIVE：当获取结果集的时候是缓存结果集到内存中，当调用next方法的时候直接从内存中获取
TYPE_SCROLL_SENSITIVE：对返回的结果集是敏感的，那么是不是意味着拿到结果集后，数据库中的数据变化都会反映到结果集中呢？不是这样的，这里此时拿到的结果集只是记录某种条件的的rowid
当调用next方法的时候，在根据rowid去数据库区查询。
在调用next方法之前对数据库进行了更新操作，此时调用next方法可以获取最新的数据
对于数据进行插入的数据，由于缓存的rowid并没有，所以不会查询出来。
但对于删除操作。因为数据库删除记录只是记录上做一个标记，不再被检索，但原来被缓存的ROWID还在，根据它还可以通过数据库自己的底层操作正确地把数据提取出来
-
ResultSet Concurrency(结果集并发性)
ResultSet对象的并发性决定了支持什么级别的更新功能。
有两种更新的级别
CONCUR_READ_ONLY: ResultSet结果集不能被更新CONCUR_UPDATABLE： ResultSet结果集可以被更新
默认的结果集并发性为CONCUR_READ_ONLY
并不是所有的数据库都支持所有的并发类型，可以用 DatabaseMetaData.supportsResultSetConcurrency()来检测是否支持哪种结果集并发类型，返回true,则说明支持
-
Cursor Holdability（游标保持性）
调用方法Connection.commit可以关闭在当前事务期间创建的ResultSet对象。然而，在某些情况下，这可能不是我们想要的行为。ResultSet属性的可保持性使应用程序能够控制在调用commit时ResultSet对象(游标)是否关闭。
下面有两种游标保持性
HOLD_CURSORS_OVER_COMMIT:当调用commit方法的时候，游标没有关闭，当继续保持。CLOSE_CURSORS_AT_COMMIT：调用commit方法的时候，游标关闭
并不是所有的数据库都支持游标的关闭和持有型。
下面给出一个具体的实例：
/**
* @Project: jdk
* @description: mysql的ResultSet测试
* @author: sunkang
* @create: 2018-10-14 14:33
* @ModificationHistory who when What
**/
public class ResultSetTest {
public static void main(String[] args) throws SQLException {
ResultSetTest resultSetTest = new ResultSetTest();
Connection con = resultSetTest.getDefalutConnection();
//验证mysql 支持哪些ResultSet类型
DatabaseMetaData dbMetaData = con.getMetaData();
System.out.println("Supports TYPE_FORWARD_ONLY? "+dbMetaData.supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY));
System.out.println("Supports TYPE_SCROLL_INSENSITIVE? "+dbMetaData.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));
System.out.println("Supports TYPE_SCROLL_SENSITIVE? "+dbMetaData.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));
/* 上面的输出结果为：
Supports TYPE_FORWARD_ONLY? false
Supports TYPE_SCROLL_INSENSITIVE? true
Supports TYPE_SCROLL_SENSITIVE? false
说明mysql支持类型为 TYPE_SCROLL_INSENSITIVE
*/
//验证mysql 支持哪些ResultSet并发性
System.out.println("Supports CONCUR_READ_ONLY? "+dbMetaData.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY));
System.out.println("Supports CONCUR_UPDATABLE? "+dbMetaData.supportsResultSetConcurrency(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE));
/* 上面的输出结果为：
Supports CONCUR_READ_ONLY? true
Supports CONCUR_UPDATABLE? true
说明mysql 可以在ResultSet对象更改结果集
*/
//验证mysql 支持哪些游标保持性
System.out.println("Supports HOLD_CURSORS_OVER_COMMIT? "+dbMetaData.supportsResultSetHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT));
System.out.println("Supports CLOSE_CURSORS_AT_COMMIT? "+dbMetaData.supportsResultSetHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT));
/**
* Supports HOLD_CURSORS_OVER_COMMIT? true
* Supports CLOSE_CURSORS_AT_COMMIT? false
* 说明mysql在commit提交之后，游标还是打开的
*/
//创建了一个类型为HOLD_CURSORS_OVER_COMMIT，并发性为：CONCUR_UPDATABLE，以及游标的保持性为：HOLD_CURSORS_OVER_COMMIT的语句集
Statement statement = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE,ResultSet.HOLD_CURSORS_OVER_COMMIT);
ResultSet resultSet = statement.executeQuery("SELECT * FROM user");
//设置连接的自动提交为false
con.setAutoCommit(false);
//更新user 的address统一后面加上：update语句
while (resultSet.next()) {
//address为大写和小写都是可以的
String address = resultSet.getString("address");
resultSet.updateString("address", address+":update");
//更新此行
resultSet.updateRow();
//在这里提交，游标还是打开的，所以不会有问题
con.commit();
}
//释放资源
resultSet.close();
statement.close();
con.close();
}
public Connection getDefalutConnection(){
Connection connection = null;
try {
//1.加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//2.通过驱动管理类获取数据库链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "123");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}
}
2.从行检索出列值
入门程序已经给出了，这里不再描述
可以根据索引来获取对应的列值，也可以根据列名获取列值，这里的列名可以使列的别名， 根据列名获取列的值的时候，这里输入名称可以大写也可以是小写
while(resultSet.next()){
User user = new User();
user.setId(resultSet.getInt("id"));
user.setUsername(resultSet.getString("username"));
user.setSex(resultSet.getString("sex"));
user.setBirthday(resultSet.getTimestamp("birthday"));
user.setAddress(resultSet.getString("address"));
userList.add(user);
}
3.cursors(游标)
你可以通过一个游标来访问ResultSet的内部数据，游标表示执行ResultSet的某一行，当ResultSet对象创建的时候，游标指向的是第一行的前一行，调用next方法，可以使游标向下移动，下面是移动游标的方法
next：移动游标执行下一行，当游标的执行的行存在数据的时候返回true,当游标执行最后一行的后面的时候返回false
previous: 将游标向上移动，该方法返回boolean型数据，当移到结果集第一行之前时，返回false。
beforeFirst: 将游标移动到结果集的初始位置，即在第一行之前。
afterLast: 将游标移到结果集最后一行之后。
first： 将游标移到结果集的第一行。
last： 将游标移到结果集的最后一行。
relative(int row):将游标移动到相对于当前位置的指定行
absolute(int row): 将游标移动到指定的行数
getRow(): 得到当前游标所指向行的行号，行号从1开始,依次类推
一般数据库默认的ResultSet的敏感类型为TYPE_FORWARD_ONLY，这集意味着游标不能滚动，除了调用next方法之外，其他的方法不可以进行调用，所以游标只能向下移动
4.更新ResultSet 对象中行
上面的mysql的ResultSet测试已经展示如何更新ResultSet中的行,更新ResultSet对象的行，需要数据库支持ResultSet并发性为CONCUR_UPDATABLE,不然是无法更新的
while (resultSet.next()) {
//address为大写和小写都是可以的
String address = resultSet.getString("address");
resultSet.updateString("address", address+":update");
//更新此行
resultSet.updateRow();
}
5.批量更新
下面展示的是一个数据库批量更新的例子
/**
* @Project: jdk
* @description: 批量更新
* @author: sunkang
* @create: 2018-10-14 15:46
* @ModificationHistory who when What
**/
public class BatchUpdateTest{
public static void main(String[] args) {
BatchUpdateTest batchUpdateTest = new BatchUpdateTest();
Connection con =batchUpdateTest.getDefalutConnection();
Statement statement = null;
try {
//默认的事务提交类型是自动提交，但是在这里需要设置自动提交类型为false,在出现错误的时候需要回滚
con.setAutoCommit(false);
statement = con.createStatement();
for(int i=0;i<10;i++){
String username = "sunkang"+ i;
statement.executeUpdate("insert user(username,birthday,sex,address) values ('"+username+"',NOW(),1,'hanghzou')");
}
//表示批量语句集返回的受影响的行数
int[] updateCounts = statement.executeBatch();
con.commit();
System.out.println(Arrays.toString(updateCounts));
} catch (SQLException e) {
//出现异常的时候回滚事务
try {
con.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally {
//关闭语句集
if(statement!=null){
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
try {
//设置回来
con.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public Connection getDefalutConnection(){
Connection connection = null;
try {
//1.加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//2.通过驱动管理类获取数据库链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "123");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}
}
上面程序展示的普通的statement 执行批量更新，如果是预编译的statement呢?下图展示了预编译的statement的批量更新
String sql = "insert user(username,birthday,sex,address) values (?,now(),?,?)";
PreparedStatement preparedStatement = con.prepareStatement(sql);
for(int i=10;i<12;i++){
String username = "sunkang"+ i;
preparedStatement.setString(1,username);
preparedStatement.setString(2,"1");
preparedStatement.setString(3,"hanghzou");
preparedStatement.addBatch();
}
preparedStatement.executeBatch();
con.commit();
6.在ResultSet插入行
并不是所有数据都支持在ResultSet执行插入的，前面的例子已经测试mysql支持结果集并发性为CONCUR_UPDATABLE
/**
* @Project: jdk
* @description: 插入的测试
* @author: sunkang
* @create: 2018-10-14 16:18
* @ModificationHistory who when What
**/
public class InsertRowByResultSet {
public static void main(String[] args) throws SQLException {
ResultSetTest resultSetTest = new ResultSetTest();
Connection con = resultSetTest.getDefalutConnection();
Statement statement = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql = "select * from user";
ResultSet resultSet = statement.executeQuery(sql);
//移动游标到插入的行
resultSet.moveToInsertRow();
//插入一行数据
resultSet.updateString("username","wangzhi");
resultSet.updateString("sex","1");
resultSet.updateTimestamp("birthday",new Timestamp(System.currentTimeMillis()));
resultSet.updateString("address","han");
//插入该条记录
resultSet.insertRow();
//游标移动到最开始的地方
resultSet.beforeFirst();
//释放资源
resultSet.close();
statement.close();
}
public Connection getDefalutConnection(){
Connection connection = null;
try {
//1.加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//2.通过驱动管理类获取数据库链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "123");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return connection;
}
}
