JDBC （二）

1 使用JDBC进行批处理

• 当需要向数据库发送一批SQL语句的时候，应该避免向数据库一条条的发送执行，而应该采用JDBC的批处理机制，以提高执行效率。

• 实现批处理的方式一：
  • Statement.addBatch(sql)
  • 执行批处理SQL语句：
    • executeBatch()方法：执行批处理命令。
    • clearBatch()方法：清理批处理命令。
  • 优点：可以向数据库发送多条不同的SQL语句。
  • 缺点：
    • ①SQL语句没有预编译。
    • ②当向数据库发送多条SQL语句相同，但仅仅参数不同的SQL语句的时候，需要重复写很多条SQL语句。　

• 示例：实现批处理的方式一
  • SQL　　

CREATE TABLE `user` (
  `id` ) NOT NULL AUTO_INCREMENT,
  `name` ) DEFAULT NULL,
  `password` ) DEFAULT NULL,
  `email` ) DEFAULT NULL,
  `birthday` date DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE DEFAULT CHARSET=utf8;

• • jdbc.properties　　

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/jdbc
jdbc.user=root
jdbc.password=root

• • JDDCUtil.java　　

package util;

import java.io.FileInputStream;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;

/**
 * 2017/11/9
 * 说明：用来获取JDBC连接和释放资源的工具类
 */
public class JDBCUtil {
    private JDBCUtil(){}

    /**
     * 获取数据库的连接
     * @return
     * @throws IOException
     * @throws SQLException
     * @throws ClassNotFoundException
     */
    public static Connection getConnection() throws IOException, SQLException, ClassNotFoundException {
        Connection conn = null;
        //获取类路径下jdbc.properties的实际路径
        String jdbcPropertiesPath = JDBCUtil.class.getClassLoader().getResource("").getPath()+"jdbc.properties";
        //创建Properties对象
        Properties properties = new Properties();
        //将jdbc.properties文件加载进Properties对象
        properties.load(new FileInputStream(jdbcPropertiesPath));
        String driver = properties.getProperty("jdbc.driver");
        String url =  properties.getProperty("jdbc.url");
        String user = properties.getProperty("jdbc.user");
        String password = properties.getProperty("jdbc.password");

        //加载驱动
        Class.forName(driver);
        //获取连接
        conn = DriverManager.getConnection(url,user,password);
        return conn;
    }

    /**
     * 释放资源
     * @param conn
     * @param stmt
     * @param rs
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs){
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

}

• • DemoTest.java　　

package test;

import org.junit.jupiter.api.Test;
import util.JDBCUtil;

import java.sql.Connection;
import java.sql.Statement;
import java.util.Arrays;

/**
 * 2017/11/9
 * 说明：
 */
public class DemoTest {

    @Test
    public void demo1(){
        Connection conn = null;
        Statement stmt = null;
        try {
            conn = JDBCUtil.getConnection();
            stmt = conn.createStatement();
            stmt.addBatch("insert into user values (null,'hehe','hehe','hehe@qq.com','2012-05-12')");
            stmt.addBatch("delete from user where id = 5");
            int[] is = stmt.executeBatch();
            System.out.println(Arrays.toString(is));

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            JDBCUtil.close(conn,stmt,null);
        }

    }

}

• 实现批处理的方式二：
  • PreparedStatement.addBatch();
  • 需要注意内存问题。
  • 优点：发送的是预编译的SQL语句，执行效率高。
  • 缺点：只能应用在相同的SQL语句，但参数不同的批处理中，因此此种形式的批处理经常用于在同一个表中批量插入数据， 或批量更新表的数据。

package test;

import org.junit.jupiter.api.Test;
import util.JDBCUtil;

import java.sql.Connection;
import java.util.Date;
import java.sql.PreparedStatement;
import java.sql.Statement;
import java.util.Arrays;

/**
 * 2017/11/9
 * 说明：
 */
public class DemoTest {

    @Test
    public void demo2(){
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = JDBCUtil.getConnection();
            pstmt = conn.prepareStatement("insert into user VALUES (null,?,?,?,?)");
            for(int x =0;x<10000;x++){
               pstmt.setString(1,x+"name");
                pstmt.setString(2,x+"password");
                pstmt.setString(3,x+"email");
                pstmt.setDate(4,new java.sql.Date(new Date().getTime()));
                pstmt.addBatch();
                if(x % 1000 == 0){
                    pstmt.executeBatch();
                    pstmt.clearBatch();;
                }

            }
            pstmt.executeBatch();
            JDBCUtil.close(conn,pstmt,null);

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            JDBCUtil.close(conn,pstmt,null);
        }
    }

}

2 事务

2.1 事务的概述

• 事务：事务是指逻辑上的一组操作，组成这组操作的各个单元，要么全部成功，要么全部失败。

• 以MySQL为例：（默认情况下，MySQL的事务是默认开启的）
• 开启事务的命令：

start transaction

• 回滚事务：

rollback

• 提交事务：

commit

• JDBC使用事务：
• 当jdbc程序向数据库获得一个Connection对象的时候，默认情况下Connection对象会自动向数据库提交发送的SQL。如果想关闭这种默认的提交方式，让多条SQL在同一个事务中执行，可以使用下列的语句：
• 开启事务

void setAutoCommit(boolean autoCommit) throws SQLException

• 回滚事务

void rollback() throws SQLException

• 提交事务

void commit() throws SQLException

2.2 事务的特性（ACID）

• 原子性：处于事务中的多条语句是不可分割的。
• 一致性：事务必须使得数据库从一个一致性状态变换到另一个一致性状态。比如：：转账前，A+B=10000元；转账后，A+B=10000元。
• 隔离性：多线程并发，一个事务不能被其它线程中的事务所打扰。
• 持久性：事务一旦提交，就永久保存起来。

2.3 事务的隔离级别

• 多个线程开启各自的事务操作数据库中的数据的时候，数据库系统要负责隔离操作，以保证各个线程在获取数据时候的准确性。
• 如果不考虑事务的隔离性，那么可能会引起如下的问题：
  • ①脏读：一个线程中的事务读取了另一个线程中没有提交的数据。
  • ②不可重复读：一个线程中的事务读取了另一个线程中已经提交的update的数据。
  • ③虚读（幻读）：一个线程中的事务读取了另外一个线程中已经提交的insert的数据。　　
• 要避免上面的现象，可以通过更改事务的隔离级别来避免：
  • read uncommitted：脏读、不可重复读、虚读有可能发生。
  • read committed：避免脏读的发生，不可重复读和虚读有可能发生。
  • repeatable read：避免脏读和不可重复读的发生，虚读有可能发生。
  • serializable：避免脏读、不可重复读和虚读。　　
• 事务的隔离级别越大，效率越低。
• MySQL中查询当前的隔离级别：

select @@tx_isolation;

• MySQL中设置当前的事务的隔离级别：

set transaction isolation level 级别;

3 模拟百度分页显示效果

• https://github.com/xuweiweiwoaini/pagination.git