这篇博客深入探讨了JDBC的高级特性，包括如何管理事务，例如关闭自动提交、手动提交和回滚事务。此外，介绍了批量更新操作以提高性能，以及如何防止内存溢出。同时讲解了JDBC如何处理返回自动主键，特别是通过序列在Oracle中生成主键。最后，讨论了DAO模式在数据访问层的作用，以及如何封装对数据的访问和异常处理。
1.取消自动提交事务
* JDBC默认是自动提交事务的，即：每当执行一条DML操作后，就自动执行COMMIT
* 若希望执行控制事务，需要先取消自动提交事务，然后再控制事务。* 事务的控制是Connection管理的。
*/
conn = DBUtil.getConnection();
//取消自动提交事务
conn.setAutoCommit(false);
注意：在向连接池还连接的时候，要将提交改为自动
//用完连接之后 改回自动提交
conn.setAutoCommit(true);
2. 批量执行
*
* 当有大批量数据需要插入到数据库某张表时，影响插入性能的主要因素：
* 1.事务，一条DML执行一次事务的效率是很差的，可以考虑多条记录使用同一个事务
* 2.PreparedStatement的使用可以减少执行计划的生成 （每一条SQL语句都使用同一个执行计划）
* 3.减少网络调用，客户端一次发送一条SQL语句与一次发送多条SQL语句到数据库服务端的效率也是不一样的。
* 批量执行就是减少网络调用，大批量执行SQL语句时应当考虑使用批量执行操作。
/*2.1
* 在一个事务中插入1000条可以减少事务对表的实际写操作次数，提高效率
*/
conn.setAutoCommit(false);
String sql = " INSERT INTO userinfo_snow "
+ " (id,username,password,email,nickname,account) "
+ "VALUES "
+ "(?,?,'123456',?,?,10000) ";
ps = conn.prepareStatement(sql);
long start = System.currentTimeMillis();
for(int i=10000;i<20000;i++){
ps.setInt(1, i);
ps.setString(2, "test"+i);
ps.setString(3, "test"+i+"@qq.com");
ps.setString(4, "nickname"+i);
/*
* 执行executeUpdate方法，会将？对应的一组数据发送给数据库服务端，
* 那么调用10000次该方法就会发送10000次，增加了网络调用次数，会降低网络传输效率
*/
// ps.executeUpdate();
//添加到本地缓存中（添加到批中）
ps.addBatch();
}
//执行批操作（将缓存内容一次性发送给数据库执行）
int[] d = ps.executeBatch();//每一次批操作影响数据库的次数
System.out.println(d.length);
conn.commit();
long end = System.currentTimeMillis();
System.out.println("插入数据成功！耗时为："+(end-start)+"ms");
3. 自动返回主键
* 允许我们在插入一条信息的同时将该条数据中指定的字段返回。
* 通常返回的都是系统自动生成的值，例如主键值
* 使用Connection 带两个参数的方法生成PS，其中第二个参数是一个字符串数组，
* 数组中每一个字符串内容应当是需要知道插入后该条记录希望返回值的字段名。
*/
PreparedStatement ps = conn.prepareStatement(sql, columnNames);
//取出id
ResultSet rs = ps.getGeneratedKeys();
rs.next();
int id = rs.getInt(1);
userinfo.setId(id);
4. * DAO 数据连接对象
* DAO泛指一个层次的类，DAO层是在业务逻辑层与数据库之间的层次
* 作用：让业务逻辑对数据库的操作完全面向对象化，并且只对数据库的具体操作透明。
* 使得业务逻辑层的类只需要关注业务操作即可。
为了建立一个健壮的Java应用，需将所有对数据源的访问操作抽象封装在一个公共API中，需要：
- 建立一个接口，接口中定义了应用程序中将会用到的所有事务方法
- 建立接口的实现类，实现接口对应的所有方法，和数据库直接交互
在应用程序中，当需要和数据源交互时则使用DAO接口，不涉及任何数据库的具体操作。DAO通常包括：
1. 一个DAO工厂类；
2. 一个DAO接口；
3. 一个实现DAO接口的具体类；
4. 数据传递对象（实体对象（Entity）或值对象（Value Object，简称VO））.
1. JDBC高级编程
1.1. JDBC高级编程
1.1.1. 事务简介
事务（Transaction）：数据库中保证交易可靠的机制。JDBC支持数据库中的事务概念，并且在JDBC中，事务默认是自动提交的。
可能存在的问题：某些业务逻辑必须在一个事务中完成。如图-1所示。
图-1事务示意图
事务特性介绍：ACID
- 原子性（Atomicity）：事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行
- 一致性（Consistency）：事务在完成时，必须使所有的数据都保持一致状态
- 隔离性（Isolation）：由并发事务所作的修改必须与任何其它并发事务所作的修改隔离
- 持久性（Durability）：事务完成之后，它对于系统的影响是永久性的
事务是数据库的概念，JDBC支持事务，本质还是在数据库中实现的。
1.1.2. JDBC事务API
JDBC中和事务相关API：
- Connection.getAutoCommit() :获得当前事务的提交方式，默认为true
- Connection.setAutoCommit():设置事务的提交属性，参数是true：自动提交；false：不自动提交
- Connection.commit():提交事务
- Connection.rollback():回滚事务
1.1.3. JDBC标准事务编程模式
JDBC处理事务的通常模式：
- 先将事务的自动提交关闭；
- 执行事务中的若干SQL语句；
- 事务提交；SQL失败则回滚；
- 恢复JDBC的事务提交状态；释放资源。
- try{
- // 1.定义用于在事务中执行的SQL语句
- String sql1 = "update account set amount = amount - " + amount + " where id = '" + from + "'";
- String sql2 = "update account set amount = amount + " + amount + " where id = '" + to + "'";
- autoCommit = con.getAutoCommit(); // 2.获得自动提交状态
- con.setAutoCommit(false); // 3.关闭自动提交
- stmt.executeUpdate(sql1); // 4.执行SQL语句
- stmt.executeUpdate(sql2);
- con.commit(); // 5.提交
- con.setAutoCommit(autoCommit); // 6.将自动提交功能恢复到原来的状态
- //其他语句;
- }catch(SQLException e){
- conn.rollback();//异常时回滚
- }
1.2. 批量更新
1.2.1. 批量更新的优势
批处理：发送到数据库作为一个单元执行的一组更新语句。批处理降低了应用程序和数据库之间的网络调用，相比单个SQL语句的处理，批处理更为有效。
1.2.2. 批量更新API
- addBatch(String sql)
- Statement类的方法, 可以将多条sql语句添加Statement对象的SQL语句列表中
- addBatch()
- PreparedStatement类的方法, 可以将多条预编译的sql语句添加到PreparedStatement对象的SQL语句列表中
- executeBatch()
- 把Statement对象或PreparedStatement对象语句列表中的所有SQL语句发送给数据库进行处理
- clearBatch()
- 清空当前SQL语句列表
1.2.3. 防止OutOfMemory
如果PreparedStatement对象中的SQL列表包含过多的待处理SQL语句, 可能会产生OutOfMemory错误。所以需要及时处理SQL语句列表。
- for (inti = 0; i< 1000; i++) {
- sql = “insert into emp(empno, ename) values(emp_seq.nextval, 'name" + i + "'")";
- //将SQL语句加入到Batch中
- stmt.addBatch(sql);
- //根据需要设置及时处理的条件
- if (i % 500 == 0) {
- stmt.executeBatch(); //及时处理
- stmt.clearBatch(); //清空列表
- }
- }
- // 最后一次列表不足500条，处理
- stmt.executeBatch();
1.3. 返回自动主键
1.3.1. 关联数据插入
在主表/从表关联关系下，插入数据时需要保证数据完整性。关联数据插入时的流程：
图-2 关联数据插入流程
1.3.2. 通过序列产生主键（Oracle）
不同数据库的主键自增方式不同，在oracle中，建议主键通过序列获得。在SQL语句中，指定由哪个序列为表产生主键：
- String sql =
- “insert into dept (deptno, dname, loc) values(dept_seq.nextval,?,?)”；
如果仅仅是单表操作，不需要返回刚刚插入的主键值，但如果有关联关系的表操作，需要获得刚刚插入的主键值。
1.3.3. JDBC返回自动主键API
方法一：先通过序列的nextval获取序列的下一个值，再作为参数插入到主表和从表。
- //1.获得主键的SQL语句
- String sql = "select dept_seq.nextval as id from dual";
- //执行上条SQL语句，通过ResultSet获得主键值，省略
- //2.利用刚刚得到的主键值插入主表
- String sql1=“insert into dept(deptno, dname, loc) values(?,?,?)";
- //执行insert语句，省略
- //3.利用刚刚得到的主键值，作为外键插入从表
- String sql2 = “insert into emp(empno, ename, deptno) values(?,?,?)”;
- //执行insert语句，省略
这种方式操作简单，但需要额外多一次访问数据库，影响性能。
方法二（建议）：利用PreparedStatement的getGeneratedKeys方法获取自增类型的数据，性能良好，只要一次SQL交互。
- //1.插入主表SQL，使用序列作为主键
- sql = "insert into dept (deptno, dname, loc) values(dept_seq.nextval,?,?)";
- //2.定义stmt时，第二个参数是GeneratedKeys的主键的字段名列表，类型是字符串数组
- stmt = con.prepareStatement(sql, new String[] { "deptno" });
- //3.将占位符赋值
- stmt.setString(1, “Research”);
- stmt.setString(2, “beijing”);
- //4.执行插入主表的insert语句
- stmt.executeUpdate();
- //5.获得主键值
- rs = stmt.getGeneratedKeys();
- rs.next();
- intdeptno = rs.getInt(1);
- //6.将刚刚得到的主表主键值，作为外键插入到从表中。
- String sql2 = “insert into emp(empno, ename, deptno) values(?,?,?)”;
1.4. 分页查询
1.4.1. JDBC实现Oracle分页查询
利用数据库的分页SQL语句，实现在Java程序中数据表的分页。在Oracle中使用rownum，以获得分页结果集：
- String sql = "select * from (select rownumrn, empno, ename, job,mgr, hiredate, sal, comm, deptno from (select * from emp order by empno) ) where rn between ? and ?";
两个占位符分别是结果集的起点和终点，计算后，替代SQL中的占位符：
- int begin = (page - 1) * pageSize + 1;
- int end = begin + pageSize - 1;
其中：
- page:返回第几页
- pageSize：每页多少条
- stmt = con.prepareStatement(sql);
- stmt.setInt(1, begin);
- stmt.setInt(2, end);
- rs = stmt.executeQuery();
这种分页方式，每次只向数据库请求一页的数据量，内存压力小适合大数据量数据表。
另一种分页策略介绍：基于缓存的分页技术（也被称作假分页），一次性把数据全部取出来放在缓存中,根据用户要看的页数(page)和每页记录数(pageSize),计算把哪些数据输出显示，将可滚动结果集的指针移动到指定位置。
这种方式只访问数据库一次 , 第一次取数比较慢 , 以后每页都从缓存中取 , 比较快，比较适合小数据量 , 如果数据量大 , 对内存压力较大。
1.4.2. JDBC实现MySQL分页查询
不同数据库获取部分结果集的SQL是有区别的，在MySQL中的实现方式：
- select * from t limit begin，pageSize;
其中：
- begin: 从第几条开始显示
- pageSize:每页多少条
在Java程序中，MySQL和Oracle分页的方式，仅限于SQL语句不同。
2. DAO
DAO实现数据持久化（写到硬盘上）
设计程序原则：高内聚，低耦合
面向接口实现了低耦合
2.1. 什么是DAO（一张表对应一个DAO）
2.1.1. DAO封装对数据的访问
DAO (Data Access Object)：数据访问对象，是建立在数据库和业务层之间，封装所有对数据库的访问。
目的：数据访问逻辑和业务逻辑分开。（操作数据以面向对象的形式进行）
使业务逻辑对数据库的操作完全面向对象
图-3 DAO在多层结构中的位置
为了建立一个健壮的Java应用，需将所有对数据源的访问操作抽象封装在一个公共API中，需要：
- 建立一个接口，接口中定义了应用程序中将会用到的所有事务方法
- 建立接口的实现类，实现接口对应的所有方法，和数据库直接交互
在应用程序中，当需要和数据源交互时则使用DAO接口，不涉及任何数据库的具体操作。DAO通常包括：
1. 一个DAO工厂类；
2. 一个DAO接口；
3. 一个实现DAO接口的具体类；
4. 数据传递对象（实体对象（Entity）或值对象（Value Object，简称VO））.
2.1.2. 实体对象
DAO层需要定义对数据库中表的访问。
对象关系映射(ORM：Object/Relation Mapping)描述对象和数据表之间的映射，将Java程序中的对象对应到关系数据库的表中：
- 表和类对应
- 表中的字段和类的属性对应
- 记录和对象对应
2.2. 编写DAO
2.2.1. 查询方法
- public Account findById(Integer id) throws SQLException {
- Connection conn = getConnection();
- String sql = SELECT_BY_ID; //预先定义好的SQL查询语句
- PreparedStatementps = conn.prepareStatement(sql);
- ps.setInt(1, id);//传入参数
- ResultSetrs = ps.executeQuery();
- Account account = null;
- while(rs.next()){//处理结果集
- account = new Account();
- account.setId(rs.getInt("ACCOUNT_ID"));
- //设置account对象所有的属性，略 }
- return account;
- }
2.2.2. 更新方法
- publicboolean update(Account account) throws SQLException {
- Connection conn = getConnection();
- String sql = UPDATE_STATUS; //预先定义好的SQL语句
- PreparedStatementps = conn.prepareStatement(sql);
- ps.setInt(1,account.getId());//传入参数
- ps.setString(2, account.getStatus());
- int flag= ps.executeUpdate();
- return (flag>0 ? true : false);
- }
2.2.3. 异常处理机制
多层系统的异常处理原则：
- 谁抛出的异常，谁捕捉处理，因为只有异常抛出者，知道怎样捕捉处理异常；
- 尽量在当前层中捕捉处理抛出的异常，尽量不要抛出到上层接口；
- 尽量在每层中封装每层的异常类，这样可准确定位异常抛出的层；
- 如异常无法捕捉处理，则向上层接口抛出，直至抛给JVM，尽量避免；
1. JDBC高级编程
1.1. JDBC高级编程
1.1.1. 事务简介
事务（Transaction）：数据库中保证交易可靠的机制。JDBC支持数据库中的事务概念，并且在JDBC中，事务默认是自动提交的。
可能存在的问题：某些业务逻辑必须在一个事务中完成。如图-1所示。
图-1事务示意图
事务特性介绍：ACID
- 原子性（Atomicity）：事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行
- 一致性（Consistency）：事务在完成时，必须使所有的数据都保持一致状态
- 隔离性（Isolation）：由并发事务所作的修改必须与任何其它并发事务所作的修改隔离
- 持久性（Durability）：事务完成之后，它对于系统的影响是永久性的
事务是数据库的概念，JDBC支持事务，本质还是在数据库中实现的。
1.1.2. JDBC事务API
JDBC中和事务相关API：
- Connection.getAutoCommit() :获得当前事务的提交方式，默认为true
- Connection.setAutoCommit():设置事务的提交属性，参数是true：自动提交；false：不自动提交
- Connection.commit():提交事务
- Connection.rollback():回滚事务
1.1.3. JDBC标准事务编程模式
JDBC处理事务的通常模式：
- 先将事务的自动提交关闭；
- 执行事务中的若干SQL语句；
- 事务提交；SQL失败则回滚；
- 恢复JDBC的事务提交状态；释放资源。
- try{
- // 1.定义用于在事务中执行的SQL语句
- String sql1 = "update account set amount = amount - " + amount + " where id = '" + from + "'";
- String sql2 = "update account set amount = amount + " + amount + " where id = '" + to + "'";
- autoCommit = con.getAutoCommit(); // 2.获得自动提交状态
- con.setAutoCommit(false); // 3.关闭自动提交
- stmt.executeUpdate(sql1); // 4.执行SQL语句
- stmt.executeUpdate(sql2);
- con.commit(); // 5.提交
- con.setAutoCommit(autoCommit); // 6.将自动提交功能恢复到原来的状态
- //其他语句;
- }catch(SQLException e){
- conn.rollback();//异常时回滚
- }
1.2. 批量更新
1.2.1. 批量更新的优势
批处理：发送到数据库作为一个单元执行的一组更新语句。批处理降低了应用程序和数据库之间的网络调用，相比单个SQL语句的处理，批处理更为有效。
1.2.2. 批量更新API
- addBatch(String sql)
- Statement类的方法, 可以将多条sql语句添加Statement对象的SQL语句列表中
- addBatch()
- PreparedStatement类的方法, 可以将多条预编译的sql语句添加到PreparedStatement对象的SQL语句列表中
- executeBatch()
- 把Statement对象或PreparedStatement对象语句列表中的所有SQL语句发送给数据库进行处理
- clearBatch()
- 清空当前SQL语句列表
1.2.3. 防止OutOfMemory
如果PreparedStatement对象中的SQL列表包含过多的待处理SQL语句, 可能会产生OutOfMemory错误。所以需要及时处理SQL语句列表。
- for (inti = 0; i< 1000; i++) {
- sql = “insert into emp(empno, ename) values(emp_seq.nextval, 'name" + i + "'")";
- //将SQL语句加入到Batch中
- stmt.addBatch(sql);
- //根据需要设置及时处理的条件
- if (i % 500 == 0) {
- stmt.executeBatch(); //及时处理
- stmt.clearBatch(); //清空列表
- }
- }
- // 最后一次列表不足500条，处理
- stmt.executeBatch();
1.3. 返回自动主键
1.3.1. 关联数据插入
在主表/从表关联关系下，插入数据时需要保证数据完整性。关联数据插入时的流程：
图-2 关联数据插入流程
1.3.2. 通过序列产生主键（Oracle）
不同数据库的主键自增方式不同，在oracle中，建议主键通过序列获得。在SQL语句中，指定由哪个序列为表产生主键：
- String sql =
- “insert into dept (deptno, dname, loc) values(dept_seq.nextval,?,?)”；
如果仅仅是单表操作，不需要返回刚刚插入的主键值，但如果有关联关系的表操作，需要获得刚刚插入的主键值。
1.3.3. JDBC返回自动主键API
方法一：先通过序列的nextval获取序列的下一个值，再作为参数插入到主表和从表。
- //1.获得主键的SQL语句
- String sql = "select dept_seq.nextval as id from dual";
- //执行上条SQL语句，通过ResultSet获得主键值，省略
- //2.利用刚刚得到的主键值插入主表
- String sql1=“insert into dept(deptno, dname, loc) values(?,?,?)";
- //执行insert语句，省略
- //3.利用刚刚得到的主键值，作为外键插入从表
- String sql2 = “insert into emp(empno, ename, deptno) values(?,?,?)”;
- //执行insert语句，省略
这种方式操作简单，但需要额外多一次访问数据库，影响性能。
方法二（建议）：利用PreparedStatement的getGeneratedKeys方法获取自增类型的数据，性能良好，只要一次SQL交互。
- //1.插入主表SQL，使用序列作为主键
- sql = "insert into dept (deptno, dname, loc) values(dept_seq.nextval,?,?)";
- //2.定义stmt时，第二个参数是GeneratedKeys的主键的字段名列表，类型是字符串数组
- stmt = con.prepareStatement(sql, new String[] { "deptno" });
- //3.将占位符赋值
- stmt.setString(1, “Research”);
- stmt.setString(2, “beijing”);
- //4.执行插入主表的insert语句
- stmt.executeUpdate();
- //5.获得主键值
- rs = stmt.getGeneratedKeys();
- rs.next();
- intdeptno = rs.getInt(1);
- //6.将刚刚得到的主表主键值，作为外键插入到从表中。
- String sql2 = “insert into emp(empno, ename, deptno) values(?,?,?)”;
1.4. 分页查询
1.4.1. JDBC实现Oracle分页查询
利用数据库的分页SQL语句，实现在Java程序中数据表的分页。在Oracle中使用rownum，以获得分页结果集：
- String sql = "select * from (select rownumrn, empno, ename, job,mgr, hiredate, sal, comm, deptno from (select * from emp order by empno) ) where rn between ? and ?";
两个占位符分别是结果集的起点和终点，计算后，替代SQL中的占位符：
- int begin = (page - 1) * pageSize + 1;
- int end = begin + pageSize - 1;
其中：
- page:返回第几页
- pageSize：每页多少条
- stmt = con.prepareStatement(sql);
- stmt.setInt(1, begin);
- stmt.setInt(2, end);
- rs = stmt.executeQuery();
这种分页方式，每次只向数据库请求一页的数据量，内存压力小适合大数据量数据表。
另一种分页策略介绍：基于缓存的分页技术（也被称作假分页），一次性把数据全部取出来放在缓存中,根据用户要看的页数(page)和每页记录数(pageSize),计算把哪些数据输出显示，将可滚动结果集的指针移动到指定位置。
这种方式只访问数据库一次 , 第一次取数比较慢 , 以后每页都从缓存中取 , 比较快，比较适合小数据量 , 如果数据量大 , 对内存压力较大。
1.4.2. JDBC实现MySQL分页查询
不同数据库获取部分结果集的SQL是有区别的，在MySQL中的实现方式：
- select * from t limit begin，pageSize;
其中：
- begin: 从第几条开始显示
- pageSize:每页多少条
在Java程序中，MySQL和Oracle分页的方式，仅限于SQL语句不同。
2. DAO
DAO实现数据持久化（写到硬盘上）
设计程序原则：高内聚，低耦合
面向接口实现了低耦合
2.1. 什么是DAO（一张表对应一个DAO）
2.1.1. DAO封装对数据的访问
DAO (Data Access Object)：数据访问对象，是建立在数据库和业务层之间，封装所有对数据库的访问。
目的：数据访问逻辑和业务逻辑分开。（操作数据以面向对象的形式进行）
使业务逻辑对数据库的操作完全面向对象
图-3 DAO在多层结构中的位置
为了建立一个健壮的Java应用，需将所有对数据源的访问操作抽象封装在一个公共API中，需要：
- 建立一个接口，接口中定义了应用程序中将会用到的所有事务方法
- 建立接口的实现类，实现接口对应的所有方法，和数据库直接交互
在应用程序中，当需要和数据源交互时则使用DAO接口，不涉及任何数据库的具体操作。DAO通常包括：
1. 一个DAO工厂类；
2. 一个DAO接口；
3. 一个实现DAO接口的具体类；
4. 数据传递对象（实体对象（Entity）或值对象（Value Object，简称VO））.
2.1.2. 实体对象
DAO层需要定义对数据库中表的访问。
对象关系映射(ORM：Object/Relation Mapping)描述对象和数据表之间的映射，将Java程序中的对象对应到关系数据库的表中：
- 表和类对应
- 表中的字段和类的属性对应
- 记录和对象对应
2.2. 编写DAO
2.2.1. 查询方法
- public Account findById(Integer id) throws SQLException {
- Connection conn = getConnection();
- String sql = SELECT_BY_ID; //预先定义好的SQL查询语句
- PreparedStatementps = conn.prepareStatement(sql);
- ps.setInt(1, id);//传入参数
- ResultSetrs = ps.executeQuery();
- Account account = null;
- while(rs.next()){//处理结果集
- account = new Account();
- account.setId(rs.getInt("ACCOUNT_ID"));
- //设置account对象所有的属性，略 }
- return account;
- }
2.2.2. 更新方法
- publicboolean update(Account account) throws SQLException {
- Connection conn = getConnection();
- String sql = UPDATE_STATUS; //预先定义好的SQL语句
- PreparedStatementps = conn.prepareStatement(sql);
- ps.setInt(1,account.getId());//传入参数
- ps.setString(2, account.getStatus());
- int flag= ps.executeUpdate();
- return (flag>0 ? true : false);
- }
2.2.3. 异常处理机制
多层系统的异常处理原则：
- 谁抛出的异常，谁捕捉处理，因为只有异常抛出者，知道怎样捕捉处理异常；
- 尽量在当前层中捕捉处理抛出的异常，尽量不要抛出到上层接口；
- 尽量在每层中封装每层的异常类，这样可准确定位异常抛出的层；
- 如异常无法捕捉处理，则向上层接口抛出，直至抛给JVM，尽量避免；
扫一扫
608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
