JDBC_核心技术第一章：JDBC概述数据的持久化持久化(persistence)：把数据保存到可掉电式存储设备中以

第一章：JDBC概述

数据的持久化

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

Java中的数据存储技术

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

JDBC直接访问数据库
JDO (Java Data Object )技术
第三方O/R工具，如Hibernate, Mybatis 等

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

JDBC介绍

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

JDBC体系结构

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

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

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

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

第二章：获取数据库连接

要素一：Driver接口实现类

Driver接口介绍

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

加载与注册JDBC驱动

加载驱动：加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名
- Class.forName(“com.mysql.jdbc.Driver”);
注册驱动：DriverManager 类是驱动程序管理器类，负责管理驱动程序
- 使用DriverManager.registerDriver(com.mysql.jdbc.Driver)来注册驱动

要素二：URL

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

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

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

几种常用数据库的 JDBC URL

MySQL的连接URL编写方式：
- jdbc:mysql://主机名称:mysql服务端口号/数据库名称?参数=值&参数=值
- jdbc:mysql://localhost:3306/atguigu
- jdbc:mysql://localhost:3306/atguigu?useUnicode=true&characterEncoding=utf8（如果JDBC程序与服务器端的字符集不一致，会导致乱码，那么可以通过参数指定服务器端的字符集）
- jdbc:mysql://localhost:3306/atguigu?user=root&password=123456
Oracle 9i的连接URL编写方式：
- jdbc:oracle:thin:@主机名称:oracle服务端口号:数据库名称
- jdbc:oracle:thin:@localhost:1521:atguigu
SQLServer的连接URL编写方式：
- jdbc:sqlserver://主机名称:sqlserver服务端口号:DatabaseName=数据库名称
- jdbc:sqlserver://localhost:1433:DatabaseName=atguigu

要素三：用户名和密码

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

数据库连接方式举例

连接方式一

@Test
public void testConnection1 () {
    try {
        // 1.提供 Driver接口实现类的对象
        Driver driver = null;
        driver = new com.mysql.jdbc.Driver();
        // 2.提供 url，指明具体操作的数据
        String url = "jdbc:mysql://localhost:3306/test";
        // 3.提供 Properties对象，指明用户名和密码
        Properties info = new propertes();
        info.setProperty("user", "root");
        info.setProperty("password", "root");
        // 4.调用 driver的 connect(),获取连接
        Connection connect = driver.connect(url, info);
        System.out.print(connect);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

说明：上述代码中显式出现了第三方数据库的API

连接方式二

对方式一的迭代（使用反射），面向接口编程，不要出现第三方相关的 api
在如下程序中不出现第三方的 api，使得程序具有更好的可移植性

    // 方式二：对方式一的迭代（使用反射），面向接口编程，不要出现第三方相关的 api
    // 在如下程序中不出现第三方的 api，使得程序具有更好的可移植性
    @Test
    public void testConnection2 () throws Exception {
        // 1.获取 Driver实现类对象，使用反射
        Class clazz = Class.forName("com.mysql.jdbc.Driver");
        Driver driver = (Driver) clazz.newInstance();

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

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

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

    }

连接方式三

使用 DriverManager（驱动管理类，主要用于 JDBC驱动）替换 Driver
体会获取连接必要的4个基本要素。

    // 方式三：使用 DriverManager（驱动管理类，主要用于 JDBC驱动）替换 Driver
	@Test
    public void testConnection3() {
        try {
            //1.数据库连接的4个基本要素：
            String url = "jdbc:mysql://localhost:3306/test";
            String user = "root";
            String password = "abc123";
            String driverName = "com.mysql.jdbc.Driver";

            //2.实例化Driver
            Class clazz = Class.forName(driverName);
            Driver driver = (Driver) clazz.newInstance();
            //3.注册驱动
            DriverManager.registerDriver(driver);
            //4.获取连接
            Connection conn = DriverManager.getConnection(url, user, password);
            System.out.println(conn);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

连接方式四

对方式三的优化，可以只是加载驱动，不用显示的注册驱动了

    // 方式四：对方式三的优化，可以只是加载驱动，不用显示的注册驱动了
    @Test
    public void testConnection4 () throws ClassNotFoundException, SQLException {

        // 1.提供三个连接的基本信息
        String url = "jdbc:mysql://localhost:3306/test";
        String user = "root";
        String password = "root";

        // 2.加载驱动 Driver
//        Class clazz = Class.forName("com.mysql.jdbc.Driver");
        Class.forName("com.mysql.jdbc.Driver");
        /*
         * static静态代码块，随着类的加载而执行
         */

        // 相比于方式三，可以省略如下操作
//      Driver driver = (Driver) clazz.newInstance();
//        // 3.注册驱动
//        DriverManager.registerDriver(driver);
        // 原因如下：在 mysql的实现类中，声明了如下操作
//        static {
//            try {
//                java.sql.DriverManager.registerDriver(new com.mysql.jdbc.Driver());
//            } catch (SQLException E) {
//                throw new RuntimeException("Can't register driver!");
//            }
//        }

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

    }

连接方式五(最终版)

优点：

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

@Test
public void testConnection5 () {
    // 1.加载配置文件
    // 通过当前类的加载器加载 jdbc.properties资源，默认的路径是 src下
    InputStream is = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
    Properties pros = new Properties();
    pros.load(is);
    
    // 2.读取配置文件
    String user = props.getProperty("user");
    String password = pros.getProperty("password");
    String url = pros.getProperty("url");
    String driverClass = pros.getProperty("driverClass");
    
    // 3.加载驱动
    Class.forName(driverClass);
    // 4.获取连接
    Connection connect = DriverManager.getConnection(url, user, password);
    System.out.print(connect);
}

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

user=root
password=abc123
url=jdbc:mysql://localhost:3306/test
driverClass=com.mysql.jdbc.Driver

第三章：使用 PreparedStatement实现 CRUD操作

操作和访问数据库

数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。
在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式：
- Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。
- PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。
- CallableStatement：用于执行 SQL 存储过程

使用Statement操作数据表的弊端

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

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

但是使用Statement操作数据表存在弊端：
- 问题一：存在拼串操作，繁琐
- 问题二：存在SQL注入问题
对于 Java 而言，要防范 SQL 注入，只要用 PreparedStatement(从Statement扩展而来) 取代 Statement 就可以了。
实例：

package com.atguigu.statement.crud;

import org.junit.Test;

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

public class StatementTest {

	// 使用Statement的弊端：需要拼写sql语句，并且存在SQL注入的问题，
	// 如何避免 sql注入：需要使用 PreparedStatement来取代 statement
	@Test
	public void testLogin2 () {

		Scanner scan = new Scanner(System.in);
		System.out.println("用户名：");
		String userName = scan.next();
		System.out.println("密码：");
		String password = scan.nextLine();

		String sqlStr = "SELECT user, password FROM user_table WHERE user = '" + userName + "' AND password = '" + password + "'";
		User user = get(sqlStr, User.class);
		if (user != 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;
	}

}

PreparedStatement的使用

PreparedStatement介绍

可以通过调用 Connection 对象的 preparedStatement(String sql) 方法获取 PreparedStatement 对象
PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句
PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXxx() 方法来设置这些参数. setXxx() 方法有两个参数，第一个参数是要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

PreparedStatement vs Statement

代码的可读性和可维护性。
PreparedStatement 能最大可能提高性能：
- DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。
- 在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。
- (语法检查，语义检查，翻译成二进制命令，缓存)
PreparedStatement 可以防止 SQL 注入

PreparedStatement的优点

解决了 Statement的拼串、sql注入问题
PreparedStatement可以操作 Blob数据，Statement无法做到
PreparedStatement可以实现更高效的批量操作

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

简单实现：

    // 向 customers表中 添加一条记录
    @Test
    public void testInsert () {
        // PreparedStatementUpdateTest.class.getClassLoader()：获取类的加载器（自定义的类的加载器是 系统类的）
//        InputStream is = PreparedStatementUpdateTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

        Properties pros = new Properties();
        try {
            pros.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        String url = pros.getProperty("url");
        String driverClass = pros.getProperty("driverClass");

        Connection connect = null;
        try {
            Class.forName(driverClass);
            // 3.获取连接
            connect = DriverManager.getConnection(url, user, password);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

//        System.out.println(connect);

        // 4.预编译 sql语句，返回 PreparedStatement的实例；?：占位符
        String sqlStr = "INSERT INTO customers(name, email, birth)VALUES(?, ?, ?)";
        PreparedStatement pps = null;
        try {
            pps = connect.prepareStatement(sqlStr);
        } catch (SQLException e) {
            e.printStackTrace();
        }

        // 5.填充占位符
        try {
            pps.setString(1, "哪吒");
            pps.setString(2, "nezha@gmail.com");
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            java.util.Date date = sdf.parse("1000-01-01");
            pps.setDate(3, new java.sql.Date(date.getTime()));
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        }

        // 6.执行 sql语句
        try {
            pps.execute();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (pps != null)
                    pps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (connect != null)
                    connect.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

提取公共的操作类 JDBCUtils

    // 向 customers表中 修改一条记录，使用 JDBCUtils类
    @Test
    public void testUpdate () {
        // 1.获取数据库的连接
        Connection connect = null;
        PreparedStatement pps = null;
        try {
            connect = JDBCUtils.getConnection();
            // 2.预编译 sql语句，返回 PreparedStatement的实例
            String updateSql = "UPDATE customers SET name = ? WHERE id = ?";
            pps = connect.prepareStatement(updateSql);
            // 3.填充占位符
            pps.setObject(1, "莫扎特");
            // pps.setInt(2, 18);
            pps.setObject(2, 18);
            // 4.执行
            pps.execute();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 5.资源的关闭
            JDBCUtils.closeResource(connect, pps);
        }

    }

// JDBCUtils类
package com.atguigu.util;

/**
 * @author lv
 * @create 2021-06-10 22:25
 */

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.SQLException;
import java.util.Properties;

/**
 * 操作数据库的工具类：
 */
public class JDBCUtils {
    /**
     * 获取数据库的连接
     * @return
     * @throws IOException
     * @throws ClassNotFoundException
     * @throws SQLException
     */
    public static Connection getConnection () throws IOException, ClassNotFoundException, SQLException {

        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");

        Properties pros = new Properties();
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        String url = pros.getProperty("url");
        String driverClass = pros.getProperty("driverClass");

        Connection connect = null;
        Class.forName(driverClass);
        // 3.获取连接
        connect = DriverManager.getConnection(url, user, password);

        return connect;
    }

    /**
     * 关闭资源
     * @param connect
     * @param pps
     */
    public static void closeResource (Connection connect, Statement pps) {
        if (connect != null) {
            try {
                connect.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (pps != null) {
            try {
                pps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

}

在 JDBCUtils类的基础上，使 增删改操作通用化

    // 测试 通用增删改方法 updates
    @Test
    public void testUpdates () {

//        String sql = "DELETE FROM customers WHERE id = ?";
//        updates(sql, 3);
        /*
        * order：是关键字，不能用于表名，可以使用 ``来避免 sql解析出错
        * */
        String sql = "UPDATE `order` SET order_name = ? WHERE order_id = ?";
        updates(sql, "DD", 2);
    }
    // 通用 增删改操作
    public void updates (String sqlStr, Object ...args) {

        Connection connect = null;
        PreparedStatement pps = null;
        try {
            // 1.获取数据库的连接
            connect = JDBCUtils.getConnection();
            // 2.预编译 sql语句，返回 PreparedStatement的实例
            pps = connect.prepareStatement(sqlStr);
            // 3.填充占位符
            for (int i = 0; i < args.length; i++) {
                pps.setObject(i + 1, args[i]);
            }
            // 4.执行
            pps.execute();

        } catch (Exception e) {
            // System.out.println(e.getStackTrace());
            e.printStackTrace();
        } finally {
            // 5.资源的关闭
            JDBCUtils.closeResource(connect, pps);
        }

    }

使用PreparedStatement实现查询操作

    @Test
    public void testQuery1 () {
        Connection connect = null;
        PreparedStatement pps = null;
        ResultSet resultSet = null;
        try {
            // 获取连接
            connect = JDBCUtils.getConnection();
            // 预处理 sql
            String sql = "SELECT id, name, email, birth FROM customers WHERE id = ?";
            pps = connect.prepareStatement(sql);
            pps.setInt(1, 1);
            // 执行，并返回结果
            resultSet = pps.executeQuery();
            // next()：调用 next()方法检测下一行是否有效；若有效，该方法返回 true，且指针下移。
            if (resultSet.next()) {
                // 获取当前这条数据的各个字段值
                int id = resultSet.getInt(1);
                String name = resultSet.getString(2);
                String email = resultSet.getString(3);
                Date birth = resultSet.getDate(4);

//            方式一：
//            System.out.println("id = " + id + ", name = " + name);
//            方式二：
//            Object[] cus = new Object[]{id, name, email, birth};
//            方式三：
                Customer customer = new Customer(id, name, email, birth);
                System.out.println(customer);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            JDBCUtils.closeResource(connect, pps, resultSet);
        }
    }

ResultSet与ResultSetMetaData

ResultSet

查询需要调用PreparedStatement 的 executeQuery() 方法，查询结果是一个ResultSet 对象
ResultSet 对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet 接口由数据库厂商提供实现
ResultSet 返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
ResultSet 对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过 ResultSet 对象的 next() 方法移动到下一行。调用 next()方法检测下一行是否有效。若有效，该方法返回 true，且指针下移。相当于Iterator对象的 hasNext() 和 next() 方法的结合体。
当指针指向一行时, 可以通过调用 getXxx(int index) 或 getXxx(int columnName) 获取每一列的值。
- 例如: getInt(1), getString("name")
- 注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。
ResultSet 接口的常用方法：
- boolean next()
- getString()

ResultSetMetaData

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

ResultSet与 ResultSetMetaData 实例

需掌握的知识点：

获取每行的列数：结果集的元数据 ResultSetMetaData
获取每列的名字
给对应的列赋值：反射


    // 测试 customers表的 通用查询操作：queryForCustomers
    @Test
    public void testQueryForCustomers () {
        String sql = "select id, name, email, birth from customers where id = ?";
        Customer rsCustomer = queryForCustomers(sql, 13);
        System.out.println(rsCustomer);
        sql = "select id, name from customers where email = ?";
        Customer customer1 = queryForCustomers(sql, "liuyifei@qq.com");
        System.out.println(customer1);

    }
    /**
     * 针对于 customers表的通用查询操作
     *
     * 问题：
     * 1.获取每行的列数：结果集的元数据 ResultSetMetaData
     * 2.获取每列的名字
     * 3.给对应的列赋值：反射
     * */
    public Customer queryForCustomers (String sql, Object ...args) {
        Connection connect = null;
        PreparedStatement pps = null;
        ResultSet rs = null;

        try {
            connect = JDBCUtils.getConnection();

            pps = connect.prepareStatement(sql);

            for (int i = 0; i < args.length; i++) {
                pps.setObject(i + 1, args[i]);
            }
            rs = pps.executeQuery();
            // 获取结果集的 元数据：ResultSetMetaData
            ResultSetMetaData rsmd = rs.getMetaData();
            // 通过 ResultSetMetaData获取结果集的列数
            int columnCount = rsmd.getColumnCount();
            if (rs.next()) {
                Customer customer = new Customer();
                // 处理结果集中一行数据的每一列数据
                for (int i = 0; i < columnCount; i++) {
                    Object colVal = rs.getObject(i + 1);
                    // 下面是最难的部分
                    // 1.获取列名
                    String columnName = rsmd.getColumnName(i + 1);

                    // 2.给 customer对象的 columnName属性，赋值为 val -> 通过反射
                    Field field = Customer.class.getDeclaredField(columnName);
                    // 确保 customer中的属性可访问
                    field.setAccessible(true);
                    field.set(customer, colVal);
                }
                return customer;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connect, pps, rs);
        }

        return null;

    }

针对不同表的通用查询操作（`重点`）

泛型方法的使用
反射的应用

返回数据表中的一条记录

package com.atguigu.preparedstatement.crud;

import com.atguigu.bean.Customer;
import com.atguigu.bean.Order;
import com.atguigu.util.JDBCUtils;
import org.junit.Test;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

/**
 * @author lv
 * @create 2021-06-14 16:00
 *
 * 使用 PreparedStatement实现针对于不同表的通用查询操作
 */
public class PreparedStatementQueryTest {

    // 测试 针对不同表的通用查询操作 泛型方法 getInstance()
    @Test
    public void testGetInstance () {
        String sql = "SELECT id, name, email FROM customers WHERE id = ?";
        Customer customer = getInstance(Customer.class, sql, 1);
        System.out.println(customer);

        String sql2 = "select order_id orderId, order_name orderName from `order` where order_id = ?";
        Order order = getInstance(Order.class, sql2, 1);
        System.out.println(order);
    }
    /*
    * 使用 PreparedStatement实现针对于不同表的通用查询操作
    *
    * */
    // 泛型方法
    public <T> T getInstance (Class<T> clazz, String sql, Object ...args) {

        Connection connect = null;
        PreparedStatement pps = null;
        ResultSet rs = null;
        try {
            connect = JDBCUtils.getConnection();
            pps = connect.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                pps.setObject(i + 1, args[i]);
            }
            rs = pps.executeQuery();
            if (rs.next()) {
                T t = clazz.newInstance();
                ResultSetMetaData rsmd = rs.getMetaData();
                int columnCount = rsmd.getColumnCount();
                for (int i = 0; i < columnCount; i++) {
                    Object colVal = rs.getObject(i + 1);
                    String colLabel = rsmd.getColumnLabel(i + 1);
                    Field field = clazz.getDeclaredField(colLabel);
                    field.setAccessible(true);
                    field.set(t, colVal);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connect, pps, rs);
        }

        return null;
    }
}

返回数据表中的多条记录：List

    /*
    * 测试 返回结果为 List的通用查询操作 getForList()
    * */
    @Test
    public void testGetForList () {
        // consumer
        String sql = "SELECT id, name, email FROM customers WHERE id > ?";
        List<Customer> customerList = getForList(Customer.class, sql, 10);
        // System.out.println(customerList);
        // Lambda表达式
        // forEach(Consumer)：Consumer 消费者，无返回
        customerList.forEach(System.out::println);
        
        // order
        String sql2 = "select order_id orderId, order_name orderName from `order`";
        List<Order> orderList = getForList(Order.class, sql2);
//        System.out.println(order);
        orderList.forEach(System.out::println);
    }
    // 返回结果为 List的通用查询操作
    public <T> List<T> getForList (Class<T> clazz, String sql, Object ...args) {
        Connection connect = null;
        PreparedStatement pps = null;
        ResultSet rs = null;
        try {
            connect = JDBCUtils.getConnection();
            pps = connect.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                pps.setObject(i + 1, args[i]);
            }
            rs = pps.executeQuery();

            ArrayList<T> list = new ArrayList<>();

            while (rs.next()) {
                T t = clazz.newInstance();
                ResultSetMetaData rsmd = rs.getMetaData();
                int columnCount = rsmd.getColumnCount();

                for (int i = 0; i < columnCount; i++) {

                    Object colVal = rs.getObject(i + 1);
                    String colLabel = rsmd.getColumnLabel(i + 1);
                    Field field = clazz.getDeclaredField(colLabel);
                    field.setAccessible(true);
                    field.set(t, colVal);
                }

                list.add(t);
            }
            return list;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connect, pps, rs);
        }

        return null;
    }

资源的释放

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

JDBC API小结

两种思想
- 面向接口编程的思想 JDBC
- ORM思想(object relational mapping)
  - 一个数据表对应一个java类
  - 表中的一条记录对应java类的一个对象
  - 表中的一个字段对应java类的一个属性
sql是需要结合列名和表的属性名来写。注意起别名。
两种技术
- JDBC结果集的元数据：ResultSetMetaData
  - 获取列数：getColumnCount()
  - 获取列的别名：getColumnLabel()
- 通过反射，创建指定类的对象，获取指定的属性并赋值
查询操作的流程

反射+orm.png

章节练习

从控制台向数据库的表customers中插入一条数据，表结构如下：

pps.executeUpdate(); 返回增删改执行后，在 sql中影响的行数
字符串 "2012-09-01"; 存在隐式转换，可以转换为 java.sql.Date的日期类型

package com.atguigu.exer;

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

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.util.Scanner;

/**
 * @author lv
 * @create 2021-06-15 20:30
 */
public class ExerTest1 {

    // 练习题1：向数据库表 customers中插入一条数据
    @Test
    public void testInsert () {
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入用户名：");
        String name = scan.next();
        System.out.print("请输入邮箱：");
        String email = scan.next();
        System.out.print("请输入生日：");
        String birth = scan.next();

//        String name = "lv";
//        String email = "lv@123.com";
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//        Date parse = sdf.parse("2012-09-01");
//        java.sql.Date birth = new java.sql.Date(parse.getTime());
//        String birth = "2012-09-01"; // 存在隐式转换，java.sql.Date
        String sql = "INSERT INTO customers(name, email, birth)VALUES(?, ?, ?)";
        int updates = updates(sql, name, email, birth);
        if (updates > 0) {
            System.out.println("Success");
        } else {
            System.out.println("Fail");
        }
//        try {
//
//        } catch (ParseException e) {
//            e.printStackTrace();
//        }
    }
    // 增删改-通用操作：
    public int updates (String sql, Object ...args) {
        Connection connect = null;
        PreparedStatement pps = null;
        try {
            connect = JDBCUtils.getConnection();
            pps = connect.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                pps.setObject(i + 1, args[i]);
            }
            // 方式一：
//            pps.execute();

            // 方式二：返回增删改执行后，在 sql中影响的行数
            return pps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connect, pps);
        }
        return 0;
    }
}

输入身份证号或准考证号可以查询到学生的基本信息

"a".equalsIgnoreCase(next)：避免空指针异常

package com.atguigu.exer;

import com.atguigu.bean.ExamStudent;
import com.atguigu.util.JDBCUtils;
import org.junit.Test;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.Scanner;

/**
 * @author lv
 * @create 2021-06-15 22:23
 */
public class ExerTest2 {

    // 查询学生信息
    @Test
    public void testSqlQuery () {
        System.out.println("请选择你要输入的类型：");
        System.out.println("a：准考证号");
        System.out.println("b：身份证号");
        System.out.println();
        Scanner scan = new Scanner(System.in);
        String select = scan.next();
        System.out.println(select);
        // "a".equalsIgnoreCase(next)：避免空指针异常
        if ("a".equalsIgnoreCase(select)) {
            System.out.println("请输入准考证号：");
            String examCard = scan.next();
            String sql = "select FlowId flowId, Type type, IDCard idCard, ExamCard examCard, StudentName studentName, Location location, Grade grade from examstudent where ExamCard = ?";
            ExamStudent examStudent = sqlQuerys(ExamStudent.class, sql, examCard);
            System.out.println(examStudent);
        } else if ("b".equalsIgnoreCase(select)) {
            System.out.println("请输入身份证号：");
            String idCard = scan.next();
            String sql = "select FlowId flowId, Type type, IDCard idCard, ExamCard examCard, StudentName studentName, Location location, Grade grade from examstudent where IDCard = ?";
            ExamStudent examStudent = sqlQuerys(ExamStudent.class, sql, idCard);
            System.out.println(examStudent);
        } else {
            System.out.println("输入有误，请重新进入程序！");
        }
    }
    // 通用查询操作
    public <T> T sqlQuerys (Class<T> clazz, String sql, Object ...args) {
        Connection connect = null;
        PreparedStatement pps = null;
        ResultSet rs = null;
        try {
            connect = JDBCUtils.getConnection();
            pps = connect.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                pps.setObject(i + 1, args[i]);
            }
            rs = pps.executeQuery();
            if (rs.next()) {
                T t = clazz.newInstance();
                ResultSetMetaData rsmd = rs.getMetaData();
                int columnCount = rsmd.getColumnCount();
                for (int i = 0; i < columnCount; i++) {
                    Object colVal = rs.getObject(i + 1);
                    String colLabel = rsmd.getColumnLabel(i + 1);
                    Field field = clazz.getDeclaredField(colLabel);
                    field.setAccessible(true);
                    field.set(t, colVal);
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connect, pps, rs);
        }
        return null;
    }
    // 信息录入操作
    @Test
    public void testInsert () {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入四/六级等级：");
        int type = scan.nextInt();
        System.out.println("请输入身份证号码：");
        String idCard = scan.next();
        System.out.println("请输入准考证号码：");
        String examCard = scan.next();
        System.out.println("请输入学生姓名：");
        String studentName = scan.next();
        System.out.println("请输入区域：");
        String location = scan.next();
        System.out.println("请输入成绩：");
        int grade = scan.nextInt();
        String sql = "insert into examstudent(Type, IDCard, ExamCard, StudentName, Location, Grade)values(?, ?, ?, ?, ?, ?)";
        int updatesCount = updates(sql, type, idCard, examCard, studentName, location, grade);
        if (updatesCount > 0) {
            System.out.println("信息录入成功！");
        } else {
            System.out.println("信息录入失败！");
        }
    }
    public int updates (String sql, Object ...args) {
        Connection connect = null;
        PreparedStatement pps = null;
        try {
            connect = JDBCUtils.getConnection();
            pps = connect.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                pps.setObject(i + 1, args[i]);
            }
            return pps.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connect, pps);
        }
        return 0;
    }
}

第四章操作BLOB类型字段

MySQL BLOB类型

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

类型	大小（字节）
TinyBlob	255
Blob	64K
MediumBlob	16M
LongBlob	4G

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

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

    // 向数据表 customers中插入 Blob类型的字段
    // mysql对于插入的 Blob类型的体积 》 1M的，需要在 mysql中进行配置，如下
    // 找my.ini文件加上如下的配置参数： max_allowed_packet=16M
    @Test
    public void testInsert () {
        Connection connect = null;
        PreparedStatement pps = null;
        try {
            connect = JDBCUtils.getConnection();
            String sql = "insert into customers(name, email, birth, photo)values(?, ?, ?, ?)";
            pps = connect.prepareStatement(sql);
            pps.setObject(1, "lv");
            pps.setObject(2, "lv123@456.com");
            pps.setObject(3, "2012-12-12");
            // new File()：默认根路径，与 src同级
            FileInputStream fis = new FileInputStream(new File("charset_UTF-8.png"));
            pps.setBlob(4, fis);

            int i = pps.executeUpdate();
            if (i > 0) {
                System.out.println("success");
            } else {
                System.out.println("fail");
            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(connect, pps);
        }

    }

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

    // 查询数据表中的 Blob字段
    @Test
    public void testQuery () {
        Connection connect = null;
        PreparedStatement pps = null;
        ResultSet rs = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            connect = JDBCUtils.getConnection();
            String sql = "select id, name, email, birth, photo from customers where id = ?";
            pps = connect.prepareStatement(sql);

            pps.setInt(1, 16);
            rs = pps.executeQuery();
            if (rs.next()) {

                // 方式一：
//                int id = rs.getInt(1);
//                String name = rs.getString(2);
//                String email = rs.getString(3);
//                Date birth = rs.getDate(4);

                // 方式二：
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String email = rs.getString("email");
                Date birth = rs.getDate("birth");
                Customer cust = new Customer(id, name, email, birth);
                System.out.println(cust);

                // 将 Blob格式字段下载下来，以文件的方式保存在本地
                Blob photo = rs.getBlob("photo");
                // InputStream
                is = photo.getBinaryStream();
                // new File("zhuyin.jpg")
                // FileOutputStream
                fos = new FileOutputStream("zhuyin.jpg");
                byte[] buffer = new byte[1024];
                int len;
                while ((len = is.read(buffer)) != -1) {
                    fos.write(buffer, 0, len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {

            JDBCUtils.closeResource(connect, pps, rs);

            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

第五章批量插入

批量执行SQL语句

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

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

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

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

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

批量插入方式二：使用PreparedStatement

批量插入方式一：使用 Statement，忽略

    // 批量插入方式二：使用PreparedStatement
    @Test
    public void testBatchInsert1 () {
        Connection con = null;
        PreparedStatement pps = null;
        try {
            long start = System.currentTimeMillis();
            con = JDBCUtils.getConnection();
            String sql = "insert into goods(name)values(?)";
            pps = con.prepareStatement(sql);
            for (int i = 0; i <= 10000; i++) {
                pps.setObject(1, "name_" + i);
                pps.execute();
            }
            long end = System.currentTimeMillis();

            System.out.println("times: " + (end - start)); // times: 292330
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(con, pps);
        }
    }

批量插入方式三：

使用：addBatch()、executeBatch()、clearBatch()
mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。 ?rewriteBatchedStatements=true 写在配置文件的url后面
使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar

    // 批量插入方式三：
    /***
     * 1.使用：addBatch()、executeBatch()、clearBatch()
     *
     * 2.mysql服务器默认是关闭批处理的，我们需要通过一个参数，让mysql开启批处理的支持。
     * 		 ?rewriteBatchedStatements=true 写在配置文件的url后面
     *
     * 3.使用更新的mysql 驱动：mysql-connector-java-5.1.37-bin.jar
     */
    @Test
    public void testBatchInsert2 () {
        Connection con = null;
        PreparedStatement pps = null;
        try {
            long start = System.currentTimeMillis();
            con = JDBCUtils.getConnection();
            String sql = "insert into goods(name)values(?)";
            pps = con.prepareStatement(sql);
            for (int i = 1; i <= 10000; i++) {
                pps.setObject(1, "name_" + i);
                // pps.execute();
                // 1. 攒 sql
                pps.addBatch();

                if (i % 500 == 0) {
                    // 2. 执行 batch
                    pps.executeBatch();
                    // 3. 清空 batch
                    pps.clearBatch();
                }
            }
            long end = System.currentTimeMillis();

            System.out.println("times: " + (end - start)); // times: 1115

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(con, pps);
        }
    }

批量插入方式四：(终极方案)设置连接不允许自动提交数据

使用Connection 的 setAutoCommit(false) / commit()

    // 批量插入方式四：(终极方案)设置连接不允许自动提交数据
    /**
     * 使用Connection 的 setAutoCommit(false)  /  commit()
     *
     */
    @Test
    public void testBatchInsert3 () {
        Connection con = null;
        PreparedStatement pps = null;
        try {
            long start = System.currentTimeMillis();
            con = JDBCUtils.getConnection();
            // 设置不允许自动提交数据
            con.setAutoCommit(false);
            String sql = "insert into goods(name)values(?)";
            pps = con.prepareStatement(sql);
            for (int i = 1; i <= 10000; i++) {
                pps.setObject(1, "name_" + i);
                // pps.execute();
                // 1. 攒 sql
                pps.addBatch();

                if (i % 500 == 0) {
                    // 2. 执行 batch
                    pps.executeBatch();
                    // 3. 清空 batch
                    pps.clearBatch();
                }
            }
            // 最后，统一提交所有数据
            con.commit();

            long end = System.currentTimeMillis();

            System.out.println("times: " + (end - start)); // times: 673

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeResource(con, pps);
        }
    }

问题：

数据的持久化：

把数据保存到可掉电式存储设备中以供之后使用

JDBC的理解：

是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口；

简单理解为：JDBC是 SUN公司提供的一套 API，使用这套 API可以实现对具体数据库的操作（获取连接、关闭连接、DML、DDL、TCL）。

数据库的驱动：

数据库厂商针对于 JDBC这套接口，提供的具体实现类的集合

面向接口编程的思想：

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

JDBCUtils获取和关闭连接：

Statement的弊端：

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

问题一：存在拼串操作，繁琐
问题二：存在SQL注入问题
其它问题：

Statement无法操作 Blob类型变量
Statement实现批量插入时，效率低

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

PreparedStatement介绍

PreparedStatement 接口是 Statement 的子接口
它表示一条预编译过的 SQL 语句
可以解决 Statement的 sql注入问题、拼串问题

两种思想

面向接口编程的思想
ORM思想(object relational mapping)
- 一个数据表对应一个java类
- 表中的一条记录对应java类的一个对象
- 表中的一个字段对应java类的一个属性

两种技术

JDBC结果集的元数据：ResultSetMetaData
- 获取列数：getColumnCount()
- 获取列的别名：getColumnLabel()
通过反射，创建指定类的对象，获取指定的属性并赋值

JDBC_核心技术

第一章：JDBC概述

数据的持久化

Java中的数据存储技术

JDBC介绍

JDBC体系结构

第二章：获取数据库连接

要素一：Driver接口实现类

Driver接口介绍

加载与注册JDBC驱动

要素二：URL

要素三：用户名和密码

数据库连接方式举例

连接方式一

连接方式二

连接方式三

连接方式四

连接方式五(最终版)

第三章：使用 PreparedStatement实现 CRUD操作

操作和访问数据库

使用Statement操作数据表的弊端

PreparedStatement的使用

PreparedStatement介绍

PreparedStatement vs Statement

PreparedStatement的优点

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

使用PreparedStatement实现查询操作

ResultSet与ResultSetMetaData

ResultSet

ResultSetMetaData

ResultSet与 ResultSetMetaData 实例

针对不同表的通用查询操作（重点）

资源的释放

JDBC API小结

章节练习

从控制台向数据库的表customers中插入一条数据，表结构如下：

输入身份证号或准考证号可以查询到学生的基本信息

第四章 操作BLOB类型字段

MySQL BLOB类型

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

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

第五章 批量插入

批量执行SQL语句

批量插入方式二：使用PreparedStatement

批量插入方式三：

批量插入方式四：(终极方案)设置连接不允许自动提交数据

问题：

数据的持久化：

JDBC的理解：

数据库的驱动：

面向接口编程的思想：

JDBCUtils获取和关闭连接：

Statement的弊端：

PreparedStatement介绍

两种思想

两种技术

PreparedStatement操作 Blob类型的变量

PreparedStatement实现批量操作

PreparedStatement与 Statement的异同

针对不同表的通用查询操作（`重点`）

第四章操作BLOB类型字段

第五章批量插入