需要在MySQL导入的数据，我放在文章的末尾处

一、JDBC概述

1.1、数据的持久化

??持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的数据保存到硬盘上加以”固化”，而持久化的实现过程大多通过各种关系数据库来完成。持久化的主要应用是将内存中的数据存储在关系型数据库中，当然也可以存储在磁盘文件、XML数据文件中。

1.2、Java中的数据存储技术

• 在Java中，数据库存取技术可分为如下几类：
  • JDBC直接访问数据库
  • JDO (Java Data Object )技术
  • 第三方O/R工具，如Hibernate, Mybatis等
• JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等只是更好的封装了JDBC。

1.3、JDBC介绍

??JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，（java.sql,javax.sql）使用这些类库可以以一种标准的方法、方便地访问数据库资源。JDBC为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。JDBC的目标是使Java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。

1.4、JDBC体系结构

• JDBC接口（API）包括两个层次：
  • 面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。
  • 面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。

JDBC是sun公司（08年已被Oracle收购）提供一套用于数据库操作的接口，java程序员只需要面向这套接口编程即可。
不同的数据库厂商，需要针对这套接口，提供不同实现。不同的实现的集合，即为不同数据库的驱动。———— 面向接口编程

二、获取数据库连接

2.1、要素一：Driver接口实现类

2.1.1、Driver接口介绍

??java.sql.Driver 接口是所有JDBC驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现。

??将上述jar包拷贝到Java工程的一个目录中，然后在驱动jar上右键选择Add as library……，接着在Level选择Moudle Library，最后点击OK。

2.1.2、加载与注册JDBC驱动

• 加载驱动：加载JDBC驱动需调用Class类的静态方法forName()，向其传递要加载的JDBC驱动的类名
  • Class.forName(“com.mysql.jdbc.Driver”);
• 注册驱动：DriverManager类是驱动程序管理器类，负责管理驱动程序
  • 使用DriverManager.registerDriver(com.mysql.jdbc.Driver)来注册驱动
  • 通常不用显式调用 DriverManager类的registerDriver()方法来注册驱动程序类的实例，因为Driver接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用DriverManager.registerDriver()方法来注册自身的一个实例。

2.2、要素二：URL

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

• JDBC URL的标准由三部分组成，各部分间用冒号分隔。
  • jdbc:子协议:子名称
  • 协议：JDBC URL中的协议总是jdbc
  • 子协议：子协议用于标识一个数据库驱动程序
  • 子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名
• 几种常用数据库的JDBC URL
  • MySQL的连接URL编写方式：
    • jdbc:mysql://主机名称:mysql服务端口号/数据库名称?参数=值&参数=值
  • Oracle 9i的连接URL编写方式：
    • jdbc:oracle:thin:@主机名称:oracle服务端口号:数据库名称
  • SQL Server的连接URL编写方式：
    • jdbc:sqlserver://主机名称:sqlserver服务端口号:DatabaseName=数据库名称

2.3、要素三：用户名和密码

• user,password可以用“属性名=属性值”方式告诉数据库
• 可以调用DriverManager类的getConnection()方法建立到数据库的连接

2.4、数据库连接方式举例

package star.light;

import org.junit.Test;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.util.Properties;

public class ConnectionTest {

    //方式一
    @Test
    public void testConnection1() throws Exception {
        //获取Driver实现类对象
        //Driver driver = new com.mysql.jdbc.Driver();        //MySQL8.0之前的写法
        Driver driver = new com.mysql.cj.jdbc.Driver();       //MySQL8.0之后的写法

        //2. 提供要连接的数据库
        String url = "jdbc:mysql://localhost:3306/jdbc_learn";

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

        //4. 获取连接
        Connection connection = driver.connect(url,info);
        System.out.println(connection);
    }

    //方式二：在如下的程序不出现第三方的api，使得程序具有更好的可移植性
    @Test
    public void testConnection2() throws Exception {
        //1. 获取Driver实现类对象，使用反射
        Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");
        Driver driver = (Driver) clazz.getConstructor().newInstance();

        //2. 提供要连接数据库
        String url = "jdbc:mysql://localhost:3306/jdbc_learn";

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

        //4. 获取连接
        Connection connection = driver.connect(url,info);
        System.out.println(connection);
    }

    //方式三：使用DriverManager替换Driver
    @Test
    public void testConnection3() throws Exception {
        //1. 提供另外三个连接的基本信息
        String url = "jdbc:mysql://localhost:3306/jdbc_learn";
        String user = "root";
        String password = "abc123";

        //2. 获取Driver实现类对象
        Class clazz = Class.forName("com.mysql.cj.jdbc.Driver");
        Driver driver = (Driver) clazz.getConstructor().newInstance();
        //3. 注册驱动
        DriverManager.registerDriver(driver);

        //4. 获取连接
        Connection connection = DriverManager.getConnection(url,user,password);
        System.out.println(connection);
    }
    
    /**
     * 相对于方式三可以省略注册驱动
     * 在MySQL的Driver实现类中，声明了如下操作：
     * static {
     *         try {
     *             DriverManager.registerDriver(new Driver());
     *         } catch (SQLException var1) {
     *             throw new RuntimeException("Can't register driver!");
     *         }
     *     }
     */
    //方式四：可以只加载驱动，不用显示的注册驱动
    @Test
    public void testConnection4() throws Exception {
        //1. 提供另外三个连接的基本信息
        String url = "jdbc:mysql://localhost:3306/jdbc_learn";
        String user = "root";
        String password = "abc123";
        
        //2. 加载Driver
        Class.forName("com.mysql.cj.jdbc.Driver");

        //4. 获取连接
        Connection connection = DriverManager.getConnection(url,user,password);
        System.out.println(connection);
    }
    
    /**
     * 此种方法的好处
     * 1. 实现了数据与代码的分离，实现了解耦
     * 2. 如果修改配置文件信息，可以避免程序重新打包
     */
    //方式五：将数据路需要的4个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接
    @Test
    public void testConnection5() throws Exception {
        //1. 读取配置文件中的4个基本信息
        InputStream inputStream = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");

        Properties properties = new Properties();
        properties.load(inputStream);

        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driver = properties.getProperty("driver");

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

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

??其中，配置文件声明在工程的src目录下：【jdbc.properties】

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

三、使用PreparedStatement实现CRUD操作

3.1、操作和访问数据库

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

• 在 java.sql 包中有3个接口分别定义了对数据库的调用的不同方式：
  • Statement：用于执行静态SQL语句并返回它所生成结果的对象。
  • PrepatedStatement：SQL语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。
  • CallableStatement：用于执行SQL存储过程

3.2、使用Statement操作数据表的弊端

??通过调用Connection对象的createStatement()方法创建该对象。该对象用于执行静态的SQL语句，并且返回执行结果。Statement接口中定义了下列方法用于执行SQL语句：

boolean execute?(String sql) throws SQLException          //执行更新操作INSERT、UPDATE、DELETE
ResultSet executeQuery?(String sql) throws SQLException   //执行查询操作SELECT

??但是使用Statement操作数据表存在弊端：（1）存在拼串操作，繁琐；（2）存在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就可以了。

3.3、PreparedStatement的使用

??可以通过调用Connection对象的preparedStatement(String sql)方法获取PreparedStatement对象。PreparedStatement接口是Statement的子接口，它表示一条预编译过的SQL语句。

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

boolean execute() throws SQLException           //如果执行的是查询操作，有返回结果，则此方法返回true，如果执行的是增、删、改操作，没有返回结果，则此方法返回false
ResultSet executeQuery() throws SQLException    //执行查询操作SELECT
int executeUpdate() throws SQLException         //执行更新操作INSERT、UPDATE、DELETE，返回影响的行数

??PreparedStatement除了解决Statement的拼串、SQL注入问题之外，它还可以操作Blob的数据，而Statement做不到。PreparedStatement可以实现更高效的批量操作。

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

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

3.4、ResultSet与ResultSetMetaData

3.4.1、ResultSet

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

boolean next() throws SQLException                          //检测下一行是否有效。若有效，该方法返回true，且指针下移
Object getObject?(int columnIndex) throws SQLException      //通过字段的序号获取指定的结果
Object getObject?(String columnLabel) throws SQLException   //通过字段的别名获取指定的结果

注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。

3.4.2、ResultSetMetaData

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

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

3.5、资源的释放

??释放ResultSet, Statement,Connection。数据库连接（Connection）是非常稀有的资源，用完后必须马上释放，如果Connection不能及时正确的关闭将导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。可以在finally中关闭，保证及时其他代码出现异常，资源也一定能被关闭。

3.6、例程

package star.light;

import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.Properties;
import java.util.Scanner;

public class StatementTest {

    public static void main(String[] args) {
        StatementTest statementTest = new StatementTest();
        Scanner scanner = new Scanner(System.in);

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

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

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

        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            // 1.加载配置文件
            InputStream inputStream = StatementTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
            Properties properties = new Properties();
            properties.load(inputStream);

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

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

            // 4.获取连接
            connection = DriverManager.getConnection(url,user,password);
            statement = connection.createStatement();
            resultSet = statement.executeQuery(sql);

            //5. 获取结果集的元数据
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();

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

            if (resultSet.next()) {
                t = clazz.getConstructor().newInstance();
                for (int i = 0; i < columnCount; i++) {
                    // //1. 获取列的名称
                    // String columnName = rsmd.getColumnName(i+1);

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

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

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

            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }

        return null;
    }
}

package star.light;

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

    public User() {
    }

    public User(String user, String password) {
        this.user = user;
        this.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;
    }

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

package star.light;

import org.junit.Test;

import java.io.*;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class PreparedStatementTest {
    public static void main(String[] args) {
        PreparedStatementTest test = new PreparedStatementTest();
        Scanner scanner = new Scanner(System.in);

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

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

    @Test
    public void test01() throws Exception {
        FileInputStream fileInputStream = new FileInputStream(new File("./image/小钰袖.jpg"));
        String sql = "insert into customers(id,name,email,photo) value(?,?,?,?)";   //?占位符
        update(sql,19,"白钰袖","baiyuxiu@sina.com", fileInputStream);
    }

    @Test
    public void test02() throws Exception {
        FileInputStream fileInputStream = new FileInputStream(new File("./image/钰袖.jpg"));
        String sql = "update customers set name = ?,photo = ? where id = ?";
        update(sql,"钰袖",fileInputStream,19);
    }
    @Test
    public void test03(){
        String sql = "delete from customers where id = ?";
        update(sql,19);
    }

    @Test
    public void test04(){
        String sql = "select id,name,email,birth from customers where id = ?";
        Customer customer = getInstance(Customer.class, sql, 19);
        System.out.println(customer);
    }

    @Test
    public void test05(){
        String sql = "select order_id orderId,order_name orderName,order_date orderDate from `order` where order_id = ?";
        Order order = getInstance(Order.class, sql, 1);
        System.out.println(order);
    }

    @Test
    public void test06(){
        String sql = "select id,name,email,birth from customers where id < ?";
        List list = getForList(Customer.class, sql, 12);
        list.forEach(System.out::println);
    }



    //通用的增、删、改操作（体现一：增、删、改 ； 体现二：针对于不同的表）
    public void update(String sql,Object ... args){
        Connection connection = null;
        PreparedStatement preparedStatement = null;

        try {
            //1.获取数据库的连接
            connection = JDBCUtils.getConnection();

            //2.获取PreparedStatement的实例 (或：预编译sql语句)
            preparedStatement = connection.prepareStatement(sql);

            //3.填充占位符
            for(int i = 0;i < args.length;i++){
                preparedStatement.setObject(i + 1, args[i]);
            }

            //4.执行sql语句
            preparedStatement.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //5.关闭资源
            JDBCUtils.closeResource(connection, preparedStatement);
        }
    }

    // 通用的针对于不同表的查询:返回一个对象
    public  T getInstance(Class 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.执行executeQuery(),得到结果集：ResultSet
            resultSet = preparedStatement.executeQuery();

            // 5.得到结果集的元数据：ResultSetMetaData
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();

            // 6.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
            int columnCount = resultSetMetaData.getColumnCount();
            if (resultSet.next()) {
                T t = clazz.getConstructor().newInstance();
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columnVal = resultSet.getObject(i + 1);

                    // 获取列的别名:列的别名，使用类的属性名充当，如果没有取别名，获取的是列名
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);

                    // 6.2使用反射，给对象的相应属性赋值
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 7.关闭资源
            JDBCUtils.closeResource(connection, preparedStatement, resultSet);
        }
        return null;
    }

    // 通用的针对于不同表的查询:返回一个集合
    public  List getForList(Class 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.执行executeQuery(),得到结果集：ResultSet
            resultSet = preparedStatement.executeQuery();

            // 5.得到结果集的元数据：ResultSetMetaData
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();

            // 6.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
            int columnCount = resultSetMetaData.getColumnCount();
            //创建集合对象
            ArrayList list = new ArrayList();
            while (resultSet.next()) {
                T t = clazz.getConstructor().newInstance();
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columnVal = resultSet.getObject(i + 1);

                    // 获取列的别名:列的别名，使用类的属性名充当，如果没有取别名，获取的是列名
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);

                    // 6.2使用反射，给对象的相应属性赋值
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                }
                list.add(t);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 7.关闭资源
            JDBCUtils.closeResource(connection, preparedStatement, resultSet);
        }
        return null;
    }
}

package star.light;

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

public class JDBCUtils {

    public static Connection getConnection() throws Exception {
        //1. 读取配置文件中的4个基本信息
        InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        properties.load(inputStream);

        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driver = properties.getProperty("driver");

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

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

        return  connection;
    }

    public static void closeResource(Connection connection, Statement statement){
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void closeResource(Connection connection, Statement statement,ResultSet resultSet){
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if(statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (resultSet != null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

package star.light;

import java.sql.Date;

public class Customer {
    private int id;
    private String name;
    private String email;
    private Date birth;

    public Customer() {
    }

    public Customer(int id, String name, String email, Date birth) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.birth = birth;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", birth=" + birth +
                '}';
    }
}

package star.light;

import java.sql.Date;

public class Order {
    private int orderId;
    private String orderName;
    private Date orderDate;

    public Order() {
    }

    public Order(int orderId, String orderName, Date orderDate) {
        this.orderId = orderId;
        this.orderName = orderName;
        this.orderDate = orderDate;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public Date getOrderDate() {
        return orderDate;
    }

    public void setOrderDate(Date orderDate) {
        this.orderDate = orderDate;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderId=" + orderId +
                ", orderName='" + orderName + '\'' +
                ", orderDate=" + orderDate +
                '}';
    }
}

??其中，jdbc.properties配置文件声明同上；

四、操作BLOB类型字段

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

如果在指定了相关的Blob类型以后，还报错：xxx too large，那么在mysql的安装目录下，找my.ini文件加上如下的配置参数： max_allowed_packet=16M。同时注意：修改了my.ini文件之后，需要重新启动mysql服务。

package star.light;

import org.junit.Test;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;

public class BlobTest {

    @Test
    public void test07(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        InputStream inputStream = null;
        FileOutputStream fileOutputStream = null;
        ResultSet resultSet = null;

        try {
            connection = JDBCUtils.getConnection();
            String sql = "select id,name,email,birth,photo from customers where id = ?";
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1,19);

            resultSet = preparedStatement.executeQuery();
            if (resultSet.next()){
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                String email = resultSet.getString("email");
                Date birth = resultSet.getDate("birth");

                Customer customer = new Customer(id,name,email,birth);
                System.out.println(customer);

                Blob photo = resultSet.getBlob("photo");
                inputStream = photo.getBinaryStream();
                fileOutputStream = new FileOutputStream("./image/白钰袖.jpg");
                byte[] buffer = new byte[1024];
                int len;
                while((len = inputStream.read(buffer)) != -1){
                    fileOutputStream.write(buffer,0,len);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileOutputStream != null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            JDBCUtils.closeResource(connection,preparedStatement,resultSet);
        }
    }
}

??其中，jdbc.properties配置文件、JDBCUtils类、Customer类声明同上；

五、批量插入

5.1、批量执行SQL语句

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

void addBatch?(String sql) throws SQLException  //添加需要批量处理的SQL语句或是参数
int[] executeBatch() throws SQLException       //执行批量处理语句
void clearBatch() throws SQLException          //清空缓存的数据

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

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

??批量插入：

package star.light;

import org.junit.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.Statement;

public class InsertTest {

    //使用Statement    2255514
    @Test
    public void test01(){
        Connection connection = null;
        Statement statement = null;

        try {
            long start = System.currentTimeMillis();

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

            long end = System.currentTimeMillis();
            System.out.println("花费的时间为：" + (end-start));
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connection,statement);
        }
    }

    //使用PreparedStatement       2195188
    @Test
    public void test02(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;

        try {
            long start = System.currentTimeMillis();

            connection = JDBCUtils.getConnection();
            String sql = "insert into goods(name) values(?)";
            preparedStatement = connection.prepareStatement(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();
        }
        JDBCUtils.closeResource(connection,preparedStatement);
    }

    //mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。      10011
    // ?rewriteBatchedStatements=true 写在配置文件的url后面
    @Test
    public void test03(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;

        try {
            long start = System.currentTimeMillis();

            connection = JDBCUtils.getConnection();
            String sql = "insert into goods(name) values(?)";
            preparedStatement = connection.prepareStatement(sql);
            for (int i=1;i<=20000;i++){
                preparedStatement.setObject(1,"name_" + i);
                preparedStatement.addBatch();
                if (i%500 == 0){
                    preparedStatement.executeBatch();
                    preparedStatement.clearBatch();
                }
            }

            long end = System.currentTimeMillis();
            System.out.println("花费的时间为：" + (end-start));
        } catch (Exception e) {
            e.printStackTrace();
        }
        JDBCUtils.closeResource(connection,preparedStatement);
    }

    //设置连接不允许自动提交数据         4323
    @Test
    public void test04(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;

        try {
            long start = System.currentTimeMillis();

            connection = JDBCUtils.getConnection();
            connection.setAutoCommit(false);
            String sql = "insert into goods(name) values(?)";
            preparedStatement = connection.prepareStatement(sql);
            for (int i=1;i<=20000;i++){
                preparedStatement.setObject(1,"name_" + i);
                preparedStatement.addBatch();
                if (i%500 == 0){
                    preparedStatement.executeBatch();
                    preparedStatement.clearBatch();
                }
            }
            connection.commit();

            long end = System.currentTimeMillis();
            System.out.println("花费的时间为：" + (end-start));
        } catch (Exception e) {
            e.printStackTrace();
        }
        JDBCUtils.closeResource(connection,preparedStatement);
    }
}

六、数据库事务

6.1、数据库事务介绍

• 事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
• 事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。

??为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。

6.2、JDBC事务处理

• 数据一旦提交，就不可回滚。
• 数据什么时候意味着提交？
  • 当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个SQL语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
  • 关闭数据库连接，数据就会自动的提交。如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
• JDBC程序中为了让多个SQL语句作为一个事务执行：
  • 调用Connection对象的setAutoCommit(false); 以取消自动提交事务
  • 在所有的SQL语句都成功执行后，调用commit(); 方法提交事务
  • 在出现异常时，调用rollback(); 方法回滚事务

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

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

package star.light;

import org.junit.Test;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class TransactionTest {

    @Test
    public void test01() {
        Connection connection = null;

        try {
            // 1.获取数据库连接
            connection = JDBCUtils.getConnection();
            // 2.关闭自动提交
            connection.setAutoCommit(false);

            // 3.进行数据库操作
            String sql1 = "update user_table set balance = balance-100 where user = ?";
            update(connection,sql1,"AA");

            String sql2 = "update user_table set balance = balance+100 where user = ?";
            update(connection,sql2,"BB");

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

            // 4.若没有异常，则提交事务
            connection.commit();

            System.out.println("转账成功！");
        } catch (Exception e) {
            e.printStackTrace();
            // 5.若有异常，则回滚事务
            try {
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {
            //6.恢复每次DML操作的自动提交功能
            try {
                connection.setAutoCommit(true);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            //7.关闭连接
            JDBCUtils.closeResource(connection,null);
        }
    }

    //使用事务以后的通用的增删改操作
    public void update(Connection connection,String sql,Object ... args){
        PreparedStatement preparedStatement = null;

        try {
            //1.获取PreparedStatement的实例 (或：预编译sql语句)
            preparedStatement = connection.prepareStatement(sql);

            //2.填充占位符
            for(int i = 0;i < args.length;i++){
                preparedStatement.setObject(i + 1, args[i]);
            }

            //3.执行sql语句
            preparedStatement.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //4.关闭资源
            JDBCUtils.closeResource(null, preparedStatement);
        }
    }
}

??其中，jdbc.properties配置文件、JDBCUtils类声明同上；

6.3、事务的ACID属性

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

6.3.1、数据库的并发问题

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

• 脏读：对于两个事务T1、T2，T1读取了已经被T2更新但还没有被提交的字段。之后，若T2回滚，T1读取的内容就是临时且无效的
• 不可重复读：对于两个事务T1、T2，T1读取了一个字段, 然后T2更新了该字段。之后，T1再次读取同一个字段, 值就不同了。
• 幻读：对于两个事务T1、T2，T1从一个表中读取了一个字段，然后T2在该表中插入了一些新的行。之后，如果T1再次读取同一个表，就会多出几行。

??数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

6.3.2、四种隔离级别

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

• READ UNCOMMITTED（读未被提交数据）：允许事务读取未被其它事务提交的变更，脏读、不可重复读和幻读的问题都会出现；
• READ COMMITTED（读已提交数据）：只允许事务读取已经被其它事务提交的变更，可以避免脏读，但是不可重复读和幻读问题仍然可能存在；
• REPEATABLE READ（可重复读）：确保事务可以多次从一个字段中读取相同的值。在这个事务持续期间，禁止其它事务对这个字段进行更新，可以避免脏读和不可重复读，但幻读的问题仍然存在；
• SERIALIZABLE（串行化）：确保事务可以从一个表中读取相同的行。在这个事务持续期间，禁止其它事务对该表执行插入、更新和删除操作，所有的并发问题都可以避免，但性能十分低下；

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

6.3.3、在MySql中设置隔离级别

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

-- 查看当前的隔离级别: 
SELECT @@tx_isolation;                  -- MySQL 8.0之前的版本
SELECT @@transaction_isolation;         -- MySQL 8.0之后的版本

-- 设置当前MySQL连接的隔离级别: 
SET [GLOBAL|SESSION] TRANSACTION ISOLATION LEVEL 隔离级别;
/* 其中，隔离级别格式：READ UNCOMMITTED、READ COMMITTED 、REPEATABLE READ 、SERIALIZABLE */
SET [GLOBAL|SESSION] TRANSACTION_ISOLATION = '隔离级别';
/* 其中，隔离级别格式：READ-UNCOMMITTED、READ-COMMITTED、REPEATABLE-READ、SERIALIZABLE */

七、DAO及相关实现类

• DAO：Data Access Object访问数据信息的类和接口，包括了对数据的CRUD（Create、Retrival、Update、Delete），而不包含任何业务相关的信息。有时也称作：BaseDAO
• 作用：为了实现功能的模块化，更有利于代码的维护和升级。

package star.light;

import org.junit.Test;

import java.sql.Connection;
import java.sql.Date;
import java.text.SimpleDateFormat;
import java.util.List;

public class CustomerDAOImplementTest {
    CustomerDAOImplement dao = new CustomerDAOImplement();

    @Test
    public void insertTest() {
        Connection connection = null;

        try {
            connection = JDBCUtils.getConnection();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            java.util.Date date = simpleDateFormat.parse("1990-04-01");
            Customer customer = new Customer(20, "sakura", "sakura@gmail.com", new Date(date.getTime()));
            dao.insert(connection,customer);
            System.out.println("添加成功！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connection,null);
        }
    }

    @Test
    public void deleteByIdTest() {
        Connection connection = null;

        try {
            connection = JDBCUtils.getConnection();
            dao.deleteById(connection,12);
            System.out.println("删除成功！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connection,null);
        }
    }

    @Test
    public void updateTest() {
        Connection connection = null;

        try {
            connection = JDBCUtils.getConnection();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            java.util.Date date = simpleDateFormat.parse("1995-05-02");
            Customer customer = new Customer(3,"Mikoto","mikoto@gmail.com",new Date(date.getTime()));
            dao.update(connection,customer);
            System.out.println("修改成功！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connection,null);
        }
    }

    @Test
    public void getCustomerByIdTest() {
        Connection connection = null;

        try {
            connection = JDBCUtils.getConnection();
            Customer customer = dao.getCustomerById(connection,13);
            System.out.println(customer);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connection,null);
        }
    }

    @Test
    public void getAllTest() {
        Connection connection = null;

        try {
            connection = JDBCUtils.getConnection();
            List list = dao.getAll(connection);
            list.forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connection,null);
        }
    }

    @Test
    public void getCountTest() {
        Connection connection = null;

        try {
            connection = JDBCUtils.getConnection();
            long count = dao.getCount(connection);
            System.out.println("表中记录数为：" + count);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connection,null);
        }
    }

    @Test
    public void getMaxBirthTest() {
        Connection connection = null;

        try {
            connection = JDBCUtils.getConnection();
            Date date = dao.getMaxBirth(connection);
            System.out.println("最大的生日为：" + date);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connection,null);
        }
    }
}

package star.light;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public abstract class BaseDAO {
    private Class clazz = null;

    {
        Type genericSuperclass = this.getClass().getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType)genericSuperclass;
        Type[] typeArguments = paramType.getActualTypeArguments();              //获取父类的泛型
        clazz = (Class) typeArguments[0];                                    //泛型的第一个参数
    }

    //使用事务以后的通用的增删改操作
    public void update(Connection connection, String sql, Object ... args){
        PreparedStatement preparedStatement = null;

        try {
            //1.获取PreparedStatement的实例 (或：预编译sql语句)
            preparedStatement = connection.prepareStatement(sql);

            //2.填充占位符
            for(int i = 0;i < args.length;i++){
                preparedStatement.setObject(i + 1, args[i]);
            }

            //3.执行sql语句
            preparedStatement.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //4.关闭资源
            JDBCUtils.closeResource(null, preparedStatement);
        }
    }

    //使用事务以后的通用的增删改操作针对于不同表的查询:返回一个对象
    public  T getInstance(Connection connection, String sql, Object... args) {
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            // 1.预编译sql语句，得到PreparedStatement对象
            preparedStatement = connection.prepareStatement(sql);

            // 2.填充占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }

            // 3.执行executeQuery(),得到结果集：ResultSet
            resultSet = preparedStatement.executeQuery();

            // 4.得到结果集的元数据：ResultSetMetaData
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();

            // 5.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
            int columnCount = resultSetMetaData.getColumnCount();
            if (resultSet.next()) {
                T t = clazz.getConstructor().newInstance();
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columnVal = resultSet.getObject(i + 1);

                    // 获取列的别名:列的别名，使用类的属性名充当，如果没有取别名，获取的是列名
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);

                    // 5.2使用反射，给对象的相应属性赋值
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭资源
            JDBCUtils.closeResource(null, preparedStatement, resultSet);
        }
        return null;
    }
    // 使用事务以后的通用的针对于不同表的查询:返回一个对象
    public List getForList(Connection connection, String sql, Object... args){
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            // 1.预编译sql语句，得到PreparedStatement对象
            preparedStatement = connection.prepareStatement(sql);

            // 2.填充占位符
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i + 1, args[i]);
            }

            // 3.执行executeQuery(),得到结果集：ResultSet
            resultSet = preparedStatement.executeQuery();

            // 4.得到结果集的元数据：ResultSetMetaData
            ResultSetMetaData resultSetMetaData = resultSet.getMetaData();

            // 5.1通过ResultSetMetaData得到columnCount,columnLabel；通过ResultSet得到列值
            int columnCount = resultSetMetaData.getColumnCount();
            //创建集合对象
            ArrayList list = new ArrayList();
            while (resultSet.next()) {
                T t = clazz.getConstructor().newInstance();
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columnVal = resultSet.getObject(i + 1);

                    // 获取列的别名:列的别名，使用类的属性名充当，如果没有取别名，获取的是列名
                    String columnLabel = resultSetMetaData.getColumnLabel(i + 1);

                    // 5.2使用反射，给对象的相应属性赋值
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnVal);
                }
                list.add(t);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭资源
            JDBCUtils.closeResource(null, preparedStatement, resultSet);
        }
        return null;
    }

    //用于查询特殊值的通用方法
    public E getValue(Connection connection,String sql,Object... args){
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            preparedStatement = connection.prepareStatement(sql);
            for (int i=0;i

package star.light;

import java.sql.Connection;
import java.sql.Date;
import java.util.List;

//此接口用于规范对于Customer表的常用操作
public interface CustomerDAO {
    void insert(Connection connection,Customer customer);       //将customer对象添加到数据库中
    void deleteById(Connection connection,int id);              //针对指定的id删除表中的记录
    void update(Connection connection,Customer customer);       //针对内存中的customer对象修改数据表中的记录
    Customer getCustomerById(Connection connection,int id);     //针对指定的id查询得到对应的Customer对象
    List getAll(Connection connection);               //查询表中所有记录构成的集合
    long getCount(Connection connection);                       //返回数据表中数据的条目数
    Date getMaxBirth(Connection connection);                    //返回数据表中最大的生日
}

package star.light;

import java.sql.Connection;
import java.sql.Date;
import java.util.List;

public class CustomerDAOImplement extends BaseDAO implements CustomerDAO {

    @Override
    public void insert(Connection connection, Customer customer) {
        String sql = "insert into customers(name,email,birth) values(?,?,?)";
        update(connection,sql,customer.getName(),customer.getEmail(),customer.getBirth());
    }

    @Override
    public void deleteById(Connection connection, int id) {
        String sql = "delete from customers where id = ?";
        update(connection,sql,id);
    }

    @Override
    public void update(Connection connection, Customer customer) {
        String sql = "update customers set name = ?,email = ?,birth = ? where id = ?";
        update(connection,sql,customer.getName(),customer.getEmail(),customer.getBirth(),customer.getId());
    }

    @Override
    public Customer getCustomerById(Connection connection, int id) {
        String sql = "select id,name,email,birth from customers where id = ?";
        Customer customer = getInstance(connection, sql, id);
        return customer;
    }

    @Override
    public List getAll(Connection connection) {
        String sql = "select id,name,email,birth from customers";
        List list = getForList(connection, sql);
        return list;
    }

    @Override
    public long getCount(Connection connection) {
        String sql = "select count(*) from customers";
        return getValue(connection,sql);
    }

    @Override
    public Date getMaxBirth(Connection connection) {
        String sql = "select max(birth) from customers";
        return getValue(connection,sql);
    }
}

package star.light;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;

import java.sql.Connection;

public class C3P0Test {

    //方法一：
    @Test
    public void test01() throws Exception {

        //获取C3P0数据库连接池
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        comboPooledDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbc_learn");
        comboPooledDataSource.setUser("root");
        comboPooledDataSource.setPassword("abc123");

        //通过设置相关的参数对数据库连接池进行管理
        comboPooledDataSource.setInitialPoolSize(10);       //设置初始时数据库连接池中的连接数

        Connection connection = comboPooledDataSource.getConnection();
        System.out.println(connection);

//        DataSources.destroy(comboPooledDataSource);         //销毁C3P0数据库连接池
    }

    //方法二：使用配置文件
    @Test
    public void test02() throws Exception {
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("c3p0");
        Connection connection = comboPooledDataSource.getConnection();
        System.out.println(connection);
    }
}

<?xml version="1.0" encoding="UTF-8"?>

    
        
        com.mysql.cj.jdbc.Driver
        jdbc:mysql://localhost:3306/jdbc_learn
        root
        abc123

        
        
        5
        
        5
        
        5
        
        10
        
        30
        
        3
    

package star.light;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;
import org.junit.Test;

import javax.sql.DataSource;
import java.io.File;
import java.io.FileInputStream;
import java.sql.Connection;
import java.util.Properties;


public class DBCPTest {

    //方法一
    @Test
    public void test01() throws Exception {
        //创建DBCP数据库连接池
        BasicDataSource dataSource = new BasicDataSource();

        //设置基本信息
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/jdbc_learn");
        dataSource.setUsername("root");
        dataSource.setPassword("abc123");

        //设置数据库连接池管理的相关属性
        dataSource.setInitialSize(10);
        dataSource.setMaxActive(15);

        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }

    //方式二：使用配置文件
    @Test
    public void test02() throws Exception {
        Properties properties = new Properties();
        FileInputStream fileInputStream = new FileInputStream(new File("src/dbcp.properties"));
        properties.load(fileInputStream);
        DataSource dataSource = BasicDataSourceFactory.createDataSource(properties);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }
}

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbc_learn
username=root
password=abc123

package star.light;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.junit.Test;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;

public class DruidTest {

    @Test
    public void test01() throws Exception {
        Properties properties = new Properties();
        InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
        properties.load(inputStream);
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
    }
}

driveClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbc_learn
username=root
password=abc123

package star.light;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;

import java.sql.Connection;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

public class QueryRunnerTest {

    @Test
    public void testInsert(){
        Connection connection = null;

        try {
            QueryRunner queryRunner = new QueryRunner();
            connection = JDBCUtilsByDruid.getConnection();
            String sql = "insert into customers(name,email) values(?,?)";
            queryRunner.update(connection,sql,"Rimuru","rimuru@gmail.com");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtilsByDruid.closeResource(connection,null);
        }
    }

    //BeanHander：是ResultSetHandler接口的实现类，用于封装表中的一条记录
    @Test
    public void testQuery01() {
        Connection connection = null;

        try {
            QueryRunner queryRunner = new QueryRunner();
            connection = JDBCUtilsByDruid.getConnection();
            String sql = "select id,name,email,birth from customers where id = ?";
            BeanHandler handler = new BeanHandler<>(Customer.class);
            Customer customer = queryRunner.query(connection, sql, handler, 12);
            System.out.println(customer);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtilsByDruid.closeResource(connection,null);
        }
    }

    //BeanListHandler：是ResultSetHandler接口的实现类，用于封装表中的多条记录构成的集合
    @Test
    public void testQuery02() {
        Connection connection = null;

        try {
            QueryRunner queryRunner = new QueryRunner();
            connection = JDBCUtilsByDruid.getConnection();
            String sql = "select id,name,email,birth from customers where id > ?";
            BeanListHandler handler = new BeanListHandler<>(Customer.class);
            List list = queryRunner.query(connection, sql, handler, 12);
            list.forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtilsByDruid.closeResource(connection,null);
        }
    }

    //MapHandler：是ResultSetHandler接口的实现类，对应表中的一条记录，将字段及相应字段的值作为map中的key和value
    @Test
    public void testQuery03() {
        Connection connection = null;

        try {
            QueryRunner queryRunner = new QueryRunner();
            connection = JDBCUtilsByDruid.getConnection();
            String sql = "select id,name,email,birth from customers where id = ?";
            MapHandler handler = new MapHandler();
            Map map = queryRunner.query(connection, sql, handler, 10);
            System.out.println(map);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtilsByDruid.closeResource(connection,null);
        }
    }

    //MapListHandler：是ResultSetHandler接口的实现类，对应表中多条记录，将字段及相应字段的值作为map中的key和value，将这些map添加到list中
    @Test
    public void testQuery04() {
        Connection connection = null;

        try {
            QueryRunner queryRunner = new QueryRunner();
            connection = JDBCUtilsByDruid.getConnection();
            String sql = "select id,name,email,birth from customers where id < ?";
            MapListHandler handler = new MapListHandler();
            List> list = queryRunner.query(connection, sql, handler, 12);
            list.forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtilsByDruid.closeResource(connection,null);
        }
    }

    //ScalarHandler用于查询特殊值
    @Test
    public void testQuery05() {
        Connection connection = null;

        try {
            QueryRunner queryRunner = new QueryRunner();
            connection = JDBCUtilsByDruid.getConnection();
            String sql = "select count(*) from customers";
            ScalarHandler handler = new ScalarHandler();
            long count = (long) queryRunner.query(connection, sql, handler);
            System.out.println(count);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtilsByDruid.closeResource(connection,null);
        }
    }

    @Test
    public void testQuery06() {
        Connection connection = null;

        try {
            QueryRunner queryRunner = new QueryRunner();
            connection = JDBCUtilsByDruid.getConnection();
            String sql = "select max(birth) from customers";
            ScalarHandler handler = new ScalarHandler();
            Date date = (Date) queryRunner.query(connection, sql, handler);
            System.out.println(date);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtilsByDruid.closeResource(connection,null);
        }
    }

    //自定义ResultSetHandler接口的实现类
    @Test
    public void testQuery07(){
        Connection connection = null;

        try {
            QueryRunner queryRunner = new QueryRunner();
            connection = JDBCUtilsByDruid.getConnection();
            String sql = "select id,name,email,birth from customers where id = ?";
            ResultSetHandler handler = new ResultSetHandler() {
                @Override
                public Customer handle(ResultSet resultSet) throws SQLException {
                    if (resultSet.next()){
                        int id = resultSet.getInt("id");
                        String name = resultSet.getString("name");
                        String email = resultSet.getString("email");
                        Date birth = resultSet.getDate("birth");
                        Customer customer = new Customer(id, name, email, birth);
                        return customer;
                    }
                    return null;
                }
            };
            Customer customer = queryRunner.query(connection, sql, handler,7);
            System.out.println(customer);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtilsByDruid.closeResource(connection,null);
        }
    }
}

package star.light;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.commons.dbutils.DbUtils;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Properties;

public class JDBCUtilsByDruid {
    private static DataSource dataSource = null;

    static {
        try {
            Properties properties = new Properties();
            InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
            properties.load(inputStream);
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws Exception {
        Connection connection = dataSource.getConnection();
        return connection;
    }

    //使用dbutils.jar中提供的Dbutils工具类，实现资源的关闭
    public static void closeResource(Connection connection, Statement statement){
        DbUtils.closeQuietly(connection);
        DbUtils.closeQuietly(statement);
    }

    public static void closeResource(Connection connection, Statement statement, ResultSet resultSet) {
        DbUtils.closeQuietly(connection);
        DbUtils.closeQuietly(statement);
        DbUtils.closeQuietly(resultSet);
    }
}

DROP DATABASE IF EXISTS `jdbc_learn`;
CREATE DATABASE IF NOT EXISTS `jdbc_learn` 
USE `jdbc_learn`;

-- 导出  表 jdbc_learn.customers 结构
DROP TABLE IF EXISTS `customers`;
CREATE TABLE IF NOT EXISTS `customers` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(15) DEFAULT NULL,
  `email` varchar(20) DEFAULT NULL,
  `birth` date DEFAULT NULL,
  `photo` mediumblob,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

-- 正在导出表  jdbc_learn.customers 的数据：~0 rows (大约)
INSERT INTO `customers` (`id`, `name`, `email`, `birth`, `photo`) VALUES
	(1, '汪峰', 'wf@126.com', '2010-02-02', NULL),
	(2, '王菲', 'wangf@163.com', '1988-12-26', NULL),
	(3, '林志玲', 'linzl@gmail.com', '1984-06-12', NULL),
	(4, '汤唯', 'tangw@sina.com', '1986-06-13', NULL),
	(5, '成龙', 'Jackey@gmai.com', '1955-07-14', NULL),
	(6, '迪丽热巴', 'reba@163.com', '1983-05-17', NULL),
	(7, '刘亦菲', 'liuyifei@qq.com', '1991-11-14', NULL),
	(8, '陈道明', 'bdf@126.com', '2014-01-17', NULL),
	(10, '周杰伦', 'zhoujl@sina.com', '1979-11-15', NULL),
	(12, '黎明', 'LiM@126.com', '1998-09-08', NULL),
	(13, '张学友', 'zhangxy@126.com', '1998-12-21', NULL),
	(16, '朱茵', 'zhuyin@126.com', '2014-01-16', NULL),
	(18, '贝多芬', 'beidf@126.com', '2014-01-17', NULL);

-- 导出  表 jdbc_learn.examstudent 结构
DROP TABLE IF EXISTS `examstudent`;
CREATE TABLE IF NOT EXISTS `examstudent` (
  `FlowID` int NOT NULL AUTO_INCREMENT,
  `Type` int DEFAULT NULL,
  `IDCard` varchar(18) DEFAULT NULL,
  `ExamCard` varchar(15) DEFAULT NULL,
  `StudentName` varchar(20) DEFAULT NULL,
  `Location` varchar(20) DEFAULT NULL,
  `Grade` int DEFAULT NULL,
  PRIMARY KEY (`FlowID`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=gb2312;

-- 正在导出表  jdbc_learn.examstudent 的数据：~0 rows (大约)
INSERT INTO `examstudent` (`FlowID`, `Type`, `IDCard`, `ExamCard`, `StudentName`, `Location`, `Grade`) VALUES
	(1, 4, '412824195263214584', '200523164754000', '张锋', '郑州', 85),
	(2, 4, '222224195263214584', '200523164754001', '孙朋', '大连', 56),
	(3, 6, '342824195263214584', '200523164754002', '刘明', '沈阳', 72),
	(4, 6, '100824195263214584', '200523164754003', '赵虎', '哈尔滨', 95),
	(5, 4, '454524195263214584', '200523164754004', '杨丽', '北京', 64),
	(6, 4, '854524195263214584', '200523164754005', '王小红', '太原', 60);

-- 导出  表 jdbc_learn.order 结构
DROP TABLE IF EXISTS `order`;
CREATE TABLE IF NOT EXISTS `order` (
  `order_id` int NOT NULL AUTO_INCREMENT,
  `order_name` varchar(20) DEFAULT NULL,
  `order_date` date DEFAULT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

-- 正在导出表  jdbc_learn.order 的数据：~0 rows (大约)
INSERT INTO `order` (`order_id`, `order_name`, `order_date`) VALUES
	(1, 'AA', '2010-03-04'),
	(2, 'BB', '2000-02-01'),
	(4, 'GG', '1994-06-28');

-- 导出  表 jdbc_learn.user 结构
DROP TABLE IF EXISTS `user`;
CREATE TABLE IF NOT EXISTS `user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(10) NOT NULL,
  `password` varchar(15) NOT NULL DEFAULT '123456',
  `address` varchar(25) DEFAULT NULL,
  `phone` varchar(15) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

-- 正在导出表  jdbc_learn.user 的数据：~5 rows (大约)
INSERT INTO `user` (`id`, `name`, `password`, `address`, `phone`) VALUES
	(1, '章子怡', 'qwerty', 'Beijing', '13788658672'),
	(2, '郭富城', 'abc123', 'HongKong', '15678909898'),
	(3, '林志玲', '654321', 'Taiwan', '18612124565'),
	(4, '梁静茹', '987654367', 'malaixiya', '18912340998'),
	(5, 'LadyGaGa', '123456', 'America', '13012386565');

-- 导出  表 jdbc_learn.user_table 结构
DROP TABLE IF EXISTS `user_table`;
CREATE TABLE IF NOT EXISTS `user_table` (
  `user` varchar(20) DEFAULT NULL,
  `password` varchar(20) DEFAULT NULL,
  `balance` int DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

-- 正在导出表  jdbc_learn.user_table 的数据：~4 rows (大约)
INSERT INTO `user_table` (`user`, `password`, `balance`) VALUES
	('AA', '123456', 1000),
	('BB', '654321', 1000),
	('CC', 'abcd', 2000),
	('DD', 'abcder', 3000);