JDBC核心技术上篇

1 - Java中数据存储技术

在Java中，数据库存取技术可分为如下几类：

　　1 JDBC直接访问数据库

　　2 JDO (Java Data Object )技术

　　3 第三方O/R工具，如Hibernate, Mybatis 等

JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等只是更好的封装了JDBC

2 - JDBC介绍

1 JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，（java.sql,javax.sql）使用这些类库可以以一种标准的方法、方便地访问数据库资源。

2 JDBC为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。

3 JDBC的目标是使Java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。

4 有了JDBC，Java程序访问数据库时是这样的：

 

 5 总结如下

3 - JDBC体系结构

JDBC接口（API）包括两个层次：

　　1 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。

　　2 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。

/*
补充：

JDBC是sun公司提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。

不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。                                                        
*/

4 - 获取数据库连接

1 Driver接口介绍

　　java.sql.Driver 接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。

　　在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现。

　　　　Oracle的驱动：oracle.jdbc.driver.OracleDriver

　　　　mySql的驱动： com.mysql.jdbc.Driver(5.0版本)   com.mysql.cj.jdbc.Driver(8.0版本)

2 导入JDBC驱动以8.0版本为例步骤：

① 找到MySQL8.0版本的驱动jar包（一般在安装mysql时的文件里，例如：C:\Program Files (x86)\MySQL\Connector J 8.0\mysql-connector-java-8.0.19.jar），然后复制此文件。

 

 ② 在项目下创建 lib 文件夹，把复制的文件粘贴上去  注意：如果是Dynamic Web Project（动态的web项目）话，则是把驱动jar放到WebContent（有的开发工具叫WebRoot）目录中的WEB-INF目录中的lib目录下即可

 

 ③ 选中 lib 右键 选择 add as library，完成jar包的导入。导包完成后，即可使用该包下的工具类。

 

2 加载与注册JDBC驱动

① 加载驱动：加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名

　　Class.forName(“com.mysql.jdbc.Driver”);

② 注册驱动：DriverManager 类是驱动程序管理器类，负责管理驱动程序

　　使用DriverManager.registerDriver(com.mysql.jdbc.Driver)来注册驱动

　　通常不用显式调用 DriverManager 类的 registerDriver() 方法来注册驱动程序类的实例，因为 Driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 DriverManager.registerDriver() 方法来注册自身的一个实例（可在源码中查看）

 

3 URL介绍

JDBC URL 用于标识一个被注册的驱动程序，驱动程序管理器通过这个 URL 选择正确的驱动程序，从而建立到数据库的连接。

JDBC URL的标准由三部分组成，各部分间用冒号分隔。

　　jdbc:子协议:子名称

　　协议：JDBC URL中的协议总是jdbc

　　子协议：子协议用于标识一个数据库驱动程序

　　子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名

举例：

/*
MySQL的连接URL编写方式：

    - jdbc:mysql://主机名称:mysql服务端口号/数据库名称?参数=值&参数=值
    - jdbc:mysql://localhost:3306/atguigu
    - jdbc:mysql://localhost:3306/atguigu?useUnicode=true&characterEncoding=utf8**（如果JDBC程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集）
    - jdbc:mysql://localhost:3306/atguigu?user=root&password=123456
*/

4 数据库连接方式举例

 @Test // 方式1
    public void connectionTest1() throws SQLException {
        Driver driver = new com.mysql.cj.jdbc.Driver(); // 获取Driver的实现类对象
        String url = "jdbc:mysql://localhost:3306/test?useSSL=FALSE&serverTimezone=UTC";
        /*
        jdbc：主协议
        mysql：自协议
        localhost：IP地址
        3306：默认mysql端口号
        test：test数据库
         */
        Properties info = new Properties(); // 将用户名和密码封装在Properties中
        info.setProperty("user","root");
        info.setProperty("password","101323");
        Connection connection = driver.connect(url,info);
        System.out.println(connection);
    }
方式1
@Test // 方式2
    public void connectionTest2() throws Exception {
        /*
        方式1的迭代
        迭代原因：在如下程序中不出现第三方的api，使得程序更具有更好的移植性
         */

        // ① 获取Driver实现类对象：使用反射机制实现
        Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");
        Driver driver = (Driver) clazz.newInstance();

        // ② 提供要连接的数据库
        String url = "jdbc:mysql://localhost:3306/test?useSSL=FALSE&serverTimezone=UTC";

        // ③ 提供连接需要的用户名和密码
        Properties info = new Properties();
        info.setProperty("user","root");
        info.setProperty("password","101323");

        // ④ 获取连接
        Connection connection = driver.connect(url,info);
        System.out.println(connection);
    }
方式2(方式1的迭代)
@Test // 方式3：方式2的迭代(DriverManager替换Driver)
    public void connectionTest3() throws Exception{
        // 1. 获取Driver的实现类对象
        Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");
        Driver driver = (Driver) clazz.newInstance();

        // 2.提供连接信息
        String url = "jdbc:mysql://localhost:3306/test?useSSL=FALSE&serverTimezone=UTC";
        String user = "root";
        String password = "101323";

        // 注册驱动
        DriverManager.registerDriver(driver);

        // 获取连接
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
    }
方式3：方式2的迭代(DriverManager替换Driver)
 @Test // 方式4：方式3的优化
    public void connectionTest4() throws Exception{
        /*
        可以只是加载驱动，不用显示的注册驱动过了
         */
        // 1.提供连接信息
        String url = "jdbc:mysql://localhost:3306/test?useSSL=FALSE&serverTimezone=UTC";
        String user = "root";
        String password = "101323";

        // 2. 加载mysql驱动(Driver)
        Class.forName("com.mysql.cj.jdbc.Driver");

        // Driver driver = (Driver) clazz.newInstance();

        // 注册驱动
        // DriverManager.registerDriver(driver);

        // 获取连接
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
    }
方式4：方式3的优化

方式5 最终版(将数据库连接需要的4个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接)

在项目的 src 下新建 jdbc.properties 配置文件，文件内容如下

 

# 据库连接需要的4个基本信息
user=root
password=101323
url=jdbc:mysql://localhost:3306/test?useSSL=FALSE&serverTimezone=UTC
#jdbc:mysql://localhost:3306/springdb?useSSL=FALSE&serverTimezone=UTC&allowPublicKeyRetrieval=true
driverClass=com.mysql.cj.jdbc.Driver

 

在Java文件中 读取配置文件中的4个基本信息  -> 加载驱动 -> 获取连接

@Test // 方式5：最终版
    public void connectionTest5() throws Exception {
        /*
        将数据库连接需要的4个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接

        好处：
            1.实现了数据和代码的分离，也就是实现了解耦。
            2.如果需要修改配置文件信息，可避免程序重新打包
         */
        // 1.读取配置文件中的4个基本信息
        InputStream jdbcInfo = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        properties.load(jdbcInfo);
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driverClass = properties.getProperty("driverClass");

        // 2.加载驱动
        Class.forName(driverClass);

        // 3.获取连接
        Connection connection = DriverManager.getConnection(url,user,password);
        System.out.println(connection);
    }
方式5

5 - Statement与PreparedStatement

1 操作和访问数据库

　　数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。

　　在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式：

　　　　① Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。

　　　　② PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。

　　　　③ CallableStatement：用于执行 SQL 存储过程

2 使用Statement操作数据表的弊端

　　通过调用 Connection 对象的 createStatement() 方法创建该对象。该对象用于执行静态的 SQL 语句，并且返回执行结果。

　　Statement 接口中定义了下列方法用于执行 SQL 语句：

　　　　int excuteUpdate(String sql)：执行更新操作INSERT、UPDATE、DELETE
　　　　ResultSet executeQuery(String sql)：执行查询操作SELECT

　　但是使用Statement操作数据表存在弊端：

　　　　问题一：存在拼串操作，繁琐

　　　　问题二：存在SQL注入问题

　　SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令(如：SELECT user, password FROM user_table WHERE user='a' OR 1 = ' AND password = ' OR '1' = '1') ，从而利用系统的 SQL 引擎完成恶意行为的做法。

　　对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了。

弊端代码演示

package com.lzh.connection;

public class User {
    private String user;
    private String password;

    public User() {
    }

    public User(String user, String password) {
        super();
        this.user = user;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User [user=" + user + ", password=" + password + "]";
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}
User.java
package com.lzh.connection;

import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import java.util.Scanner;

public class StatementTest {
    public static void main(String[] args) {
        // 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题
        // 如何避免出现SQL注入只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了
        Scanner scan = new Scanner(System.in);

        System.out.print("用户名：");
        String userName = scan.nextLine();
        System.out.print("密  码：");
        String password = scan.nextLine();

        // SELECT user,password FROM user_table WHERE USER = '1' or ' AND PASSWORD = '='1' or '1' = '1';
        //
        String sql = "SELECT user,password FROM user_table WHERE USER = '" + userName + "' AND PASSWORD = '" + password
                + "'";
        User user = get(sql, User.class);
        if (user != null) {
            System.out.println("登陆成功!");
        } else {
            System.out.println("用户名或密码错误！");
        }
    }

    // 使用Statement实现对数据表的查询操作
    public static <T> T get(String sql, Class<T> clazz) {
        T t = null;

        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try {
            // 1.加载配置文件
            InputStream is = StatementTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties pros = new Properties();
            pros.load(is);

            // 2.读取配置信息
            String user = pros.getProperty("user");
            String password = pros.getProperty("password");
            String url = pros.getProperty("url");
            String driverClass = pros.getProperty("driverClass");

            // 3.加载驱动
            Class.forName(driverClass);

            // 4.获取连接
            conn = DriverManager.getConnection(url, user, password);

            st = conn.createStatement();

            rs = st.executeQuery(sql);

            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();

            // 获取结果集的列数
            int columnCount = rsmd.getColumnCount();

            if (rs.next()) {

                t = clazz.newInstance();

                for (int i = 0; i < columnCount; i++) {
                    // //1. 获取列的名称
                    // String columnName = rsmd.getColumnName(i+1);

                    // 1. 获取列的别名
                    String columnName = rsmd.getColumnLabel(i + 1);

                    // 2. 根据列名获取对应数据表中的数据
                    Object columnVal = rs.getObject(columnName);

                    // 3. 将数据表中得到的数据，封装进对象
                    Field field = clazz.getDeclaredField(columnName);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (st != null) {
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}
StatementTest.java

 综上：

1 PreparedStatement介绍

　　可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象

　　PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句

　　PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

2 PreparedStatement vs Statement

　　① 代码的可读性和可维护性。

　　② PreparedStatement 能最大可能提高性能：

　　　　1 DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。

　　　　2 在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。

　　　　3 (语法检查，语义检查，翻译成二进制命令，缓存)

　　③ PreparedStatement 可以防止 SQL 注入

3 Java与SQL对应数据类型转换表

6 - 使用PreparedStatement实现增、删、改操作

1 在项目的src文件创建配置文件(jdbc.properties)，用来存储据库连接需要的4个基本信息

# 据库连接需要的4个基本信息
user=root
password=101323
url=jdbc:mysql://localhost:3306/test?useSSL=FALSE&serverTimezone=UTC&allowPublicKeyRetrieval=true
driverClass=com.mysql.cj.jdbc.Driver
jdbc.properties

2 新建JDBC的工具类(JDBCUtils)，用来封装数据库的连接与资源的关闭

package com.lzh.util;

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

/*
操作数据库的工具类
 */
public class JDBCUtils {
    /**
     * @author Howie
     * @date 2020/7/13 9:46
     * @description 获取数据库连接
     * @return connection
     */
    public static Connection getConnection() throws IOException, ClassNotFoundException, SQLException {
        // 1. 加载配置文件
        InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        properties.load(inputStream);
        // System.out.println(properties);

        // 2. 读取4个基本配置信息
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String driverClass = properties.getProperty("driverClass");
        String url = properties.getProperty("url");

        // 3. 加载驱动
        Class.forName(driverClass);

        // 4. 获取连接
        Connection connection = DriverManager.getConnection(url, user, password);

        return connection;
    }
    /**
     * @author Howie
     * @date 2020/7/13 9:58
     * @param connection
     * @param preparedStatement
     * @Description 关闭连接和Statement的操作
     * @return
     */
    public static void closeResource(Connection connection,PreparedStatement preparedStatement){
        try {
            if(connection != null)
                connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if(preparedStatement != null)
                preparedStatement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    /**
     * @author Howie
     * @date 2020/7/13 15:53
     * @param
     * @Description 关闭数据库连接、PreparedStatement、ResultSet资源
     * @return
     */
    public static void closeResource(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet){
        try {
            if(connection != null)
                connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if(preparedStatement != null)
                preparedStatement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        try {
            if(resultSet != null)
                resultSet.close();
        } catch (SQLException e){
            e.printStackTrace();
        }
    }
}
JDBCUtils.class

3 增删改具体实现

package com.lzh.preparedstatement;

import com.lzh.util.JDBCUtils;
import org.junit.Test;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Date;
import java.text.SimpleDateFormat;
import java.util.Properties;

// 使用PreparedStatement实现CRUD操作
/*
使用PreparedStatement来替换Statement，实现对数据表的增删改查
 */
public class PreparedStatementUpdateTest {
    // 向customer表中添加一条记录
    @Test
    public void insertTest() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try{
            // 1. 加载配置文件
            InputStream inputStream = PreparedStatementUpdateTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties properties = new Properties();
            properties.load(inputStream);
            // System.out.println(properties);

            // 2. 读取4个基本配置信息
            String user = properties.getProperty("user");
            String password = properties.getProperty("password");
            String driverClass = properties.getProperty("driverClass");
            String url = properties.getProperty("url");

            // 3. 加载驱动
            Class.forName(driverClass);

            // 4. 获取连接
            connection = DriverManager.getConnection(url,user,password);

            // 5. 预编译SQL语句，返回PreparedStatement的实例
            String sql = "insert into customers(name,email,birth) values(?,?,?)"; // ?：占位符
            preparedStatement = connection.prepareStatement(sql);

            // 6. 填充占位符
            preparedStatement.setString(1,"howie"); // 注意这里索引从1开始
            preparedStatement.setString(2,"1013235435@qq.com");
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            java.util.Date date = simpleDateFormat.parse("1999-1-9");
            preparedStatement.setDate(3, new Date(date.getTime()));

            // 7. 执行SQL
            preparedStatement.execute();
            System.out.println("插入成功!");
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            // 8. 关闭资源
            try {
                if(connection != null)
                    connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if(preparedStatement != null)
                    preparedStatement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    // 修改customers表中的一条记录
    public void updateTest() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            // 1.获取数据库的连接
            connection = JDBCUtils.getConnection();
            // System.out.println(connection);

            // 2.预编译SQL语句，返回PreparedStatement的实例
            String sql = "update customers set email = ? where id = ?";
            preparedStatement = connection.prepareStatement(sql);

            // 3.填充占位符
            preparedStatement.setObject(1,"howie@qq.com");
            preparedStatement.setObject(2,19);

            // 4.执行SQL语句
            preparedStatement.execute();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 5.关闭资源
            JDBCUtils.closeResource(connection,preparedStatement);
        }
        System.out.println("修改成功");
    }

    // 通用的[增删改]操作
    public int update(String sql,Object ...args) { // 注意：这里要求SQL中的占位符(?)个数要与参数一致
            Connection connection = null;
            PreparedStatement preparedStatement = null;
        try {
            // 1. 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 2. 预编译SQL语句，返回PreparedStatement的实例
            preparedStatement = connection.prepareStatement(sql);
            // 3. 填充占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }
            // 4. 执行
            // 方式2
            // preparedStatement.execute();
            /*
            preparedStatement.execute() 方法：
                如果执行的是查询操作，有返回结果，则此方法返回true
                如果执行的增、删、改操作，没有返回结果，则此方法返回false
             */
            // 方式1
            return preparedStatement.executeUpdate();
        } catch(Exception e){
            e.printStackTrace();
        } finally {
            // 5. 关闭连接和PreparedStatement
            JDBCUtils.closeResource(connection,preparedStatement);
        }
        return 0;
    }

    @Test // 测试通用的[增删改]操作
    public void test(){
        String sql = "delete from customers where id = ?";
        int deleteCount = update(sql,20);
        if(deleteCount > 0){
            System.out.println("删除成功!");
        }else{
            System.out.println("删除失败!");
        }
    }
}
PreparedStatementUpdateTest.class

7 - 使用PreparedStatement实现查询操作

说明：使用PreparedStatement实现的查询操作可以替换Statement实现的查询操作，解决Statement拼串和SQL注入问题。

package com.lzh.preparedstatement;

import com.lzh.bean.Order;
import com.lzh.util.JDBCUtils;
import org.junit.Test;
import com.lzh.bean.User;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/*
使用PreparedStatement实现针对不同表的通用的查询操作

说明：PreparedStatement替换Statement的好处？
    1.解决SQLl注入问题
    2.解决了Statement的SQL语句拼串问题
    3.PreparedStatement操作Blob的数据，而Statement做不到
    4.PreparedStatement可以实现更高效的批量插入

 */
public class PreparedStatementQueryTest {
    /**
     * @author Howie
     * @date 2020/7/14 13:53
     * @param
     * @Description getInstance() 实现不同表的通用的查询操作，此时只返回一张表中的一条记录
     * @return
     */
    public <T> T getInstance(Class<T> clazz,String sql,Object ...args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 1.获取数据库连接
            connection = JDBCUtils.getConnection();
            // 2.预编译SQL语句，返回PreparedStatement实例
            preparedStatement = connection.prepareStatement(sql);
            // 3.填充占位符
            for(int i = 0;i < args.length;i++){
                preparedStatement.setObject(i+1,args[i]);
            }
            // 4.执行SQL语句，返回ResultSet结果集
            resultSet = preparedStatement.executeQuery();
            // 5.处理结果集
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData(); // 获取元数据
            int columnCount = resultSetMetaData.getColumnCount(); // 获取字段数
            if (resultSet.next()) {
                T t = clazz.newInstance();
                for(int i = 0;i < columnCount;i++){
                    String columnLabel = resultSetMetaData.getColumnLabel(i+1); // 获取查询字段的别名
                    Object columnValue = resultSet.getObject(i+1); // 获取字段的值

                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t,columnValue);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭资源
            JDBCUtils.closeResource(connection,preparedStatement,resultSet);
        }
        return null;
    }

    @Test
    public void testGetInstance(){
        String sql1 = "select id,name,address,phone,password from user where id = ?";
        User user = getInstance(User.class,sql1,1);
        System.out.println(user);

        String sql2 = "select * from test.order where order_id = ?";
        Order order = getInstance(Order.class,sql2,2);
        System.out.println(order);
    }

    /**
     * @author Howie
     * @date 2020/7/14 14:45
     * @param
     * @Description 实现不同表的通用的查询操作，此时可以返回一张表中中的多条记录
     * @return
     */
    public <T> List<T> getInstanceList(Class<T> clazz,String sql,Object ...args){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 1.获取数据库连接
            connection = JDBCUtils.getConnection();
            // 2.预编译SQL语句，返回PreparedStatement实例
            preparedStatement = connection.prepareStatement(sql);
            // 3.填充占位符
            for(int i = 0;i < args.length;i++){
                preparedStatement.setObject(i+1,args[i]);
            }
            // 4.执行SQL语句，返回ResultSet结果集
            resultSet = preparedStatement.executeQuery();
            // 5.处理结果集
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData(); // 获取元数据
            int columnCount = resultSetMetaData.getColumnCount(); // 获取字段数

            // 创建集合对象
            ArrayList<T> list = new ArrayList<>();
            while (resultSet.next()) {
                T t = clazz.newInstance();
                // 处理结果集一行数据中的每一个列：给t对象 指定的属性赋值
                for(int i = 0;i < columnCount;i++){
                    String columnLabel = resultSetMetaData.getColumnLabel(i+1); // 获取查询字段的别名
                    Object columnValue = resultSet.getObject(i+1); // 获取字段的值

                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t,columnValue);
                }
                list.add(t);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭资源
            JDBCUtils.closeResource(connection,preparedStatement,resultSet);
        }
        return null;
    }

    @Test
    public void testGetInstanceList(){
        String sql = "select * from user where id < ?";
        List<User> userList = getInstanceList(User.class,sql,5);
        for(User i:userList){
            System.out.println(i);
        }
        // userList.foreach(System.out::println);
    }
}
PreparedStatementQueryTest.class
/*
ORM编程思想(Object relational mapping)
一个数据表对应一个Java类
表中的一条记录对应Java类中的一个对象
表中的一个字段对应Java类中的一个属性
 */
ORM编程思想

1 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() 方法

 

2 资源的释放

  • 释放ResultSet, Statement,Connection。

  • 数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。

  • 可以在finally中关闭，保证及时其他代码出现异常，资源也一定能被关闭。

8 - JDBC API小结

  • 两种思想

    • 面向接口编程的思想

    • ORM思想(object relational mapping)

      • 一个数据表对应一个java类

      • 表中的一条记录对应java类的一个对象

      • 表中的一个字段对应java类的一个属性

    sql是需要结合列名和表的属性名来写。注意起别名。

  • 两种技术

    • JDBC结果集的元数据：ResultSetMetaData

      • 获取列数：getColumnCount()

      • 获取列的别名：getColumnLabel()

    • 通过反射，创建指定类的对象，获取指定的属性并赋值

9 - 操作BLOB类型的字段

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服务。

 

2 使用PreparedStatement 向数据表中插入大数据(blob类型字段)类型

@Test
    // 向数据表customers中插入Blob类型的字段
    public void insertBlobTest() throws SQLException, IOException, ClassNotFoundException {
        // 1.获取数据库连接
        Connection connection = JDBCUtils.getConnection();
        // 2.预编译SQL语句，返回PreparedStatement实例
        String sql = "insert into customers(name,email,birth,photo) values(?,?,?,?)";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        // 3.填充占位符
        preparedStatement.setObject(1,"howie");
        preparedStatement.setObject(2,"howie@123.com");
        preparedStatement.setObject(3,"1999-1-9");
        FileInputStream photoFile = new FileInputStream(new File("me.jpg"));
        preparedStatement.setBlob(4,photoFile);

        // 4.执行SQL语句
        int insertCount = preparedStatement.executeUpdate();
        // 5.关闭资源
        JDBCUtils.closeResource(connection,preparedStatement);
        System.out.println(insertCount);
    }
View Code

3 使用PreparedStatement 查询数据表中blob类型的字段

 @Test
    // 查询数据表customers中含有Blob字段的数据
    public void blobQueryTest() {
        Connection  connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        InputStream photoBinary = null;
        FileOutputStream fileOutputStream = null;
        try {
            // 1.获取数据库连接
            connection = JDBCUtils.getConnection();
            // 2.预编译SQL语句，返回PreparedStatement的实例
            String sql = "select * from test.customers where id = ?";
            preparedStatement = connection.prepareStatement(sql);
            // 3.填充占位符
            preparedStatement.setObject(1,21);
            // 4.执行SQL语句，返回ResultSet类型的结果集
            resultSet = preparedStatement.executeQuery();
            // 5.处理结果集
            if(resultSet.next()){
                int id = resultSet.getInt(1);
                String name = resultSet.getString(2);
                String email = resultSet.getString(3);
                Date birthDate = resultSet.getDate(4);

                Customer customer = new Customer(id,name,email,birthDate);
                System.out.println(customer);
                // 将Blob类型的字段下载下来，以文件的方式保存在本地
                Blob photo = resultSet.getBlob("photo");
                photoBinary = photo.getBinaryStream();
                fileOutputStream = new FileOutputStream(new File("howie.jpg"));
                byte[] buffer = new byte[1024];
                int len;
                while((len = photoBinary.read(buffer)) != -1){
                    fileOutputStream.write(buffer,0,len);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭资源
            try {
                if(fileOutputStream != null)
                    fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(photoBinary != null)
                    photoBinary.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            JDBCUtils.closeResource(connection,preparedStatement,resultSet);
        }
    }
View Code

10 - 批量插入数据

1 批量执行SQL语句

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

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

  • addBatch(String)：添加需要批量处理的SQL语句或是参数；

  • executeBatch()：执行批量处理语句；

  • clearBatch():清空缓存的数据

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

  • 多条SQL语句的批量处理；

  • 一个SQL语句的批量传参；

 

2 高效插入的批量插入

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

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

create table goods(
    id int primary key auto_increment,
    name varchar(25)
);

实现方式1：使用Statement接口

connection connection = JDBCUtils.getConnection();
Statement statement = connection.createStatement();
for(int i = 1;i < 10000;i++){
    String sql = "insert into goods(name) values('name_" + i +"');"
    statement.execute(sql);
}
View Code

说明：使用Statement接口时缺点颇多且繁杂，向表中插入20000条数据就要校验2000条SQL语句，效率极其的低，开发中一般不使用此接口。

 

实现方式2：使用PreparedStatement接口替换Statement接口

 @Test // 方式2：使用PreparedStatement替换Statement
    public void insertTest() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            long start = System.currentTimeMillis();
            // 1.获取数据库连接
            connection = JDBCUtils.getConnection();

            // 2.预编译SQL语句，返回PreparedStatement实例
            String sql = "insert into goods(name) values(?)";
            preparedStatement = connection.prepareStatement(sql);

            // 3.填充占位符与执行SQL语句
            for(int i = 1;i < 20000;i++){
                preparedStatement.setObject(1,"name_" + i);
                preparedStatement.execute();
            }
            long end = System.currentTimeMillis();
            System.out.println("花费时间为：" + (end - start)); // 与磁盘交互过多，花费时间还是较长
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 4.关闭资源
            JDBCUtils.closeResource(connection,preparedStatement);
        }
    }
View Code

说明：方式2虽然以预编译的方式减少了SQL语句的校验(只需编译一次)，提高了效率，但是数据写入数据表过程中与磁盘交互过多，效率上仍有提升的空间

 

实现方式3：方式2的优化(优化方法：制定SQL执行规则来减少与磁盘交互，新加方法：addBatch()、executeBatch()、clearBatch())

 @Test // 方式3：方式2的优化
    public void insertTest2(){
        /*
        优化方法：
            1.新加方法：addBatch()、executeBatch()、clearBatch()
            2.mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持：?rewireBatchedStatements=true
            写在配置文件的url后面
         */
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            long start = System.currentTimeMillis();
            // 1.获取数据库连接
            connection = JDBCUtils.getConnection();

            // 2.预编译SQL语句，返回PreparedStatement实例
            String sql = "insert into goods(name) values(?)";
            preparedStatement = connection.prepareStatement(sql);

            // 3.填充占位符与执行SQL语句
            for(int i = 1;i < 20000;i++){
                preparedStatement.setObject(1,"name_" + i);
                // 1.赞"sql"
                preparedStatement.addBatch();
                if(i % 500 == 0){
                    // 2.执行batch
                    preparedStatement.executeBatch();
                    // 3.清空batch
                    preparedStatement.clearBatch();
                }
            }
            long end = System.currentTimeMillis();
            System.out.println("花费时间为：" + (end - start)); // 与磁盘交互过多，花费时间还是较长
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 4.关闭资源
            JDBCUtils.closeResource(connection,preparedStatement);
        }
    }
View Code

说明：方式3在每次执行完SQL语句后，都会自动提交，提交次数过多时，仍有优化空间

 

实现方式4(最终版)：方式3的优化，设置不允许自动提交数据

@Test // 批量插入的方式4(最终版)
    public void insertTest3(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            long start = System.currentTimeMillis();
            // 1.获取数据库连接
            connection = JDBCUtils.getConnection();

            // 优化方案：设置不允许自动提交数据
            connection.setAutoCommit(false);

            // 2.预编译SQL语句，返回PreparedStatement实例
            String sql = "insert into goods(name) values(?)";
            preparedStatement = connection.prepareStatement(sql);

            // 3.填充占位符与执行SQL语句
            for(int i = 1;i < 20000;i++){
                preparedStatement.setObject(1,"name_" + i);
                // 1.赞"sql"
                preparedStatement.addBatch();
                if(i % 500 == 0){
                    // 2.执行batch
                    preparedStatement.executeBatch();
                    // 3.清空batch
                    preparedStatement.clearBatch();
                }
            }
            // 提交数据
            connection.commit();
            long end = System.currentTimeMillis();
            System.out.println("花费时间为：" + (end - start)); // 与磁盘交互过多，花费时间还是较长
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 4.关闭资源
            JDBCUtils.closeResource(connection,preparedStatement);
        }
    }
View Code

 

posted @ 2020-07-11 18:15  赖正华  阅读(207)  评论(0)  编辑  收藏  举报