(5)修改和获取ResultSet的值

前面的入门程序展示了如何从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;
    }

}