JDBC 高级封装

JDBC 高级封装

总结：

需要关闭的资源:

​ java.sql.Connection 数据库连接对象 connection.close();

​ java.sql.Statement 数据库 SQL 语句搬运工对象 statement.close();

​ java.sql.ResultSet 数据库查询结果集对象 resultSet.close();

注：insert update delete只需要关闭前两个，查询时获得结果集会用到第三个。

1. JdbcUtils 工具封装

1.1 资源关闭处理

需要关闭的资源:
	更新操作:
		insert update delete
		1. java.sql.Connection 数据库连接对象
		2. java.sql.Statement 数据库 SQL 语句搬运工对象
	查询操作:
		select
		1. java.sql.Connection 数据库连接对象
		2. java.sql.Statement 数据库 SQL 语句搬运工对象
		3. java.sql.ResultSet 数据库查询结果集对象

1.2 close 方法实现

/**
 * 关闭数据库连接对象资源
 *
 * @param connection java.sql.Connection 数据库连接对象
 */
public static void close(Connection connection) {
    close(connection, null, null);
}

/**
 * 关闭数据库连接对象，数据库 SQL 语句搬运工对象
 *
 * @param connection java.sql.Connection 数据库连接对象
 * @param statement  java.sql.Statement SQL 语句搬运工对象
 */
public static void close(Connection connection, Statement statement) {
    close(connection, statement, null);
}

/**
 * 关闭数据库连接对象，数据库 SQL 语句搬运工对象，查询结果集对象
 *
 * @param connection java.sql.Connection 数据库连接对象
 * @param statement  java.sql.Statement 数据库 SQL 语句搬运工对象
 * @param resultSet  java.sql.ResultSet 查询结果集对象
 */
public static void close(Connection connection, Statement statement, ResultSet resultSet) {
    try {
        if (resultSet != null) {
            resultSet.close();
        }

        if (statement != null) {
            statement.close();
        }

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

1.3 资源关闭整合

interface Connection extends AutoCloseable
interface Statement extends AutoCloseable
interface ResultSet extends AutoCloseable

	在数据库操作过程中涉及到的资源 数据库连接对象，数据库 SQL 语句搬运工对象，数据库查询结果集对象都是继承AutoCloseable 接口

interface AutoCloseable {
	void close() throws Exception;
}

Connection，Statement，ResultSet 都是继承 AutoCloseable 接口得到 close 方法使用权利。

/**
 * JdbcUtils 工具类中私有化成员方法，用于关闭数据库操作相关资源
 *
 * @param sources AutoCloseable 接口实现类，可以传入的类型数据库连接对象，数据库 SQL 语句搬运工对象
 *                数据库查询结果集对象，并且采用的参数形式为不定长参数形式。
 */
private static void close(AutoCloseable... sources) {
    /*
    数组/集合.iter ==> 增强 for 循环
     */
    try {
        // 不定长参数在方法内部可以按照数组处理。
        for (AutoCloseable source : sources) {
            if (source != null) {
                source.close();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

2. BaseDao 数据持久层底层封装

2.1 功能概述

两组目标方法
	第一组:
		通用更新方法，处理用户提供的 insert delete update SQL 语句对应操作。
		需要用户提供的数据
			1. String sql 语句
			2. 对应 SQL 语句的参数
	第二组:
		通用查询方法，根据数据结果集最终处理方式，包括期望的查询结果目标类型
		1. 查询结果为 JavaBean 规范对象
		2. 查询结果为 Map<String, Object>
			数据行中的字段对应 Map 双边队列的 Key 字段对应的数据为 Map 双边队列的 Value
		3. 查询结果为 Object[]
			根据 SQL 语句查询目标字段顺序，查询结果每一行数据对应一个 Object 类型数组
			
		多行数据最终的结果产出:
        	List<T> 
        	List<Map<String, Object>>
        	List<Object[]>        	

2.2 通用 update 方法

方法分析:
	PreparedStatement ==> int executeUpdate();
	预处理 SQL 语句  => PreparedStatement
	给予 SQL 语句参数 ==> PreparedStatement 对应 SQL 语句完善
	
	返回值类型:
		int 当前 SQL 语句执行对应数据表影响行数，可以用于判断 SQL 语句的执行情况。
	参数类型：
		1. String sql
		2. 对应当前 SQL 语句的参数
			a. 参数个数确定吗???
				不确定
			b. 参数类型统一吗???
				不统一
			Object... 利用 Object 类型满足类型大一统，以及不定长参数满足参数个数多样性
	方法名:
		update

方法声明:
	public int update(String sql, Object... parameters);

/**
 * 通用更新方法，可以处理 update insert delete SQL 语句，要求用户传入目标 SQL 语句
 * 和对应 SQL 语句参数列表，参数类型使用 Object 类型，参数形式为不定长参数
 *
 * @param sql        目标执行的 SQL 语句
 * @param parameters 对应的 SQL 语句的 Object 类型参数
 * @return 当前 SQL 语句执行对应数据表的影响行数
 * @throws SQLException SQL 异常
 */
public int update(String sql, Object... parameters) throws SQLException {
    // SQL 语句基本校验
    checkSql(sql);

    // 1. 获取数据库连接对象
    Connection connection = JdbcUtils.getConnection();

    // 2. 预处理 SQL 语句，得到 PreparedStatement 对象
    PreparedStatement statement = connection.prepareStatement(sql);

    /*
     3. 给予 SQL 语句参数赋值操作
     需要赋值的条件:
        1. parameterCount != 0 SQL 语句参数个数不为 0
        2. parameters != null  SQL 语句对应参数数组不得为 null
        3. parameterCount == parameters.length SQL 语句参数个数和参数数组容量一致
     */
    // 3.1 获取 SQL 语句参数个数
    int parameterCount = statement.getParameterMetaData().getParameterCount();

    // 3.2 判断约束，循环赋值
    if (parameterCount != 0 && parameters != null && parameterCount == parameters.length) {
        // 设置 SQL 语句参数  参数下标为 1 开始，数组下标为 0 开始
        for (int i = 1; i <= parameterCount; i++) {
            statement.setObject(i, parameters[i - 1]);
        }
    }

    // 4. 执行 SQL 语句获取当前 SQL 语句执行对应 数据表影响行数
    int affectedRows = statement.executeUpdate();

    // 5. 关闭使用资源
    JdbcUtils.close(connection, statement);

    // 6. 方法返回当前 SQL 语句执行对应数据表的影响行数
    return affectedRows;
}

/**
 * 类内辅助方法，用于判断用户提供的 SQL 语句是否正常
 *
 * @param sql 用户提供的 SQL 语句
 * @throws SQLException SQL 异常
 */
private void checkSql(String sql) throws SQLException {
    if (null == sql || "".equals(sql)) {
        throw new SQLException("SQL syntax errors");
    }
}

2.3 通用 update 方法演示

class Demo1 extends BaseDao {
    @Test
    public void testInsert() throws SQLException {
        String sql = "insert into javaee_2207.t_user(username, password) values(?, ?)";
        /*
        super.update() 调用父类 update 方法
         */
        System.out.println("受到影响的行数:" + super.update(sql, "老邢", "老邢正黑旗"));
    }

    @Test
    public void testDelete() throws SQLException {
        String sql = "delete from javaee_2207.t_user where id = 5";
        System.out.println("受到影响的行数:" + super.update(sql));
    }

    @Test
    public void testUpdate() throws SQLException {
        // ORM 老邢没讲
        String sql = "update javaee_2207.t_user set username = ? , password = ? where id = ?";
        System.out.println("受到影响的行数:" + super.update(sql, "黑邢", "老黑不白", 6));
    }
}

2.4 通用 query 方法

六个最终数据目标：
	T 
		对应符合 JavaBean 规范类对象
	List<T> 
		List 集合存储 对应符合 JavaBean 规范类对象
	
	Map<String, Object> 
		一行数据内容，数据行字段对应Map 中的 key ，字段对应数据为 Map 中的 value
	List<Map<String, Object>>
		List 集合存储 每一行数据内容，数据行字段对应Map 中的 key ，字段对应数据为 Map 中的 value
	
	Object[]
		一行数据内容，根据 SQL 语句查询字段目标顺序，仅存储字段数据内容组成 Object 类型数组
	List<Object[]>
		List 集合存储 每一行数据内容，根据 SQL 语句查询字段目标顺序，仅存储字段数据内容组成 Object 类型数组


方法分析：
	返回值类型
		T 
			对应符合 JavaBean 规范类对象
	参数情况:
		1. String sql 
		2. Object... parameters
		3. 第三个参数功能性:
			a. 明确约束泛型对应的具体数据类型，明确当前查询结果到底对应的是哪一个 JavaBean 规范对象
			b. ResultSet ==> 解析 ==> JavaBean 规范的对象，反射！！！
				万恶之源 Class 类型数据，具备操作对应的 JavaBean 规范对象的所有内容。
			Class<T> cls
	方法名:
		queryBean

方法声明:
	public <T> T queryBean(String sql, Class<T> cls, Object... parameters);

2.5 补充知识点 BeanUtils 使用

需要导入第三方 Jar 包

commons-beanutils-1.8.3.jar

commons-logging-1.1.3.jar

package com.qfedu.a_jdbcutil;

import org.apache.commons.beanutils.BeanUtils;

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;

/**
 * BeanUtils 使用操作
 *      给予 符合 JavaBean 规范对象进行赋值，取值，拷贝操作
 *      自带类型转换和数据处理，为了保存数据的完整性和稳定性，取值
 *      操作返回值类型都是 String 类型。
 *
 * public static void setProperty(Object bean, String name, Object value);
 *      参数解释
 *          bean 任意符合 JavaBean 规范类对象
 *          name 指定成员变量名称
 *          value 期望赋值发给成员变量数据内容，该数据类型为 Object，不限制数据类型
 *      功能概述:
 *          给予符合 JavaBean 规范对象指定成员变量名称，赋值操作，赋值数据类型不限制
 *
 * public static String getProperty(Object bean, String name);
 *       参数解释
 *          bean 任意符合 JavaBean 规范类对象
 *          name 指定成员变量名称
 *       功能概述:
 *          获取指定符合 JavaBean 规范对象指定的成员变量数据 字符串数据形式。
 *
 * public static void populate(Object bean, Map map);
 *      参数解释
 *         bean 任意符合 JavaBean 规范类对象
 *         map 存储用以映射 JavaBean 规范对象的 Map 数据内容 Map Key and Value 类型不限制
 *      功能概述:
 *          将 Map 中的数据根据 Key 对应当前符合 JavaBean 规范对象的成员变量名称，
 *          使用 Key 对应 value 赋值对应成员变量，如果没有对应成员变量存在，舍去
 *          Map 数据内容
 *
 * @author Anonymous 2022/6/6 16:22
 */
public class Demo2 {
    public static void main(String[] args)
            throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        Student student = new Student();

        /*
        parseInt parseFloat .....
         */
        BeanUtils.setProperty(student, "id", '1');
        BeanUtils.setProperty(student, "name", "老黑");
        BeanUtils.setProperty(student, "age", "60");
        BeanUtils.setProperty(student, "score", "-99.5");
        System.out.println(student);
        System.out.println("----------------------------------------------");

        String id = BeanUtils.getProperty(student, "id");
        String name = BeanUtils.getProperty(student, "name");
        String age = BeanUtils.getProperty(student, "age");
        String score = BeanUtils.getProperty(student, "score");
        System.out.println("id :" + id);
        System.out.println("name :" + name);
        System.out.println("age :" + age);
        System.out.println("score :" + score);
        System.out.println("----------------------------------------------");

        HashMap<String, Object> map = new HashMap<>();

        map.put("id", 10);
        map.put("name", "黑黑");
        map.put("age", "75");
        map.put("score", 59);
        map.put("weight", 0.1);

        Student stu2 = new Student();
        BeanUtils.populate(stu2, map);
        System.out.println(stu2);
    }
}

    HashMap<String, Object> map = new HashMap<>();

    map.put("id", 10);
    map.put("name", "黑黑");
    map.put("age", "75");
    map.put("score", 59);
    map.put("weight", 0.1);

    Student stu2 = new Student();
    BeanUtils.populate(stu2, map);
    System.out.println(stu2);
}