文章目录

• 🥽 视频链接及资源下载
• 🥽 JDBC简介
• 🥽 JDBC程序访问数据库步骤
• 🥽 获取数据库连接
• • 🌊 导入jar包
  • 🌊 Driver 接口
  • 🌊 JDBC URL
  • 🌊 方式1：
  • 🌊 方式2：
  • 🌊 方式3：
  • 🌊 方式4：
  • 🌊 方式5(final版)：
  • 🌊 连接报错：
  • • 💦 Cause: java.sql.SQLException: Unknown initial character set index '255' received from server.
• 🥽 使用Statement操作数据表的弊端【了解】
• 🥽 PreparedStatement
• • 🌊 PreparedStatement 实现表数据的添加
  • 🌊 数据库连接与关闭操作的封装
  • 🌊 PreparedStatement 实现数据的修改
  • 🌊 PreparedStatement 实现通用的增删改操作
  • 🌊 PreparedStatement 实现数据的查询
  • 🌊 实现通用的查询操作
  • • 💦 ORM编程思想
    • 💦 Java与SQL对应数据类型
    • 💦 针对customers表的通用查询操作
    • 💦 针对order表的通用查询操作
    • 💦 查询过程图解
    • 💦 针对不同表的通用查询操作
  • 🌊 PreparedStatement 解决SQL注入问题
• 🥽 PreparedStatement操作Blob类型的数据
• • 🌊 MySQL BLOB类型
  • 🌊 插入Blob类型的数据
  • 🌊 读取Blob类型的数据
• 🥽 PreparedStatement批量插入数据
• • 🌊 使用PreparedStatement
  • 🌊 使用 addBatch() / executeBatch() / clearBatch()
  • 🌊 修改事务提交的时机
• 🥽 数据库事务
• • 🌊 数据库事务介绍
  • 🌊 考虑事务后的转账操作实现
  • 🌊 事务的ACID属性
  • 🌊 数据库的并发问题
  • 🌊 四种隔离级别
• 🥽 DAO及相关实现类
• • 🌊 BaseDAO
  • 🌊 BaseDAO(泛型+反射)
• 🥽 数据库连接池
• • 🌊 数据库连接池简介
  • 🌊 C3P0数据库连接池
  • • 💦 方式一
    • 💦 方式二：使用配置文件
  • 🌊 DBCP
  • • 💦 方式一
    • 💦 方式二：使用配置文件
    • 💦 dbcp连接池常用基本配置属性
  • 🌊 Druid
  • • 💦 使用配置文件获取链接
    • 💦 Druid连接池常用基本配置属性
• 🥽 Apache-DBUtils实现CRUD操作
• • 🌊 QueryRunner类
  • 🌊 ResultSetHandler接口及实现类
  • 🌊 插入数据
  • 🌊 查询数据
  • 🌊 查询特殊值
  • 🌊 自定义ResultSetHandler的实现类

---

🥽 视频链接及资源下载

视频：【尚硅谷JDBC核心技术视频教程（康师傅带你一站式搞定jdbc）】

资源下载：【百度网盘】
提取码：1234

---

🥽 JDBC简介

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

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

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

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

JDBC API 是一系列的接口，它使得应用程序能够进行数据库连接，执行SQL语句，并且得到返回结果。Java程序员只需要面向这套接口编程即可。

---

🥽 JDBC程序访问数据库步骤

1. 导入对应的包和驱动
2. 创建连接数据库的驱动对象
3. 加载注册连接数据库的驱动
4. 通过驱动获取连接数据库的对象
5. 通过连接数据库的对象获取执行SQL语句的对象
6. 执行SQL语句得到结果集对象
7. 关闭对应的对象和连接

---

🥽 获取数据库连接

🌊 导入jar包

【MySQL JDBC下载官网】

压缩包下载到本地后解压，在IDE项目根目录下新建lib目录

把下载的压缩包解压后的jar包复制到lib目录下

复制完成后鼠标右键jar包，添加为库

🌊 Driver 接口

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

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

• Oracle的驱动：oracle.jdbc.driver.OracleDriver
• mySql的驱动： com.mysql.jdbc.Driver
• …

🌊 JDBC URL

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

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

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

• 对于 Oracle 数据库连接，采用如下形式：
  jdbc:oracle:thin:@localhost:1521:atguigu
• 对于 SQLServer 数据库连接，采用如下形式：
  jdbc:microsoft:sqlserver//localhost:1433; DatabaseName=sid
• 对于 MYSQL 数据库连接，采用如下形式：
  jdbc:mysql://localhost:3306/atguigu
• …

🌊 方式1：

如有报错后面的解决方法可能会有帮助

    @Test
    public void testConnection1() throws Exception {
        // 获取 Driver 驱动对象
        Driver driver = new com.mysql.jdbc.Driver();
        // 配置获取连接数据对象需要的信息
        // url:http://localhost:8080/gmall/keyboard.jpg
        // jdbc:mysql:协议
        // localhost:ip地址
        // 3306：默认mysql的端口号
        // test:test数据库
        
        // 字符集与数据库不一致  ?characterEncoding=utf8  设置字符集
        String url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf8";
        // 将用户名和密码封装到Properties对象中
        Properties info = new Properties();
        info.setProperty("user", "root");
        info.setProperty("password", "123456");
        // 通过驱动对象根据配置信息获取连接数据库的对象
        Connection connection = driver.connect(url, info);
        // 打印连接对象，查看是否连接成功
        System.out.println(connection);
    }

🌊 方式2：

对方式一的迭代：在如下的程序中不出现第三方的api,使得程序具有更好的可移植性

    @Test
    public void testConnection2() throws Exception {
        // 获取 Driver 驱动对象
        // 使用反射
        // 获取连接数据库驱动的类
        Class clazz = Class.forName("com.mysql.jdbc.Driver");
        // 通过连接驱动的类创建连接驱动Driver对象
        Driver driver = (Driver) clazz.newInstance();
        // 数据库的url
        String url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf8";
        // 连接数据库需要的用户信息配置对象
        Properties info = new Properties();
        info.setProperty("user", "root");
        info.setProperty("password", "123456");
        // 获取连接数据库的对象
        Connection connection = driver.connect(url, info);
        System.out.println(connection);
    }

🌊 方式3：

使用DriverManager替换Driver

DriverManager 类是驱动程序管理器类，负责管理驱动程序

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

	@Test
    public void testConnection3() throws Exception {
        // 获取 Driver 驱动对象
        // 使用反射
        Class clazz = Class.forName("com.mysql.jdbc.Driver");
        Driver driver = (Driver) clazz.newInstance();
        // 连接数据库的配置信息
        String url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf8";
        String user = "root";
        String password = "285013";
        // 通过 DriverManager 注册驱动
        DriverManager.registerDriver(driver);
        // 通过 DriverManager 获取连接对象
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
    }

🌊 方式4：

可以只是加载驱动，不用显示的注册驱动，因为在加载驱动时候就会进行驱动的注册。

    @Test
    public void testConnection4() throws Exception {
        // 连接需要的三个基本信息
        String url = "jdbc:mysql://localhost:3306/test?characterEncoding=utf8";
        String user = "root";
        String password = "123456";

        // 使用反射加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 相较于方式3，省略了如下操作
        // Driver driver = (Driver) clazz.newInstance();
        // 通过 DriverManager 注册驱动
        // DriverManager.registerDriver(driver);

        // 通过驱动管理获取数据库的连接
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
    }

可以省略的原因：
在mysql的Driver实现类中，声明了如下的操作：

static {
	try {
		java.sql.DriverManager.registerDriver(new Driver());
	} catch (SQLException E) {
		throw new RuntimeException("Can't register driver!");
	}
}

🌊 方式5(final版)：

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

此种方式的好处：

1. 实现了数据与代码的分离。实现了解耦
2. 如果需要修改配置文件信息，可以避免程序重新打包。

配置文件：
配置文件在src下，等号两边不能有空格！！！！！！

user=root
password=123456
url=jdbc:mysql://localhost:3306/test?characterEncoding=utf8
driverClass=com.mysql.jdbc.Driver

    @Test
    public void testConnection5() throws Exception {
        // 通过反射获取读取配置文件的输入流
        InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
        // 配置信息对象
        Properties properties = new Properties();
        properties.load(is); // 加载配置信息
        // 得到配置信息
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driverClass = properties.getProperty("driverClass");
        // 加载驱动
        Class.forName(driverClass);
        // 获取连接
        Connection connection = DriverManager.getConnection(url, user, password);
        System.out.println(connection);
    }

🌊 连接报错：

💦 Cause: java.sql.SQLException: Unknown initial character set index ‘255’ received from server.

Cause: java.sql.SQLException: Unknown initial character set index '255' received from server.

【解决方法博客链接】

---

🥽 使用Statement操作数据表的弊端【了解】

使用Statement的弊端：

• 需要拼写sql语句
• 存在SQL注入的问题

如何避免出现sql注入：只要用 PreparedStatement(从Statement扩展而来) 取代 Statement

SQL 注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的 SQL 语句段或命令

User 类：

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;
    }

}

StatementTest 测试类：

public class StatementTest {

    // 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题
    //如何避免出现sql注入：只要用 PreparedStatement(从Statement扩展而来) 取代 Statement
    @Test
    public void testLogin() {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入用户名：");
        String user = 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'
        String sql = "SELECT user,password FROM user_table WHERE user = '"+ user +"' AND password = '"+ password +"'";
        User returnUser = get(sql, User.class);
        if(returnUser != null){
            System.out.println("登录成功");
        }else{
            System.out.println("用户名不存在或密码错误");
        }
    }

    // 使用Statement实现对数据表的查询操作
    public <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;
    }

}

当输入的用户名为：1' or 密码为：=1 or '1' = '1就会造成SQL注入问题

因为此时进行字符串拼接完成后，需要执行的SQL语句变为：

SELECT user,password 
FROM user_table 
WHERE user = '1' or ' AND password = '=1 or '1' = '1'

判断是否成立的条件有原来的两个条件相与变为三个条件相或：

   	user = '1' 
or 	' AND password = '=1 
or 	'1' = '1'

其中 '1' = '1'一定成立，此时不管账号密码是否正确一定可以登录系统。

以上就是SQL注入问题。

---

🥽 PreparedStatement

🌊 PreparedStatement 实现表数据的添加

package preparedstatement;

import org.junit.Test;

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

public class PreparedStatementUpdate {
	// 向customers表中添加一条数据
    @Test
    public void testInsert() throws Exception {
		// 通过类加载器获取输入流
        InputStream is = PreparedStatementUpdate.class.getClassLoader().getResourceAsStream("jdbc.properties");
		// 创建数据库配置信息对象
        Properties properties = new Properties();
        properties.load(is); // 加载配置信息
		// 得到配置信息
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driverClass = properties.getProperty("driverClass");
		// 加载驱动
        Class.forName(driverClass);
		// 获取数据库的连接对象
        Connection conn = DriverManager.getConnection(url, user, password);
		// 预编译SQL语句，返回PreparedStatement实例对象
		// sql语句
		// ? 为占位符
        String sql = "INSERT INTO customers(name, email, birth) VALUES (?, ?, ?);";
		// 通过连接对象获取 PreparedStatement 对象
        PreparedStatement ps = conn.prepareStatement(sql);
		// 填充占位符 第一个参数为填充占位符的索引(从1开始), 第二个参数为填充到占位符的数据
        ps.setString(1, "ZS");
        ps.setString(2, "zs@qq.com");
        ps.setString(3, "1000-10-10");
		// 执行操作
        ps.execute();
		// 资源的关闭
        ps.close();
        conn.close();
    }
}

SELECT * FROM customers
WHERE name = 'ZS';

🌊 数据库连接与关闭操作的封装

package utils;

import preparedstatement.PreparedStatementUpdate;

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

/**
 * 操作数据库的工具类
 */
public class JDBCUtils {

    /**
     * 获取数据库的连接
     * @return
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
		// 通过类加载器获取输入流
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
		// 创建数据库配置信息对象
        Properties properties = new Properties();
        properties.load(is); // 加载配置信息
		// 得到配置信息
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        String url = properties.getProperty("url");
        String driverClass = properties.getProperty("driverClass");
		// 加载驱动
        Class.forName(driverClass);
		// 获取数据库的连接对象
        Connection conn = DriverManager.getConnection(url, user, password);
		// 返回连接对象
        return conn;
    }

    /**
     * 关闭资源操作
     * @param connection
     * @param ps
     */
    public static void closeResource(Connection connection, Statement ps) {
    	// 如果存在Statement或Statement的子类对象，进行关闭操作
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        // 进行数据库的关闭
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

🌊 PreparedStatement 实现数据的修改

    // 修改customers表中的一条数据
    @Test
    public void testUpdate() {
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            // 获取数据库的连接
            connection = JDBCUtils.getConnection();
            // 预编译sql语句，返回PreparedStatement实例对象
            String sql = "update customers set name=? where id=?";
            ps = connection.prepareStatement(sql);
            // 填充占位符
            ps.setObject(1, "莫扎特");
            ps.setObject(2, 18);
            // 执行sql
            Boolean res = ps.execute();
        } catch (Exception e) {
            e.fillInStackTrace();
        } finally {
            // 资源关闭
            JDBCUtils.closeResource(connection, ps);
        }
    }

🌊 PreparedStatement 实现通用的增删改操作

	// 通用的增删改操作
    public void update(String sql, Object ...args) {
        Connection connection = null;
        PreparedStatement ps = null;
        try {
            // 获取数据库的连接
            connection = JDBCUtils.getConnection();
            // 预编译sql，获取PreparedStatement实例对象
            ps = connection.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i+1, args[i]); // 由于不知道填充占位的数据是什么类型所以使用setObject
            }
            // 执行sql
            ps.execute();
        } catch (Exception e) {
            e.fillInStackTrace();
        } finally {
            // 关闭资源
            JDBCUtils.closeResource(connection, ps);
        }
    }

    @Test
    public void test() {
        String sql = "delete from customers where id=?";
        update(sql, 3);
    }

🌊 PreparedStatement 实现数据的查询

JDBCUtils中新增关闭资源的方法：

    /**
     * 关闭资源操作
     * @param connection
     * @param ps
     * @param rs
     */
    public static void closeResource(Connection connection, Statement ps, ResultSet rs) {
        // 如果存在Statement或Statement的子类对象，进行关闭操作
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        // 进行数据库的关闭
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
        // 进行结果集的关闭
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }

    @Test
    public void testQuery1() {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        try {
            // 获取数据库的连接
            connection = JDBCUtils.getConnection();
            // 预编译sql，获取PreparedStatement实例对象
            String sql = "select id, name, email from customers where id=?";
            ps = connection.prepareStatement(sql);
            // 填充占位符
            ps.setObject(1, 1);
            // 执行sql获取结果集
            resultSet = ps.executeQuery();
            // 处理结果集
            while (resultSet.next()) { // 判断结果集的下一条是否有数据，有数据返回true并指针下移，如果返回false指针不会下移
                // 获取当前这条数据的各个字段值
                int id = resultSet.getInt(1); // 获取第一个字段的值(从1开始)
                String name = resultSet.getString(2);
                String email = resultSet.getString(3);
                System.out.println(id + ": " + name + " " + email);
            }
        } catch (Exception e) {
            e.fillInStackTrace();
        } finally {
            // 关闭资源
            JDBCUtils.closeResource(connection, ps, resultSet);
        }
    }

🌊 实现通用的查询操作

💦 ORM编程思想

• 一个数据表对应一个Java类；
• 表中的一条记录对应Java类的一个对象；
• 表中的一个字段对应Java类的一个属性。

💦 Java与SQL对应数据类型

💦 针对customers表的通用查询操作

customers表对应的Java类

package preparedstatement;

import java.sql.Date;

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

    @Override
    public String toString() {
        return "Customer{" + "id=" + id + ", name='" + name + '\'' + ", email='" + email + '\'' + ", 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;
    }

    public Customer() {
    }

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

针对customers表的通用查询操作的方法

    public ArrayList<Customer> queryForCustomers(String sql, Object ...args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        ArrayList<Customer> customers = new ArrayList<>(); // 返回的数据对象
        try {
            // 获取数据库连接
            connection = JDBCUtils.getConnection();
            // 预编译sql获取PreparedStatement实例对象
            ps = connection.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i+1, args[i]);
            }
            // 执行sql获取结果集
            rs = ps.executeQuery();
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取结果集的列数
            int columnCount = rsmd.getColumnCount();
            // 处理结果集
            while (rs.next()) { // 如果还有下一条数据
                // 创建表行数据对应的对象
                Customer customer = new Customer();
                // 获取当前这条数据的每个字段
                for (int i = 0; i < columnCount; i++) {
                    Object columnValue = rs.getObject(i + 1);
                    // 获取当前列的列名
                    String columnName = rsmd.getColumnName(i + 1);
                    // 给Customer对象指定的columnName属性赋值 通过反射
                    Field field = Customer.class.getDeclaredField(columnName);
                    field.setAccessible(true);
                    field.set(customer, columnValue); // 把customer对象的属性赋值为columnValue
                }
                customers.add(customer);
            }
        } catch (Exception e) {
            e.fillInStackTrace();
        } finally {
            // 关闭资源
            JDBCUtils.closeResource(connection, ps, rs);
        }
        return customers;
    }

    @Test
    public void testQueryForCustomers() {
        String sql = "select id, name, email from customers where id=?";
        ArrayList<Customer> customers = queryForCustomers(sql, 13);
        for (int i = 0; i < customers.size(); i++) {
            System.out.println(customers.get(i));
        }
    }

💦 针对order表的通用查询操作

order表对应的Java类

package preparedstatement;

import java.sql.Date;

public class Order {
    private int orderId;
    private String orderName;
    private Date 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;
    }

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

针对order表的通用查询操作的方法

	// 针对与表的字段名和类的属性名不一致的情况，
	// 声明sql时使用类的属性名作为字段的别名，
	// 使用getColumnLabel获取列的别名
	// 如果没有取别名getColumnLabel获取的是列名

    public ArrayList<Order> queryForOrder(String sql, Object ...args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        ArrayList<Order> orders = new ArrayList<>();
        try {
            connection = JDBCUtils.getConnection();
            ps = connection.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i+1, args[i]);
            }
            rs = ps.executeQuery();
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取结果集中的列数
            int columnCount = rsmd.getColumnCount();
            while (rs.next()) {
                Order order = new Order();
                for (int i = 0; i < columnCount; i++) {
                    // 获取每个列的列值
                    Object columnValue = rs.getObject(i + 1);
                    // 获取列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    // 获取列的别名
                    String columnLabel = rsmd.getColumnLabel(i + 1);
                    // 通过反射将对象指定列名columnName的属性赋值为columnValue
                    Field field = Order.class.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(order, columnValue); // 赋值
                }
                orders.add(order);
            }
        } catch (Exception e) {
            e.fillInStackTrace();
        } finally {
            JDBCUtils.closeResource(connection, ps, rs);
        }
        return orders;
    }

    @Test
    public void testQueryForOrder() {
        String sql = "select order_id orderId, order_name orderName, order_date orderDate from `order` where order_id=?";
        ArrayList<Order> orders = queryForOrder(sql, 1);
        for (int i = 0; i < orders.size(); i++) {
            System.out.println(orders.get(i));
        }
    }

💦 查询过程图解

💦 针对不同表的通用查询操作

    /**
     * 泛型方法
     * @param tClass 指定返回的数据对应的Class
     * @param sql
     * @param args 填充sql语句的参数
     * @return 返回查询结果
     * @param <T> 指定返回数据对应的类
     */
    public <T> ArrayList<T> query(Class<T> tClass, String sql, Object ...args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        ArrayList<T> ts = new ArrayList<>(); // 用于存储查询结果数据
        try {
            connection = JDBCUtils.getConnection(); // 获取连接对象
            ps = connection.prepareStatement(sql); // 预编译sql获取prepareStatement对象
            for (int i = 0; i < args.length; i++) { // 填充参数
                ps.setObject(i+1, args[i]);
            }
            rs = ps.executeQuery(); // 获取结果集
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取结果集中的列数
            int columnCount = rsmd.getColumnCount();
            while (rs.next()) {
                T t = tClass.newInstance(); // 实例化对应的对象
                for (int i = 0; i < columnCount; i++) {
                    // 获取每个列的列值
                    Object columnValue = rs.getObject(i + 1);
                    // 获取列的别名，没有别名获取列名
                    String columnLabel = rsmd.getColumnLabel(i + 1);
                    // 通过反射将对象指定列名columnName的属性赋值为columnValue
                    Field field = tClass.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue); // 赋值
                }
                ts.add(t);
            }
        } catch (Exception e) {
            e.fillInStackTrace();
        } finally {
            JDBCUtils.closeResource(connection, ps, rs);
        }
        return ts;
    }

    @Test
    public void test() {
        String sql = "select id, name, email from customers where id < ?";
        ArrayList<Customer> customers = query(Customer.class, sql, 3);
        // System.out.println(customers);
        // for (Customer customer: customers) {
        //     System.out.println(customer);
        // }
        customers.forEach(System.out::println);
    }

🌊 PreparedStatement 解决SQL注入问题

	@Test
    public void testLogin() {
        // 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 = '"+ user +"' AND password = '"+ password +"'";
        String sql = "SELECT user,password FROM user_table WHERE user = ? AND password = ?";
        // ArrayList<User> users = query(User.class, sql, "AA", "123456"); // 登录成功
        ArrayList<User> users = query(User.class, sql, "1' or ", "=1 or '1' = '1"); // 用户名不存在或密码错误
        if(users.size() > 0){
            System.out.println("登录成功");
        }else{
            System.out.println("用户名不存在或密码错误");
        }
    }

    /**
     * 泛型方法
     * @param tClass 指定返回的数据对应的Class
     * @param sql
     * @param args 填充sql语句的参数
     * @return 返回查询结果
     * @param <T> 指定返回数据对应的类
     */
    public <T> ArrayList<T> query(Class<T> tClass, String sql, Object ...args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        ArrayList<T> ts = new ArrayList<>(); // 用于存储查询结果数据
        try {
            connection = JDBCUtils.getConnection(); // 获取连接对象
            ps = connection.prepareStatement(sql); // 预编译sql获取prepareStatement对象
            for (int i = 0; i < args.length; i++) { // 填充参数
                ps.setObject(i+1, args[i]);
            }
            rs = ps.executeQuery(); // 获取结果集
            // 获取结果集的元数据
            ResultSetMetaData rsmd = rs.getMetaData();
            // 获取结果集中的列数
            int columnCount = rsmd.getColumnCount();
            while (rs.next()) {
                T t = tClass.newInstance(); // 实例化对应的对象
                for (int i = 0; i < columnCount; i++) {
                    // 获取每个列的列值
                    Object columnValue = rs.getObject(i + 1);
                    // 获取列的别名，没有别名获取列名
                    String columnLabel = rsmd.getColumnLabel(i + 1);
                    // 通过反射将对象指定列名columnName的属性赋值为columnValue
                    Field field = tClass.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columnValue); // 赋值
                }
                ts.add(t);
            }
        } catch (Exception e) {
            e.fillInStackTrace();
        } finally {
            JDBCUtils.closeResource(connection, ps, rs);
        }
        return ts;
    }

由于PreparedStatement会先对sql语句进行预编译，上述登录的sql语句的条件子句为且关系，PreparedStatement对其预编译之后会认定其就为且关系，不会因为填充的数据而改变其逻辑关系，所以不会引发SQL注入问题。对于Statement，会根据拼接字符串的不同而发生条件子句逻辑关系的改变，所以会导致SQL注入。

• PreparedStatement能够解决Statement的问题：
  1. Statement的拼串
  2. Statement的SQL注入问题
  3. PreparedStatement可以操作BLob类型的数据，而Statement不行
  4. PreparedStatement可以实现更高效的批量操作，Statement每次执行sql都需要进行sql校验，而PreparedStatement在预编译时进行sql校验，后续多次执行sql可以直接填充数据执行，不用再次进行校验。

🥽 PreparedStatement操作Blob类型的数据

🌊 MySQL BLOB类型

MySQL中，BLOB是一个二进制大型对象，是一个可以存储大量数据的容器，它能容纳不同大小的数据。插入BLOB类型的数据必须使用PreparedStatement，因为BLOB类型的数据无法使用字符串拼接写的。

MySQL的四种BLOB类型(除了在存储的最大信息量上不同外，他们是等同的)：

实际使用中根据需要存入的数据大小定义不同的BLOB类型。需要注意的是：如果存储的文件过大，数据库的性能会下降，所以实际情况中，一般将文件存储在专门的文件服务器，在数据库中存储的为文件对应的地址。

🌊 插入Blob类型的数据

    @Test
    public void testInster() throws Exception {
        Connection connection = JDBCUtils.getConnection();
        String sql = "insert into customers(name, email, birth, photo) values (?, ?, ?, ?)";
        PreparedStatement ps = connection.prepareStatement(sql);
        ps.setObject(1, "ZS");
        ps.setObject(2, "ZS@qq.com");
        ps.setObject(3, "2001-11-11");
        // 使用文件输入流获取文件
        FileInputStream fis = new FileInputStream(new File("src\\preparedstatement\\1.jpg"));
        ps.setObject(4, fis);
        ps.execute();
        JDBCUtils.closeResource(connection, ps);
    }

如果在数据库表中指定了字段相关的Blob类型以后，还报错：xxx too large，那么在mysql的安装目录下，找my.ini文件加上如下的配置参数：max_allowed_packet=16M。同时注意：修改了my.ini文件之后，需要重新启动mysql服务。
Mysql8.0的my.ini文件在如下路径：C:\ProgramData\MySQL\MySQL Server 8.0

🌊 读取Blob类型的数据

    @Test
    public void testQuery() throws Exception {
        Connection connection = JDBCUtils.getConnection();
        String sql = "select id, name, email, birth, photo from customers where id = ?";
        PreparedStatement ps = connection.prepareStatement(sql);
        ps.setObject(1, 21);
        // 执行获取结果集
        ResultSet rs = ps.executeQuery();
        InputStream is = null;
        FileOutputStream fos = null;
        if (rs.next()) {
            // 方式1：
            //int id = rs.getInt(1);
            //String name = rs.getString(2);
            //String email = rs.getString(3);
            //Date birth = rs.getDate(3);
            // 方式2（建议）：
            int id = rs.getInt("id");
            String name = rs.getString("name");
            String email = rs.getString("email");
            Date birth = rs.getDate("birth");
            System.out.println(id);
            System.out.println(name);
            System.out.println(email);
            System.out.println(birth);
            // 将blob类型的数据保存本地
            Blob photo = rs.getBlob("photo");
            is = photo.getBinaryStream(); // 读取blob数据到内存
            fos = new FileOutputStream("ZS.jpg");// 输出流
            // 写入文件
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
        }
        fos.close();
        is.close();
        JDBCUtils.closeResource(connection, ps, rs);
    }

🥽 PreparedStatement批量插入数据

goods的建表语句：

CREATE TABLE goods(
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(25)
);

向goods表中插入20000条数据

🌊 使用PreparedStatement

    @Test
    public void testInsert1() throws Exception {
        Connection connection = JDBCUtils.getConnection();
        String sql = "insert into goods(name) values(?);";
        PreparedStatement ps = connection.prepareStatement(sql);
        long start = System.currentTimeMillis();
        for (int i=0; i<20000; i++) {
            ps.setObject(1, "name_" + i);
            ps.execute();
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        JDBCUtils.closeResource(connection, ps);
    }

🌊 使用 addBatch() / executeBatch() / clearBatch()

mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。?rewriteBatchedStatements=true 写在配置文件的url后面

user=root
password=123123
url=jdbc:mysql://localhost:3306/test?characterEncoding=utf8&rewriteBatchedStatements=true
driverClass=com.mysql.jdbc.Driver

    @Test
    public void testInsert1() throws Exception {
        Connection connection = JDBCUtils.getConnection();
        String sql = "insert into goods(name) values(?);";
        PreparedStatement ps = connection.prepareStatement(sql);
        long start = System.currentTimeMillis();
        for (int i=0; i<20000; i++) {
            ps.setObject(1, "name_" + i);
            // ps.execute();
            // 攒sql
            ps.addBatch();
            if (i % 500 == 0) {
                // 执行Batch
                ps.executeBatch();
                // 清空Batch
                ps.clearBatch();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        JDBCUtils.closeResource(connection, ps);
    }

更换jar包(新版支持批量插入)

🌊 修改事务提交的时机

    @Test
    public void testInsert1() throws Exception {
        Connection connection = JDBCUtils.getConnection();
        // 获取连接时取消事务的自动提交
        connection.setAutoCommit(false);
        String sql = "insert into goods(name) values(?);";
        PreparedStatement ps = connection.prepareStatement(sql);
        long start = System.currentTimeMillis();
        for (int i=0; i<20000; i++) {
            ps.setObject(1, "name_" + i);
            // ps.execute();
            // 攒sql
            ps.addBatch();
            if (i % 500 == 0) {
                // 执行Batch
                ps.executeBatch();
                // 清空Batch
                ps.clearBatch();
            }
        }
        // 统一提交数据
        connection.commit();
        long end = System.currentTimeMillis();
        System.out.println(end - start);
        JDBCUtils.closeResource(connection, ps);
    }

🥽 数据库事务

🌊 数据库事务介绍

• 事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
  • 一组逻辑操作单元：一行或多行DML操作。
• 事务处理（事务操作）的原则：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务回滚(rollback)到最初状态。
• 为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。
• 数据一旦提交，就不可回滚。
• 哪些操作会导致数据的自动提交？
  • DDL操作一旦执行，都会自动提交。set autocommit = false的方式对DDL操作失效。
  • DML操作默认情况下，一旦执行，就会自动提交。可以通过set autocommit = false的方式取消DML操作自动提交
  • 默认在关闭连接时，会自动的提交数据。

🌊 考虑事务后的转账操作实现

public class TransactionTest {
    @Test
    public void test() {
        Connection connection = null;
        try {
            connection = JDBCUtils.getConnection();
            // 取消事务的自动提交
            connection.setAutoCommit(false);
            String sql1 = "update user_table set balance=balance-100 where user=?";
            update(connection, sql2, "AA");

            String sql2 = "update user_table set balance=balance+100 where user=?";
            update(connection, sql1, "BB");
            
            System.out.println("转账成功");
            // 提交事务
            connection.commit();
        } catch (Exception e) {
            e.printStackTrace();
            // 回滚事务
            try {
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        } finally {
            JDBCUtils.closeResource(connection, null);
        }
    }

    // 通用的增删改操作
    public int update(Connection connection, String sql, Object ...args) {
        PreparedStatement ps = null;
        try {
            ps = connection.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i+1, args[i]);
            }
            // 执行sql
            return ps.executeUpdate();
        } catch (Exception e) {
            e.fillInStackTrace();
        } finally {
        	// 修改为自动提交事务
        	// 恢复自动提交状态
            try {
                connection.setAutoCommit(true);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            // 关闭资源
            JDBCUtils.closeResource(null, ps);
        }
        return 0;
    }
}

		try {
            connection = JDBCUtils.getConnection();
            // 取消事务的自动提交
            connection.setAutoCommit(false);
            String sql1 = "update user_table set balance=balance-100 where user=?";
            update(connection, sql1, "AA");
            System.out.println(10 / 0);
            String sql2 = "update user_table set balance=balance+100 where user=?";
            update(connection, sql2, "BB");

            System.out.println("转账成功");
            // 提交事务
            connection.commit();
        } 

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

🌊 事务的ACID属性

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

🌊 数据库的并发问题

• 对于同时运行的多个事务, 当这些事务访问数据库中相同的数据时, 如果没有采取必要的隔离机制, 就会导致各种并发问题:
  • 脏读: 对于两个事务 T1, T2, T1 读取了已经被 T2 更新但还没有被提交的字段。之后, 若 T2 回滚, T1读取的 内容就是临时且无效的。
  • 不可重复读: 对于两个事务T1, T2, T1 读取了一个字段, 然后 T2 更新了该字段并提交了操作。之后, T1再次读取同一个字段, 值就不同了。
  • 幻读: 对于两个事务T1, T2, T1 从一个表中读取了一个字段, 然后 T2 在该表中插入了一些新的行。之后, 如果 T1 再次读取同一个表, 就会多出几行。
• 数据库事务的隔离性: 数据库系统必须具有隔离并发运行各个事务的能力, 使它们不会相互影响, 避免各种并发问题。

🌊 四种隔离级别

• 一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别, 不同隔离级别对应不同的干扰程度, 隔离级别越高, 数据一致性就越好, 但并发性越弱。
• 数据库提供的4种事务隔离级别：
  
• Oracle 支持的 2 种事务隔离级别：READ COMMITED, SERIALIZABLE。 Oracle 默认的事务隔离级别为: READ COMMITED。
• Mysql 支持 4 种事务隔离级别。Mysql 默认的事务隔离级别为: REPEATABLE READ。

🥽 DAO及相关实现类

🌊 BaseDAO

package DAO;

import utils.JDBCUtils;

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

/**
 * 封装了针对于数据表的通用的操作
 */
public class BaseDAO {
    /**
     * 通用的增删改操作
     * @param connection 数据库连接对象
     * @param sql sql语句
     * @param args sql语句填充参数
     * @return 返回本次增删改操作对数据库表影响的行数
     */
    public int update(Connection connection, String sql, Object ...args) {
        PreparedStatement ps = null;
        try {
            ps = connection.prepareStatement(sql);
            // 填充占位符
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i+1, args[i]);
            }
            // 执行sql
            return ps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            JDBCUtils.closeResource(null, ps);
        }
        return 0;
    }

    /**
     * 通用的查询操作
     * @param conn 数据库连接对象
     * @param clazz 查询数据对应的类
     * @param sql sql语句
     * @param args sql语句填充参数
     * @return 返回查询的结果
     * @param <T> 泛型
     */
    public <T> List<T> getForList(Connection conn, Class<T> clazz, String sql, Object... args) {
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                ps.setObject(i + 1, args[i]);
            }
            rs = ps.executeQuery();
            // 获取结果集的元数据 :ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通过ResultSetMetaData获取结果集中的列数
            int columnCount = rsmd.getColumnCount();
            // 创建集合对象
            ArrayList<T> list = new ArrayList<T>();
            while (rs.next()) {
                T t = clazz.newInstance();
                // 处理结果集一行数据中的每一个列:给t对象指定的属性赋值
                for (int i = 0; i < columnCount; i++) {
                    // 获取列值
                    Object columValue = rs.getObject(i + 1);
                    // 获取每个列的列名
                    // String columnName = rsmd.getColumnName(i + 1);
                    String columnLabel = rsmd.getColumnLabel(i + 1);
                    // 给t对象指定的columnName属性，赋值为columValue：通过反射
                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, columValue);
                }
                list.add(t);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(null, ps, rs);
        }
        return null;
    }
    
    /**
     * 用于查询特殊值的通用的方法
     * @param conn 数据库连接对象
     * @param sql sql语句
     * @param args sql语句填充参数
     * @return 返回查询的结果
     * @param <E> 泛型
     */
    public <E> E getValue(Connection conn,String sql,Object...args){
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            ps = conn.prepareStatement(sql);
            for(int i = 0;i < args.length;i++){
                ps.setObject(i + 1, args[i]);
            }
            rs = ps.executeQuery();
            if(rs.next()){
                return (E) rs.getObject(1);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            JDBCUtils.closeResource(null, ps, rs);
        }
        return null;
    }
}

🌊 BaseDAO(泛型+反射)

public abstract class BaseDAO<T> {
	
	private Class<T> clazz = null;
	
//	public BaseDAO(){
//		
//	}
	
	{	
		//获取当前BaseDAO的子类继承的父类中的泛型
		Type genericSuperclass = this.getClass().getGenericSuperclass();
		ParameterizedType paramType = (ParameterizedType) genericSuperclass;
		
		Type[] typeArguments = paramType.getActualTypeArguments();//获取了父类的泛型参数
		clazz = (Class<T>) typeArguments[0];//泛型的第一个参数
		
	}
	
	
	// 通用的增删改操作---version 2.0 （考虑上事务）
	public int update(Connection conn, String sql, Object... args) {// sql中占位符的个数与可变形参的长度相同！
		PreparedStatement ps = null;
		try {
			// 1.预编译sql语句，返回PreparedStatement的实例
			ps = conn.prepareStatement(sql);
			// 2.填充占位符
			for (int i = 0; i < args.length; i++) {
				ps.setObject(i + 1, args[i]);// 小心参数声明错误！！
			}
			// 3.执行
			return ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 4.资源的关闭
			JDBCUtils.closeResource(null, ps);

		}
		return 0;

	}

	// 通用的查询操作，用于返回数据表中的一条记录（version 2.0：考虑上事务）
	public T getInstance(Connection conn, String sql, Object... args) {
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {

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

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

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

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

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

		}

		return null;
	}
	// 通用的查询操作，用于返回数据表中的多条记录构成的集合（version 2.0：考虑上事务）
	public List<T> getForList(Connection conn, String sql, Object... args) {
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {

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

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

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

					// 给t对象指定的columnName属性，赋值为columValue：通过反射
					Field field = clazz.getDeclaredField(columnLabel);
					field.setAccessible(true);
					field.set(t, columValue);
				}
				list.add(t);
			}

			return list;
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JDBCUtils.closeResource(null, ps, rs);

		}

		return null;
	}
	//用于查询特殊值的通用的方法
	public <E> E getValue(Connection conn,String sql,Object...args){
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			ps = conn.prepareStatement(sql);
			for(int i = 0;i < args.length;i++){
				ps.setObject(i + 1, args[i]);
				
			}
			
			rs = ps.executeQuery();
			if(rs.next()){
				return (E) rs.getObject(1);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(null, ps, rs);
			
		}
		return null;
		
	}	
}

🥽 数据库连接池

🌊 数据库连接池简介

• 在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：

  • 在主程序（如servlet、beans）中建立数据库连接
  • 进行sql操作
  • 断开数据库连接

• 这种模式开发，存在的问题:

  • 普通的JDBC数据库连接使用 DriverManager 来获取，每次向数据库建立连接的时候都要将 Connection加载到内存中，再验证用户名和密码(得花费0.05s～1s的时间)。需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。数据库的连接资源并没有得到很好的重复利用。若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
  • 对于每一次数据库连接，使用完后都得断开。否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。（Java的内存泄漏，存在对象不能被回收）
  • 这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。

• 为解决传统开发中的数据库连接问题，可以采用数据库连接池技术。

• 数据库连接池的基本思想：就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。

• 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。

• 数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。
  

• 数据库连接池技术的优点

  1. 资源重用
     由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。
  2. 更快的系统反应速度
     数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间
  3. 新的资源分配手段
     对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源
  4. 统一的连接管理，避免数据库连接泄漏
     在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露

• 多种开源的数据库连接池

  • JDBC 的数据库连接池使用 javax.sql.DataSource 来表示，DataSource 只是一个接口，该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：
    • DBCP 是Apache提供的数据库连接池。tomcat 服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持。
    • C3P0 是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以。hibernate官方推荐使用
    • Proxool 是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点
    • BoneCP 是一个开源组织提供的数据库连接池，速度快
    • Druid 是阿里提供的数据库连接池，据说是集DBCP 、C3P0 、Proxool 优点于一身的数据库连接池，但是速度不确定是否有BoneCP快
  • DataSource 通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把 DataSource 称为连接池
  • DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速度。
  • 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
  • 当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close(); 但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

🌊 C3P0数据库连接池

💦 方式一

    @Test
    public void test() throws Exception {
        // 获取c3p0数据库连接池
        // 实际开发中只需要一个数据库连接池即可
        ComboPooledDataSource cpds = new ComboPooledDataSource();
        cpds.setDriverClass("com.mysql.jdbc.Driver");
        cpds.setJdbcUrl("jdbc:mysql://localhost:3306/test?characterEncoding=utf8&rewriteBatchedStatements=true");
        cpds.setUser("root");
        cpds.setPassword("123123");
        // 通过设置相关的参数对数据库连接池进行管理
        // 设置初始时数据库连接池中的连接数
        cpds.setInitialPoolSize(10);

        // 获取数据库连接
        Connection connection = cpds.getConnection();
        System.out.println(connection);
    }

💦 方式二：使用配置文件

c3p0-config.xml(配置文件默认固定为该名，src目录下)

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

	<named-config name="helloc3p0">
		<!-- 提供获取连接的4个基本信息 -->
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/test?characterEncoding=utf8</property>
		<property name="user">root</property>
		<property name="password">123123</property>
		
		<!-- 进行数据库连接池管理的基本信息 -->
		<!-- 当数据库连接池中的连接数不够时，c3p0一次性向数据库服务器申请的连接数 -->
		<property name="acquireIncrement">5</property>
		<!-- c3p0数据库连接池中初始化时的连接数 -->
		<property name="initialPoolSize">10</property>
		<!-- c3p0数据库连接池维护的最少连接数 -->
		<property name="minPoolSize">10</property>
		<!-- c3p0数据库连接池维护的最多的连接数 -->
		<property name="maxPoolSize">100</property>
		<!-- c3p0数据库连接池最多维护的Statement的个数 -->
		<property name="maxStatements">50</property>
		<!-- 每个连接中可以最多使用的Statement的个数 -->
		<property name="maxStatementsPerConnection">2</property>

	</named-config>
</c3p0-config>

    @Test
    public void test2() throws Exception {
        // 获取c3p0数据库连接池
        // 实际开发中只需要一个数据库连接池即可
        // 参数值与<named-config name="hellc3p0">中的name值一致
        ComboPooledDataSource cpds = new ComboPooledDataSource("helloc3p0");
        // 获取数据库连接
        Connection connection = cpds.getConnection();
        System.out.println(connection);
    }

    @Test
    public void test2() throws Exception {
        // 获取c3p0数据库连接池
        // 参数值与<named-config name="hellc3p0">中的name值一致
        ComboPooledDataSource cpds = new ComboPooledDataSource("helloc3p0");
        // 获取数据库连接
        Connection connection = cpds.getConnection();
        // System.out.println(connection);
        String sql = "select * from user_table";
        PreparedStatement ps = connection.prepareStatement(sql);
        ps.execute();
        ResultSet resultSet = ps.getResultSet();
        while (resultSet.next()) {
            System.out.println(resultSet.getString("user"));
        }
        resultSet.close();
        ps.close();
        connection.close();
    }

🌊 DBCP

💦 方式一

    @Test
    public void test1() throws SQLException {
        // 创建DBCP数据库连接池
        // 实际开发中只需要一个数据库连接池即可
        BasicDataSource source = new BasicDataSource();
        // 设置基本信息
        source.setDriverClassName("com.mysql.jdbc.Driver");
        source.setUrl("jdbc:mysql://localhost:3306/test?characterEncoding=utf8");
        source.setUsername("root");
        source.setPassword("123123");
        //还可以设置其他涉及数据库连接池管理的相关属性：
        source.setInitialSize(10);
        source.setMaxActive(10);
        Connection connection = source.getConnection();
        System.out.println(connection);
    }

💦 方式二：使用配置文件

src目录下新建 dbcp.properties 配置文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?characterEncoding=utf8
username=root
password=123123
initialSize=10
#...

    @Test
    public void test2() throws Exception {
        Properties properties = new Properties();
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("dbcp.properties");
        properties.load(is);
        // 实际开发中只需要一个数据库连接池即可
        DataSource source = BasicDataSourceFactory.createDataSource(properties);
        Connection connection = source.getConnection();
        System.out.println(connection);
        connection.close();
    }

💦 dbcp连接池常用基本配置属性

1. initialSize ：连接池启动时创建的初始化连接数量（默认值为0）
2. maxActive ：连接池中可同时连接的最大的连接数（默认值为8，调整为20，高峰单机器在20并发左右，自己根据应用场景定）
3. maxIdle：连接池中最大的空闲的连接数，超过的空闲连接将被释放，如果设置为负数表示不限制（默认为8个，maxIdle不能设置太小，因为假如在高负载的情况下，连接的打开时间比关闭的时间快，会引起连接池中idle的个数 上升超过maxIdle，而造成频繁的连接销毁和创建，类似于jvm参数中的Xmx设置)
4. minIdle：连接池中最小的空闲的连接数，低于这个数量会被创建新的连接（默认为0，调整为5，该参数越接近maxIdle，性能越好，因为连接的创建和销毁，都是需要消耗资源的；但是不能太大，因为在机器很空闲的时候，也会创建低于minidle个数的连接，类似于jvm参数中的Xmn设置）
5. maxWait ：最大等待时间，当没有可用连接时，连接池等待连接释放的最大时间，超过该时间限制会抛出异常，如果设置-1表示无限等待（默认为无限，调整为60000ms，避免因线程池不够用，而导致请求被无限制挂起）
6. poolPreparedStatements：开启池的prepared（默认是false，未调整，经过测试，开启后的性能没有关闭的好。）
7. maxOpenPreparedStatements：开启池的prepared 后的同时最大连接数（默认无限制，同上，未配置）
8. minEvictableIdleTimeMillis ：连接池中连接，在时间段内一直空闲， 被逐出连接池的时间

🌊 Druid

💦 使用配置文件获取链接

在src目录下新建 druid.properties 配置文件

url=jdbc:mysql://localhost:3306/test?characterEncoding=utf8
username=root
password=285013
driverClassName=com.mysql.jdbc.Driver

    @Test
    public void test1() throws Exception {
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
        Properties properties = new Properties();
        properties.load(is);
        // 实际开发中只需要一个数据库连接池即可
        DataSource source = DruidDataSourceFactory.createDataSource(properties);
        Connection connection = source.getConnection();
        System.out.println(connection);
    }

💦 Druid连接池常用基本配置属性

🥽 Apache-DBUtils实现CRUD操作

🌊 QueryRunner类

该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。

• QueryRunner类提供了两个构造器：
  • 默认的构造器
  • 需要一个 javax.sql.DataSource 来作参数的构造器
• QueryRunner类的主要方法：
  • 更新
    • public int update(Connection conn, String sql, Object… params) throws SQLException:用来执行一个更新（插入、更新或删除）操作。
    • …
  • 插入
    • public T insert(Connection conn,String sql,ResultSetHandler rsh, Object… params) throws SQLException：只支持INSERT语句，其中 rsh - The handler used to create the result object from the ResultSet of auto-generated keys. 返回值: An object generated by the handler.即自动生成的键值
  • …
  • 批处理
    • public int[] batch(Connection conn,String sql,Object[][] params)throws SQLException： INSERT, UPDATE, or DELETE语句
    • public T insertBatch(Connection conn,String sql,ResultSetHandler rsh,Object[][] params)throws SQLException：只支持INSERT语句
    • …
  • 查询
    • public Object query(Connection conn, String sql, ResultSetHandler rsh,Object… params) throws SQLException：执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句 的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。
    • …

🌊 ResultSetHandler接口及实现类

• 该接口用于处理 java.sql.ResultSet，将数据按要求转换为另一种形式。
• ResultSetHandler 接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)。
• 接口的主要实现类：
  • ArrayHandler：把结果集中的第一行数据转成对象数组。
  • ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
  • BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
  • BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
  • ColumnListHandler：将结果集中某一列的数据存放到List中。
  • KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
  • MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
  • MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
  • ScalarHandler：查询单个值对象，用于查询特殊值

🌊 插入数据

    @Test
    public void test1() throws Exception {
        Properties properties = new Properties();
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
        properties.load(is);
        DataSource source = DruidDataSourceFactory.createDataSource(properties);
        Connection connection = source.getConnection();

        QueryRunner queryRunner = new QueryRunner();
        String sql = "insert into customers(name, email, birth) values(?, ?, ?)";
        // 填充执行sql, 返回影响的行数
        int insterCount = queryRunner.update(connection, sql, "ZS", "ZSZSZS@qq.com", "2001-11-23");
        System.out.println("添加的记录条数为：" + insterCount);
        connection.close();
    }

🌊 查询数据

    @Test
    public void test1() throws Exception {
        Properties properties = new Properties();
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
        properties.load(is);
        DataSource source = DruidDataSourceFactory.createDataSource(properties);
        Connection connection = source.getConnection();

        QueryRunner queryRunner = new QueryRunner();
        String sql = "select id, name, email from customers where id=?";
        BeanHandler<Customer> customerBeanHandler = new BeanHandler<>(Customer.class);
        Customer customer = queryRunner.query(connection, sql, customerBeanHandler, 10);
        System.out.println(customer);
    }

    @Test
    public void test1() throws Exception {
        Properties properties = new Properties();
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
        properties.load(is);
        DataSource source = DruidDataSourceFactory.createDataSource(properties);
        Connection connection = source.getConnection();

        QueryRunner queryRunner = new QueryRunner();
        String sql = "select id, name, email from customers where id<?";
        BeanListHandler<Customer> customerBeanHandler = new BeanListHandler<>(Customer.class);
        List<Customer> customerList = queryRunner.query(connection, sql, customerBeanHandler, 10);
        customerList.forEach(System.out::println);
    }

    @Test
    public void test1() throws Exception {
        Properties properties = new Properties();
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
        properties.load(is);
        DataSource source = DruidDataSourceFactory.createDataSource(properties);
        Connection connection = source.getConnection();

        QueryRunner queryRunner = new QueryRunner();
        String sql = "select id, name, email from customers where id<?";
        MapListHandler mapListHandler = new MapListHandler();
        List<Map<String, Object>> query = queryRunner.query(connection, sql, mapListHandler, 10);
        for (Map<String, Object> q: query) {
            System.out.println(q);
        }
    }

🌊 查询特殊值

    @Test
    public void test1() throws Exception {
        Properties properties = new Properties();
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("druid.properties");
        properties.load(is);
        DataSource source = DruidDataSourceFactory.createDataSource(properties);
        Connection connection = source.getConnection();

        QueryRunner queryRunner = new QueryRunner();
        String sql = "select count(*) from customers";
        ScalarHandler handler = new ScalarHandler();
        Long query = (Long) queryRunner.query(connection, sql, handler);
        System.out.println(query);
    }

🌊 自定义ResultSetHandler的实现类

	/*
	 * 自定义ResultSetHandler的实现类
	 */
	@Test
	public void testQuery7(){
		Connection conn = null;
		try {
			QueryRunner runner = new QueryRunner();
			conn = JDBCUtils.getConnection3();
			
			String sql = "select id,name,email,birth from customers where id = ?";
			ResultSetHandler<Customer> handler = new ResultSetHandler<Customer>(){

				@Override
				public Customer handle(ResultSet rs) throws SQLException {
//					System.out.println("handle");
//					return null;
//					return new Customer(12, "成龙", "Jacky@126.com", new Date(234324234324L));
					
					if(rs.next()){
						int id = rs.getInt("id");
						String name = rs.getString("name");
						String email = rs.getString("email");
						Date birth = rs.getDate("birth");
						Customer customer = new Customer(id, name, email, birth);
						return customer;
					}
					return null;
				}
			};
			Customer customer = runner.query(conn, sql, handler,23);
			System.out.println(customer);
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			JDBCUtils.closeResource(conn, null);
		}
	}