JDBC

该文档是:JDBC的使用

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

日期:2020-11-26

1. JDBC概述

image-20201126100703467

2. JDBC的本质

image-20201126100918231

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

image-20201126102202014

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

image-20201126102328183

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

image-20201126102805706

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

image-20201126102815979

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

image-20201126102922577

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

使用多态,只需要改动右边new的 就能连接到不同的数据库!!!!

image-20201126103141291

结果:

image-20201126103210687

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

image-20201126103740041

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

因为Oracle,Mysql,SQLServer都实现了JDBC接口,JDBC就是个父亲!

为什么要写JDBC,不直接写Oracle或者Mysql...,因为读取的配置文件,文件中可能配置的是Oracle也可能是Mysql,所以写JDBC比较灵活,JDBC是他们的父类!

image-20201126103748034

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

驱动非常重要!

image-20201126104011641

image-20201126104040541

总结: JDBC的本质其实就是一套接口!!!

3. JDBC编程六步

image-20201126135529951

3.1 编程五步案例

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

image-20201126143535753

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

因为MySQL提供的驱动中的Drive里有一个静态代码块,里边的内容会完成驱动的注册,要调用这个静态代码块只需要类加载就行!

image-20201126144331439

注册驱动的方法:

image-20201126144638624

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

实际开发中不建议把连接数据库的信息写死到java程序中。

image-20201126150705782

image-20201126145151986

3.4 查询案例(六步)

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

image-20201126151247471

1~4步:

image-20201126151230913

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

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

image-20201126152459085

image-20201126154624548

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

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注入问题)(重要*)

用户表:

image-20201126193047433

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

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

image-20201126193035051

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

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

image-20201126193545132

代码:

image-20201126192934352

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

如何防止SQL注入问题:

image-20201126195905483

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

image-20201126201551775

代码:

image-20201126201438714

6. 对比Statement和PreparedStatement

实际开发中不建议把连接数据库的信息写死到java程序中。

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

image-20201126202617140

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

总结:百分之99的情况下都使用PreparedStatement!不过各自有各自的用处。

7. 什么情况下使用Statement

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

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

例子:

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

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

image-20201126204910270image-20201126204924710

代码:

image-20201126205003106

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);//传入连接对象,数据库操作对象,结果集对象进行关闭
        }
    }
}

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

image-20201207203443891

image-20201207203454718

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()

image-20201208202903818

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):指示是否自动为指定列进行编号,这样这些列仍然是只读的。

image-20201208203004253

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

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

问题2:关于ResultSetMetaData

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

image-20201208203031884

10. 改良版的PreparedStatement查询

10.1 优化版本1:

image-20201208191029348

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

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:

流程:

image-20201208191815889

数据库的表:

image-20201208191029348

创建一个类,不一定要属性和列名对上:

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 最终版本:

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

数据库表:

image-20201208195819942

测试代码中传入的类是:

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

查询结果:

image-20201208195904978

代码:

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类型(除了在存储的最大信息量上不同外,他们是等同的)

image-20201208203423194

  • 实际使用中根据需要存入的数据大小定义不同的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种事务隔离级别:

image-20201208210548768

  • 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模糊查询

image-20201127105818131

最后修改:2020 年 12 月 08 日 09 : 08 PM
如果觉得我的文章对你有用,请随意赞赏