JDBC

该文档是：JDBC的使用

博客连接：https://www.loveuluo.cn

日期：2020-11-26

1. JDBC概述

2. JDBC的本质

本质其实就是SUN公司把接口规范定制出来后，各大数据库厂家对这个接口进行实现！

模拟SUN公司：定制一套接口供各厂商去实现

模拟MYSQL厂商：实现JDBC(SUN公司定制的接口)

模拟Oracle厂商：实现JDBC(SUN公司定制的接口)

模拟SQLServer厂商：实现JDBC(SUN公司定制的接口)

模拟我们Java程序员该干什么！：不需要关心具体是哪个品牌的数据库，只需要面相JDBC接口写代码

结果：

优化上边的代码！！！！使用反射机制创建对象，可以将要数据写在配置文件当中！：

下面代码：JDBC jdbc = (JDBC)c.newInstance()为什么可以强转成JDBC？：

.class文件就是驱动文件(实现类)，如果删除就会报错:

驱动非常重要！

3. JDBC编程六步

3.1 编程五步案例

因为是插入语句，所以只有五步，第五步是处理查询的结果集，select语句才会用到（这个方式注册驱动并不常用）：

3.2 常用的JDBC注册驱动的方式

注册驱动的方法：

3.3 从配置文件中获取链接和注册驱动

3.4 查询案例（六步）

将这三个定义在try外边，因为如果定义在try里的话，finally里无法获取。

1~4步：

第五步.处理查询结果集：

这是查询结果集的样子，用他的next方法，当下一个有数据的时候会返回true，没有就返回false。

最后第六步释放资源，这里就不弄出来了。

4. 做一个JDBC工具类

因为存在大量重复代码，所以把获取连接和关闭的方法单独抽出来：

/**
 * JDBC工具类，简化JDBC编程
 */
public class DBUtil {
    private DBUtil(){ //因为是工具类 没必要创建对象 直接把构造方法私有
    }
    static {//因为注册驱动只需要执行一次就行了 ,所以用静态代码块
        ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");
        String drive = bundle.getString("drive"); //drive=com.mysql.jdbc.Driver
        try {
            Class.forName(drive);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    //弄一个方法可以获取连接对象
    /**
     *
     * @param url
     * @param user 用户名
     * @param password 密码
     * @return 返回一个cConnection连接镀锡
     * @throws SQLException
     */
    //因为外边有try catch所以异常可以丢出去
    public static Connection getConnection(String url,String user,String password) throws SQLException { 
        return DriverManager.getConnection(url, user, password);
    }
    /**
     * 关闭连接的方法
     * @param con 连接对象
     * @param sta
     * @param rs 结果集对象
     */
//这里写Statement比较通用，写Statement既可以传入PreparedStatement也可以传入Statement（PreparedStatement继承了Statement）
    public static void close(Connection con, Statement sta, ResultSet rs){
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (sta != null) {
            try {
                sta.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

5. 登录案例(SQL注入问题)(重要*)

用户表：

未优化版登录案例(使用Statement)：

​ 这个版本的登录案例存在SQL注入问题，如果按照以下图片输入用户名和密码，也同样会显示登陆成功。

该错误发生的原因，在sql语句上打上断点使用debug查看以下当前sql语句变成什么样了：

​ 这条语句的意思是 WHERE loginName=fdsa AND loginPwd=fdsa 或者 1=1，那么1=1肯定成立，所以会返回true。

代码：

优化后的登录案例(使用PreparedStatement)：

如何防止SQL注入问题：

解决SQL注入问题后的结果：

代码：

6. 对比Statement和PreparedStatement

• -Statement存在sql注入问题：PreparedStatement解决了SQL注入问题
• -Statement是编译一次执行一次。PreparedStatement是编译一次，可执行N次(因为每次预编译的时候语句都一样)，PreparedStatement效率高一些
• -PreparedStatement会在编译阶段做类型的安全检查，例如：

因为用的是setString方法，所以只能是String，而Statement就不会进行检查。

7. 什么情况下使用Statement

​ 业务方面要求必须支持SQL注入的时候。

​ Statement支持SQL注入，凡是业务方面要求需要进行sql语句拼接的，必须使用Statement。

例子：

​ PreparedStatement比如要给占位符？传入String的时候 会自动带上'值'，而Statement可以直接进行拼接，所以做升序降序功能的时候

需要用到Statement。因为如果是SELECT FROM XXX 'desc'语法是错误的,SELECT FROM XXX desc这样才正确。

代码：

8. 用PreparedStatement完成增删改

properties文件

drive=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/bjpowernode
user=root
password=123456

未优化的增删改案例：

public class ZengJiaTest01 {
    public static void main(String[] args) {
        //准备工作
        ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");//用资源获取器获取配置文件中的内容
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");
        Connection connection=null;
        PreparedStatement sta=null; //改为PreparedStatement解决SQL注入问题，它可以预编译SQL语句的框架
        ResultSet re=null;
        try {
            //1.获取连接和注册驱动(DBUtil自动完成了注册驱动的步骤)
            connection = DBUtil.getConnection(url, user, password);
            //2.获取预编译的数据库操作对象
            //sql语句的框子。其中一个？代表一个占位符，一个？将来接受一个‘值’，注意：占位符不能使用单引号括起来
            String sql="INSERT INTO dept(deptno,dname,loc) VALUES(?,?,?)";//sql语句
            //程序执行到此处，会发送sql语句框子给DBMS进行sql语句的预先编译
            sta = connection.prepareStatement(sql);//调用prepareStatement方法得到PreparedStatement对象并且预编译
            //给占位符？传值(第1个问号的下标是1，第2个问号的下标是2，JDBC中所有下标从1开始。)
            sta.setInt(1,50);
            sta.setString(2,"销售部");
            sta.setString(3,"伤害");
            //3.执行sql语句
            int count = sta.executeUpdate();//返回增加的条数
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtil.close(connection,sta,re);//传入连接对象，数据库操作对象，结果集对象进行关闭
        }
    }
}

优化后的增删改案例(抽出增删改为一个方法)：

public class YouHuaZengJiaTest01 {

    public static void main(String[] args) {
        String sql = "INSERT INTO dept(deptno,dname,loc) VALUES(?,?,?)";
        int count = update(sql, 50, "帅哥部", "台州");
        System.out.println("成功修改 ："+count+"条数据");
    }

    //通用的增、删、改方法 (1,可以增、删、改；2,也可以针对于不同的表使用)
    //需要传入sql语句，和参数(参数的数量可能不同，所以使用可变参数，因为不知道可能接收到什么参数，所以用Object)
    public static int update(String sql,Object... objects){
        //准备工作
        ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");
        Connection connection=null;
        PreparedStatement sta=null;
        int count = 0 ;//在外边定义好需要返回的增删改的条数
        try {
            //1.获取连接和注册驱动(DBUtil自动完成了注册驱动的步骤)
            connection = DBUtil.getConnection(url, user, password);
            //2.获取预编译的数据库操作对象
            sta = connection.prepareStatement(sql);
            //3.填充占位符
            //因为参数的数量就是可变参数objects数组的长度，所以使用循环给?占位符传参
            for (int i = 0; i < objects.length; i++) {
                sta.setObject(i+1,objects[i]);//因为传占位符是从1开始，所以得+1
            }

            //3.执行sql语句
            count = sta.executeUpdate();//返回增加的条数
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            DBUtil.close(connection,sta,null);//传入连接对象，数据库操作对象，结果集对象进行关闭
        }
        return count; //返回增删改的条数
    }
}

9 ResultSet与ResultSetMetaData

9.1 ResultSet

• 查询需要调用PreparedStatement 的 executeQuery() 方法，查询结果是一个ResultSet 对象
• ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现
• ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
• ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator对象的 hasNext() 和 next() 方法的结合体。

• 当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。

  • 例如: getInt(1), getString("name")
  • 注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。

• ResultSet 接口的常用方法：

  • boolean next()
  • getString()
  • …

9.2 ResultSetMetaData

• 可用于获取关于 ResultSet 对象中列的类型和属性信息的对象

• ResultSetMetaData meta = rs.getMetaData();

  • getColumnName(int column)：获取指定列的名称
  • getColumnLabel(int column)：获取指定列的别名
  • getColumnCount()：返回当前 ResultSet 对象中的列数。
  • getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
  • getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。
  • isNullable(int column)：指示指定列中的值是否可以为 null。
  • isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。

问题1：得到结果集后, 如何知道该结果集中有哪些列 ？ 列名是什么？

​ 需要使用一个描述 ResultSet 的对象， 即 ResultSetMetaData

问题2：关于ResultSetMetaData

1. 如何获取 ResultSetMetaData： 调用 ResultSet 的 getMetaData() 方法即可
2. 获取 ResultSet 中有多少列：调用 ResultSetMetaData 的 getColumnCount() 方法
3. 获取 ResultSet 每一列的列的别名是什么：调用 ResultSetMetaData 的getColumnLabel() 方法

10. 改良版的PreparedStatement查询

10.1 优化版本1：

需要先创建对应列名的类：

public class Deptno {
    private int deptno;
    private String dname;
    private String loc;
}

返回一条数据相同的表的时候的通用查询 表的字段名和对应的类的属性名相同。(两个技术：结果集元数据，反射)

//对dept(部门表)单条数据查询的通用方法(因为每个表的结构有对应的类，所以这个方法只是对部门表通用)
public Deptno selectOneFromDeptno (String sql,Object... objects){
    //准备工作
    ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");//用资源获取器获取配置文件中的内容
    String url = bundle.getString("url");
    String user = bundle.getString("user");
    String password = bundle.getString("password");
    Connection connection = null;
    PreparedStatement sta = null;
    ResultSet re = null;
    try {
        //1.获取连接和注册驱动(DBUtil自动完成了注册驱动的步骤)
        connection = DBUtil.getConnection(url, user, password);
        //2.获取预编译的数据库操作对象
        sta = connection.prepareStatement(sql);//调用prepareStatement方法得到PreparedStatement对象并且预编译
        //3. 给占位符？传值
        for (int i = 0; i < objects.length; i++) {
            sta.setObject(i+1,objects[i]);
        }
        //4.执行sql语句
        re = sta.executeQuery();

        //5.处理结果集(关键点)
        // 获取结果集的元数据(修饰现有数据的数据) String name = "Tom"核心数据是Tom，那么String和name一定程度上都是来修饰Tom，是Tom的两个元数据
        ResultSetMetaData rsmd = re.getMetaData();
        // 从元数据中获取有几列，那么可以获得对应要取多少个值。
        int columnCount = rsmd.getColumnCount();

        if (re.next()) {//如果有下一个
            //创建deptno对象
            Deptno deptno=new Deptno();
            // 处理结果集一行数据中的每一个列
            for (int i = 0; i < columnCount; i++) { //遍历每一列
                Object columnValue = re.getObject(i + 1);// 获取列值

                // 将一个结果集封装到 对应的Deptno类中，因为不知道查询几条，可能是1条可能是2条，所以没法使用构造方法构造对象
                // 而你也不知道参数的具体名字是什么，也不能使用 get set，这时候只能使用反射来给对象的属性赋值

                String columnName = rsmd.getColumnName(i + 1);// 获取每个列的列名
                // 给deptno对象指定的columnName(列名),赋值为columnValue(列值)，通过反射
                Field declaredField = Deptno.class.getDeclaredField(columnName); //通过反射传入列名(对应类的每个属性)获取Field对象
                declaredField.setAccessible(true);//设置后可以访问私有的
                declaredField.set(deptno,columnValue); //给deptno这个对象的这个Field属性设置columnValue值
            }
            return deptno; //封装成为对象后返回
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } finally {
        DBUtil.close(connection, sta, re);//传入连接对象，数据库操作对象，结果集对象进行关闭
    }
    return null;
}

10.2 优化版本2：

流程：

数据库的表：

创建一个类，不一定要属性和列名对上：

public class Deptno {
    private int no;
    private String name;
    private String dizhi;
 }

返回一条数据相同的表的时候的通用查询(封装成对象返回)，可以针对于表的字段名与类的属性名不同的情况。(两个技术：结果集元数据，反射)

/*
 * 针对于表的字段名与类的属性名不相同的情况：(例如数据库表的列名是dname 而类中是name)
 * 1. 必须声明sql时，使用类的属性名来命名字段的别名
 * 2. 使用ResultSetMetaData时，需要使用getColumnLabel()来替换getColumnName(),获取列的别名。
 *  说明：如果sql中没有给字段其别名，getColumnLabel()获取的就是列名
 */
//通过在sql语句查询的时候给列起一个别名达到和类属性名字一致的操作进行 单条数据查询
public static Deptno selectOneFromDeptno2 (String sql,Object... objects){
    //准备工作
    ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");//用资源获取器获取配置文件中的内容
    String url = bundle.getString("url");
    String user = bundle.getString("user");
    String password = bundle.getString("password");
    Connection connection = null;
    PreparedStatement sta = null;
    ResultSet re = null;
    try {
        //1.获取连接和注册驱动(DBUtil自动完成了注册驱动的步骤)
        connection = DBUtil.getConnection(url, user, password);
        //2.获取预编译的数据库操作对象
        sta = connection.prepareStatement(sql);//调用prepareStatement方法得到PreparedStatement对象并且预编译
        //3. 给占位符？传值
        for (int i = 0; i < objects.length; i++) {
            sta.setObject(i+1,objects[i]);
        }
        //4.执行sql语句
        re = sta.executeQuery();

        //5.处理结果集(关键点)
        // 获取结果集的元数据(修饰现有数据的数据) String name = "Tom"核心数据是Tom，那么String和name一定程度上都是来修饰Tom，是Tom的两个元数据
        ResultSetMetaData rsmd = re.getMetaData();
        // 从元数据中获取有几列，那么可以获得对应要取多少个值。
        int columnCount = rsmd.getColumnCount();

        if (re.next()) {//如果有下一个
            //创建deptno对象
            Deptno deptno=new Deptno();
            // 处理结果集一行数据中的每一个列
            for (int i = 0; i < columnCount; i++) { //遍历每一列
                Object columnValue = re.getObject(i + 1);// 获取列值

                // 将一个结果集封装到 对应的Deptno类中，因为不知道查询几条，可能是1条可能是2条，所以没法使用构造方法构造对象
                // 而你也不知道参数的具体名字是什么，也不能使用 get set，这时候只能使用反射来给对象的属性赋值

                //获取列的列名：getColumnName() --不推荐使用
                //获取列的别名：getColumnLabel() 
                //  String columnName = rsmd.getColumnName(i + 1);
                String columnLabel = rsmd.getColumnLabel(i + 1);
                // 给deptno对象指定的columnLabel(列别名),赋值为columnValue(列值)，通过反射
                Field declaredField = Deptno.class.getDeclaredField(columnLabel); //通过反射传入列别名(对应类的每个属性)获取Field对象
                declaredField.setAccessible(true);//设置后可以访问私有的
                declaredField.set(deptno,columnValue); //给deptno这个对象的这个Field属性设置columnValue值
            }
            return deptno; //封装成为对象后返回
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } finally {
        DBUtil.close(connection, sta, re);//传入连接对象，数据库操作对象，结果集对象进行关闭
    }
    return null;
}

10.3 优化版本3：

参数里增加了一个Class<T> clazz，可以传入对应表结构的类，成功实现针对于不同的表的通用的查询操作，返回表中的一条记录(封装成对象返回)。

/**
     * 
     * @Description 针对于不同的表的通用的查询操作，把表中的数据封装成对象并返回一条。
     * @param clazz
     * @param sql
     * @param args
     * @return
     */
    //<T> t表示返回的类型是泛型，可以是各种类。 Class<T> 表示可以传入任何类的字节码文件。
    public <T> T getInstance(Class<T> clazz,String sql, Object... args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection(); //JDBCUtils已经做好了getConnection(url, user, password);操作 直接获得连接对象

            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            // 获取结果集的元数据 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通过ResultSetMetaData获取结果集中的列数
            int columnCount = rsmd.getColumnCount();

            if (rs.next()) {
                T t = clazz.newInstance();
                // 处理结果集一行数据中的每一个列
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columValue = rs.getObject(i + 1);

                    // 获取每个列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    // 给t对象指定的columnName属性，赋值为columValue：通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(conn, ps, rs);

        }

        return null;
    }

}

10.4 最终版本：

成功实现针对于不同的表的通用的查询操作，将多条数据封装成为多个对象，再将多个对象封装到集合中并且返回。

数据库表：

测试代码中传入的类是：

public class Deptno {
    private int no;
    private String name;
    private String dizhi;
 }

查询结果：

代码：

public class ChaXunZui最终版Test01 {
    @Test
    public void testGetForList(){
        String sql = "SELECT deptno,dname,loc FROM dept WHERE deptno < ?";
        List<Deptno> forList = getForList(Deptno.class, sql, 50);
        for (Deptno deptno : forList) {
            System.out.println(deptno);
        }
    }

    /**
     * @Description 针对于不同的表的通用的查询操作，将表中的多条记录并封装成对象放入集合中并返回
     * @param clazz
     * @param sql
     * @param args
     * @param <T>
     * @return
     */
    //<T> t表示返回的类型是泛型，可以是各种类。 Class<T> 表示可以传入任何类的字节码文件。
    public <T> List<T> getForList(Class<T> clazz, String sql, Object... args){
        ResourceBundle bundle = ResourceBundle.getBundle("JDBC.jdbc");//用资源获取器获取配置文件中的内容（可以省去properties）
        String url = bundle.getString("url");
        String user = bundle.getString("user");
        String password = bundle.getString("password");
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DBUtil.getConnection(url,user,password);

            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }

            rs = ps.executeQuery();
            // 获取结果集的元数据 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通过ResultSetMetaData获取结果集中的列数
            int columnCount = rsmd.getColumnCount();
            //创建集合对象
            ArrayList<T> list = new ArrayList<T>();
            while (rs.next()) {
                T t = clazz.newInstance();
                // 处理结果集一行数据中的每一个列:给t对象指定的属性赋值
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columValue = rs.getObject(i + 1);

                    // 获取每个列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);

                    // 给t对象指定的columnName属性，赋值为columValue：通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                list.add(t); //把对象加入集合中
            }
            return list; //返回集合
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            DBUtil.close(conn, ps, rs);
        }
        return null;
    }
}

11. 操作BLOB类型字段

11.1 MySQL BLOB类型

• MySQL中，BLOB是一个二进制大型对象，是一个可以存储大量数据的容器，它能容纳不同大小的数据。
• 插入BLOB类型的数据必须使用PreparedStatement，因为BLOB类型的数据无法使用字符串拼接写的。
• MySQL的四种BLOB类型(除了在存储的最大信息量上不同外，他们是等同的)

• 实际使用中根据需要存入的数据大小定义不同的BLOB类型。
• 需要注意的是：如果存储的文件过大，数据库的性能会下降。
• 如果在指定了相关的Blob类型以后，还报错：xxx too large，那么在mysql的安装目录下，找my.ini文件加上如下的配置参数： max_allowed_packet=16M。同时注意：修改了my.ini文件之后，需要重新启动mysql服务。

11.2 向数据表中插入大数据类型

//获取连接
Connection conn = JDBCUtils.getConnection();
        
String sql = "insert into customers(name,email,birth,photo)values(?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);

// 填充占位符
ps.setString(1, "徐海强");
ps.setString(2, "xhq@126.com");
ps.setDate(3, new Date(new java.util.Date().getTime()));
// 操作Blob类型的变量
FileInputStream fis = new FileInputStream("xhq.png");
ps.setBlob(4, fis);
//执行
ps.execute();
        
fis.close();
JDBCUtils.closeResource(conn, ps);

11.3 修改数据表中的Blob类型字段

Connection conn = JDBCUtils.getConnection();
String sql = "update customers set photo = ? where id = ?";
PreparedStatement ps = conn.prepareStatement(sql);

// 填充占位符
// 操作Blob类型的变量
FileInputStream fis = new FileInputStream("coffee.png");
ps.setBlob(1, fis);
ps.setInt(2, 25);

ps.execute();

fis.close();
JDBCUtils.closeResource(conn, ps);

11.4 从数据表中读取大数据类型

String sql = "SELECT id, name, email, birth, photo FROM customer WHERE id = ?";
conn = getConnection();
ps = conn.prepareStatement(sql);
ps.setInt(1, 8);
rs = ps.executeQuery();
if(rs.next()){
    Integer id = rs.getInt(1);
    String name = rs.getString(2);
    String email = rs.getString(3);
    Date birth = rs.getDate(4);
    Customer cust = new Customer(id, name, email, birth);
    System.out.println(cust); 
    //读取Blob类型的字段
    Blob photo = rs.getBlob(5);
    InputStream is = photo.getBinaryStream();
    OutputStream os = new FileOutputStream("c.jpg");
    byte [] buffer = new byte[1024];
    int len = 0;
    while((len = is.read(buffer)) != -1){
        os.write(buffer, 0, len);
    }
    JDBCUtils.closeResource(conn, ps, rs);
        
    if(is != null){
        is.close();
    }
        
    if(os !=  null){
        os.close();
    }
    
}

12. 批量插入

12.1 批量执行SQL语句

当需要成批插入或者更新记录时，可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率

JDBC的批量处理语句包括下面三个方法：

• addBatch(String)：添加需要批量处理的SQL语句或是参数；
• executeBatch()：执行批量处理语句；
• clearBatch():清空缓存的数据

通常我们会遇到两种批量执行SQL语句的情况：

• 多条SQL语句的批量处理；
• 一个SQL语句的批量传参；

12.2 高效的批量插入

举例：向数据表中插入20000条数据

• 数据库中提供一个goods表。创建如下：

CREATE TABLE goods(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(20)
);

12.2.1 实现层次一：使用Statement

Connection conn = JDBCUtils.getConnection();
Statement st = conn.createStatement();
for(int i = 1;i <= 20000;i++){
    String sql = "insert into goods(name) values('name_' + "+ i +")";
    st.executeUpdate(sql);
}

12.2.2 实现层次二：使用PreparedStatement

long start = System.currentTimeMillis();
        
Connection conn = JDBCUtils.getConnection();
        
String sql = "insert into goods(name)values(?)";
PreparedStatement ps = conn.prepareStatement(sql);
for(int i = 1;i <= 20000;i++){
    ps.setString(1, "name_" + i);
    ps.executeUpdate();
}
        
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));//82340
        
        
JDBCUtils.closeResource(conn, ps);

12.2.3 实现层次三

/*
 * 修改1： 使用 addBatch() / executeBatch() / clearBatch()
 * 修改2：mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
 *          ?rewriteBatchedStatements=true 写在配置文件的url后面
 * 修改3：使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar
 * 
 */
@Test
public void testInsert1() throws Exception{
    long start = System.currentTimeMillis();
        
    Connection conn = JDBCUtils.getConnection();
        
    String sql = "insert into goods(name)values(?)";
    PreparedStatement ps = conn.prepareStatement(sql);
        
    for(int i = 1;i <= 1000000;i++){
        ps.setString(1, "name_" + i);
            
        //1.“攒”sql
        ps.addBatch();
        if(i % 500 == 0){
            //2.执行
            ps.executeBatch();
            //3.清空
            ps.clearBatch();
        }
    }
        
    long end = System.currentTimeMillis();
    System.out.println("花费的时间为：" + (end - start));//20000条：625                                                                         //1000000条:14733  
        
    JDBCUtils.closeResource(conn, ps);
}

12.2.4 实现层次四

/*
* 层次四：在层次三的基础上操作
* 使用Connection 的 setAutoCommit(false)  /  commit()
*/
@Test
public void testInsert2() throws Exception{
    long start = System.currentTimeMillis();
        
    Connection conn = JDBCUtils.getConnection();
        
    //1.设置为不自动提交数据
    conn.setAutoCommit(false);
        
    String sql = "insert into goods(name)values(?)";
    PreparedStatement ps = conn.prepareStatement(sql);
        
    for(int i = 1;i <= 1000000;i++){
        ps.setString(1, "name_" + i);
            
        //1.“攒”sql
        ps.addBatch();
            
        if(i % 500 == 0){
            //2.执行
            ps.executeBatch();
            //3.清空
            ps.clearBatch();
        }
    }
        
    //2.提交数据
    conn.commit();
        
    long end = System.currentTimeMillis();
    System.out.println("花费的时间为：" + (end - start));//1000000条:4978 
        
    JDBCUtils.closeResource(conn, ps);
}

13. 数据库事务

13.1 数据库事务介绍

• 事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
• 事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
• 为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。

13.2 JDBC事务处理

• 数据一旦提交，就不可回滚。

• 数据什么时候意味着提交？

  • 当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个 SQL 语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
  • 关闭数据库连接，数据就会自动的提交。如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。即同一个事务的多个操作必须在同一个连接下。

• JDBC程序中为了让多个 SQL 语句作为一个事务执行：

  • 调用 Connection 对象的 setAutoCommit(false); 以取消自动提交事务
  • 在所有的 SQL 语句都成功执行后，调用 commit(); 方法提交事务
  • 在出现异常时，调用 rollback(); 方法回滚事务

若此时 Connection 没有被关闭，还可能被重复使用，则需要恢复其自动提交状态 setAutoCommit(true)。尤其是在使用数据库连接池技术时，执行close()方法前，建议恢复自动提交状态。

【案例：用户AA向用户BB转账100】

public void testJDBCTransaction() {
    Connection conn = null;
    try {
        // 1.获取数据库连接
        conn = JDBCUtils.getConnection(); //JDBCUtils中已经做好资源绑定等事可以直接获得连接
        // 2.开启事务
        conn.setAutoCommit(false);
        // 3.进行数据库操作
        String sql1 = "update user_table set balance = balance - 100 where user = ?";
        update(conn, sql1, "AA");

        // 模拟网络异常
        //System.out.println(10 / 0);

        String sql2 = "update user_table set balance = balance + 100 where user = ?";
        update(conn, sql2, "BB");
        // 4.若没有异常，则提交事务
        conn.commit();
    } catch (Exception e) {
        e.printStackTrace();
        // 5.若有异常，则回滚事务
        try {
            conn.rollback();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }
    } finally {
        try {
            //6.恢复每次DML操作的自动提交功能
            conn.setAutoCommit(true);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        //7.关闭连接
        JDBCUtils.closeResource(conn, null, null); 
    }  
}

其中，对数据库操作的方法为：

//使用事务以后的通用的增删改操作（version 2.0） 
public void update(Connection conn ,String sql, Object... args) { //需要传入连接
    PreparedStatement ps = null;
    try {
        // 1.获取PreparedStatement的实例 (或：预编译sql语句)
        ps = conn.prepareStatement(sql);
        // 2.填充占位符
        for (int i = 0; i < args.length; i++) {
            ps.setObject(i + 1, args[i]);
        }
        // 3.执行sql语句
        ps.execute();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 4.关闭资源
        JDBCUtils.closeResource(null, ps); //JDBCUtils已经做好了关闭连接的功能

    }
}

13.3 事务的ACID属性

1. 原子性（Atomicity）
   原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
2. 一致性（Consistency）
   事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
3. 隔离性（Isolation）
   事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
4. 持久性（Durability）
   持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。

13.3.1 数据库的并发问题

• 对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:

  • 脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段。之后, 若 T2 回滚, T1读取的内容就是临时且无效的。
  • 不可重复读: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段。之后, T1再次读取同一个字段, 值就不同了。
  • 幻读: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
• 数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。
• 一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。

13.3.2 四种隔离级别

• 数据库提供的4种事务隔离级别：

• Oracle 支持的 2 种事务隔离级别：READ COMMITED, SERIALIZABLE。 Oracle 默认的事务隔离级别为: READ COMMITED 。
• Mysql 支持 4 种事务隔离级别。Mysql 默认的事务隔离级别为: REPEATABLE READ。

13.3.3 在MySql中设置隔离级别

• 每启动一个 mysql 程序, 就会获得一个单独的数据库连接. 每个数据库连接都有一个全局变量 @@tx_isolation, 表示当前的事务隔离级别。

• 查看当前的隔离级别:

  SELECT @@tx_isolation;

• 设置当前 mySQL 连接的隔离级别:

  set  transaction isolation level read committed;

• 设置数据库系统的全局的隔离级别:

  set global transaction isolation level read committed;

• 补充操作：

  • 创建mysql数据库用户：

    create user tom identified by 'abc123';

  • 授予权限

    #授予通过网络方式登录的tom用户，对所有库所有表的全部权限，密码设为abc123.
    grant all privileges on *.* to tom@'%'  identified by 'abc123'; 
    
     #给tom用户使用本地命令行方式，授予atguigudb这个库下的所有表的插删改查的权限。
    grant select,insert,delete,update on atguigudb.* to tom@localhost identified by 'abc123'; 
    

14. JDBC模糊查询