PreparedStatement 和 元数据处理

目录

PreparedStatement 和 元数据处理

1. PreparedStatement

interface java.sql.PreparedStatement extends Statement
	数据库 SQL 语句预处理搬运工对象

获取 PreparedStatement 对象涉及到的方法
	java.sql.Connection 调用
		java.sql.PreparedStatement prepareStatement(String sql);
			通过 数据库 Connection 连接对象调用 prepareStatement 传入参数是预处理 SQL 语句，得到 
			PreparedStatement

方法:
	void setObject(int index, Object value);
		给予 SQL 语句赋值操作，index 是下标，value是给予对应下标参数的赋值数据
	int executeUpdate();
		执行 update insert delete
	java.sql.ResultSet executeQuery();
		执行 select 
		
PreparedStatement 可以避免 SQL 注入问题

2. SQL注入问题

package com.qfedu.a_jdbc;

import util.JdbcUtils;

import java.sql.*;

/**
 * SQL 注入演示
 *
 * @author Anonymous 2022/4/2 9:17
 */
public class Demo1 {
    private static String username = "张三";
    private static String password = "北平没有王乾帅' or 1=1 -- ";

    public static void main(String[] args) {
        testStatement();
        testPreparedStatement();
    }

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

        // 2. 准备 Statement 和 ResultSet 引用数据类型变量
        Statement statement = null;
        ResultSet resultSet = null;

        try {
            // 3. 通过 Connection 数据连接对象获取 Statement
            statement = connection.createStatement();

            // 4. SQL 语句准备
            String sql = "select * from javaee_2203.user where name = '" + username + "' and password = '" + password + "'";
            System.out.println(sql);

            // 5. 执行SQL 语句得到查询结果集对象
            resultSet = statement.executeQuery(sql);

            // 6. 判断是否查询到对应数据
            if (resultSet.next()) {
                System.out.println("Statement login success");
            } else {
                System.err.println("Statement login failed");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.close(connection, statement, resultSet);
        }

    }

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

        // 2. 准备数据库资源必要的引用数据类型变量
        ResultSet resultSet = null;
        PreparedStatement statement = null;

        /*
        3. 准备 SQL 语句，SQL语句带有参数，符合 PreparedStatement 与预处理 SQL 语句搬运工要求
        ? 就是 SQL 语句参数，参数存在下标，并且下标为 1 开始！！！
        */
        String sql = "select * from javaee_2203.user where name = ? and password = ?";

        try {
            /*
             4. 通过 Connection 数据库连接对象和 SQL 语句，预处理得到 PreparedStatement 对象
             预处理 SQL 语句过程是已经将 SQL 语句交给 MySQL 数据做准备！！！需要后期提供的 SQL 参数
             在给予 SQL 参数的过程汇总，MySQL 数据库语句对 SQL 语句进行了校验操作，避免 SQL 注入
             问题。
             */
            statement = connection.prepareStatement(sql);

            // 5. 给予 SQL 语句参数赋值操作
            statement.setObject(1, username);
            statement.setObject(2, password);

            // 6. 通过 PreparedStatement 对象执行 SQL 语句 得到 ResultSet 结果集对象
            resultSet = statement.executeQuery();

            // 7. 判断是否查询到对应数据
            if (resultSet.next()) {
                System.out.println("PreparedStatement login success");
            } else {
                System.err.println("PreparedStatement login failed");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.close(connection, statement, resultSet);
        }
    }

}

3. PreparedStatement 完成 CRUD 操作

3.1 PreparedStatement 操作 insert
@Test
public void testInsert() {
    // 1. 获取数据连接对象
    Connection connection = JdbcUtils.getConnection();

    // 2. 准备 PreparedStatement 用于数据类型变量
    PreparedStatement statement = null;

    // 3. 准备用户预处理 PreparedStatement 对象使用的 SQL 语句
    String sql = "insert into javaee_2203.student(name, age, score) VALUES (?,?,?)";

    try {
        /*
        4. 预处理 SQL 语句，得到 PreparedStatement 对象
        java.sql.PreparedStatement prepareStatement(String sql);
		    通过 数据库 Connection 连接对象调用 prepareStatement 传入参数是预处理 SQL 语句，得到
		    PreparedStatement
         */
        statement = connection.prepareStatement(sql);
        int parameterCount = statement.getParameterMetaData().getParameterCount();

        System.out.println(parameterCount);
        /*
        5. 给予 SQL 语句赋值参数操作，通过 PreparedStatement 完成
        void setObject(int parameterIndex, Object value);
	        给予 SQL 语句赋值操作，index 是下标，value是给予对应下标参数的赋值数据
         */
        statement.setObject(1, "大哥");
        statement.setObject(2, "15");
        statement.setObject(3, "100");

        /*
        6. 执行 SQL 语句，得到 MySQL 数据库对应数据表的影响行数
        int executeUpdate();
	        执行 update insert delete
         */
        int affectedRows = statement.executeUpdate();

        System.out.println("数据库受到影响的行数 : " + affectedRows);

    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JdbcUtils.close(connection, statement);
    }
}
3.2 PreparedStatement 操作 update
@Test
public void testUpdate() {
    // 1. 获取数据库连接对象
    Connection connection = JdbcUtils.getConnection();

    // 2. 准备 PreparedStatement 预处理 SQL 搬运工对象
    PreparedStatement statement = null;

    // 3. 准备 SQL 语句
    String sql = "update javaee_2203.student set name = ? where id = ?";

    try {
        /*
        4. 预处理 SQL 语句得到 PreparedStatement 对象
        java.sql.Connection 调用
            java.sql.PreparedStatement prepareStatement(String sql);
                通过 数据库 Connection 连接对象调用 prepareStatement 传入参数是预处理 SQL 语句，得到
                PreparedStatement
         */
        statement = connection.prepareStatement(sql);

        /*
        5. 通过 PreparedStatement 对象设置 SQL 语句对应参数
        void setObject(int index, Object value);
	        给予 SQL 语句赋值操作，index 是下标，value是给予对应下标参数的赋值数据
         */
        statement.setObject(1, "雪珂");
        statement.setObject(2, 10);

        /*
        6. 执行 SQL 语句，得到 MySQL 对应数据表受到影响的行数
        int executeUpdate();
	            执行 update insert delete
         */
        int affectedRows = statement.executeUpdate();
        System.out.println("数据库受到影响的行数 : " + affectedRows);

    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JdbcUtils.close(connection, statement);
    }
}
3.3 PreparedStatement 操作 delete
@Test
public void testDelete() {
    // 1. 数据库连接对象
    Connection connection = JdbcUtils.getConnection();

    // 2. 准备 PreparedStatement 数据库预处理引用数据类型变量
    PreparedStatement statement = null;

    // 3. 准备 SQL 语句
    String sql = "delete from javaee_2203.student where id = ?";

    try {
        /*
        4. 通过数据连接对象 预处理 SQL 语句，得到 PreparedStatement 对象
        java.sql.Connection 调用
            java.sql.PreparedStatement prepareStatement(String sql);
                通过 数据库 Connection 连接对象调用 prepareStatement 传入参数是预处理 SQL 语句，得到
                PreparedStatement
         */
        statement = connection.prepareStatement(sql);

        /*
        5. 给予 SQL 语句参数
        void setObject(int index, Object value);
	        给予 SQL 语句赋值操作，index 是下标，value是给予对应下标参数的赋值数据
         */
        statement.setObject(1, 9);

        /*
        6. 执行 SQL 语句
        int executeUpdate();
	        执行 update insert delete
         */
        int affectedRows = statement.executeUpdate();

        System.out.println("数据库受到影响的行数 : " + affectedRows);
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JdbcUtils.close(connection, statement);
    }
}
3.4 PreparedStatement 操作 select 一行数据
@Test
public void testSelectOne() {
    // 1. 获取数据库连接对象
    Connection connection = JdbcUtils.getConnection();

    // 2. 准备数据库操作所需的 PreparedStatement 和 ResultSet
    ResultSet resultSet = null;
    PreparedStatement statement = null;

    // 3. 准备 SQL 语句
    String sql = "select * from javaee_2203.student where id = ?";

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

        // 5. 给予 SQL 语句参数
        statement.setObject(1, 10);

        // 6. 执行 SQL 语句，得到查询结果集对象
        resultSet = statement.executeQuery();

        Student stu = null;
        // 7. 解析结果集
        if (resultSet.next()) {
            // 8. 根据字段名称获取和期望数据类型获取对应 内容
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            int age = resultSet.getInt("age");
            float score = resultSet.getFloat("score");

            stu = new Student(id, name, age, score);
        }

        System.out.println(stu);

    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JdbcUtils.close(connection, statement, resultSet);
    }

}
3.5 PreparedStatement 操作 select 多行数据
@Test
public void testSelectAll() {
    // 1. 获取数据库连接对象
    Connection connection = JdbcUtils.getConnection();

    // 2. 准备 PreparedStatement 和 ResultSet 引用数据类型变量
    PreparedStatement statement = null;
    ResultSet resultSet = null;

    // 3. 准备预处理 SQL 语句内容
    String sql = "select * from javaee_2203.student";

    try {
        // 4. 预处理 SQL 语句 得的 PreparedStatement 对象
        statement = connection.prepareStatement(sql);

        // 5. 无需参数赋值，直接执行 SQL 语句得到结果集对象
        resultSet = statement.executeQuery();

        // 6. 多行数据使用 while 解析
        ArrayList<Student> list = new ArrayList<>();

        while (resultSet.next()) {
            // 7. 根据字段名称和期望数据类型，得到对应内容
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            int age = resultSet.getInt("age");
            float score = resultSet.getFloat("score");

            list.add(new Student(id, name, age, score));
        }

        // 8. 展示数据喽！！！
        list.forEach(System.out::println);
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        JdbcUtils.close(connection, statement, resultSet);
    }
}

4. 元数据

4.1 参数元数据
通过 java.sql.Connection 数据库连接对象获取 PreparedStatement 对象，需要提供 SQL 语句。
在 PreparedStatement 对象是包含 SQL 语句内容。
并且 PreparedStatement可以通过 setXXX(int parameterIndex, XXX value) 对 SQL 语句进行赋值操作。

分析：
	1. PreparedStatement 包含 SQL 全部内容
	2. PreparedStatement 是已知参数个数，才可以执行 setXXX(int parameterIndex, XXX value) 执行

断点分析
	PreparedStatement 对象中有以下内容
4.2 update 方法封装
/**
 * 用户调用，给予执行 SQL 语句和对应参数，返回值是数据表受到影响的行数
 *
 * @param sql             SQL 语句
 * @param parameterValues SQL 语句对应的参数，数据类型为 Object... Object 类型不定长参数
 * @return 返回值是数据表受到影响的行数
 * @throws SQLException SQL 异常
 */
public int update(String sql, Object... parameterValues) throws SQLException {
    // 1. 获取数据库连接对象
    Connection connection = JdbcUtils.getConnection();

    // 2. 准备 PreparedStatement 预处理 SQL 搬运工对象
    PreparedStatement statement = null;

    // 3. 处理 SQL 语句，SQL 语句有可能为 null，使用断言判断 sql 是否为 null
    assert sql != null;
    statement = connection.prepareStatement(sql);

    // 5. 通过 PreparedStatement对象 获取 【参数元数据】。从【参数元数据】得到参数个数
    int parameterCount = statement.getParameterMetaData().getParameterCount();

    /*
    6. 进行参数赋值操作
        a. SQL 语句参数个数和参数数组长度不一致
        b. SQL 语句参数个数为 0
        以上两个条件不需要赋值，！取反剩下条件都是需要赋值的条件
     */
    if (!(parameterCount != parameterValues.length || 0 == parameterCount)) {
        for (int i = 0; i < parameterCount; i++) {
            statement.setObject(i + 1, parameterValues[i]);
        }
    }
    // 7. 执行 SQL
    int i = statement.executeUpdate();

    // 8. 关闭资源
    JdbcUtils.close(connection, statement);

    return i;
}
4.3 结果集元数据
 /*
    需要通过 ResultSet 得到 字段名称，同时利用字段名获取对应的数据内容。
    ResultSet 中有两组方法
        XXX getXXX(String columnName);
        XXX getXXX(int columnIndex);

    ResultSet 结果集中是否会包含字段名称???
        一定包含，因为 resultSet 可以利用字段名称获取对应数据，字段名称在 ResultSet 一定存在。
    是否会包含字段个数???
        一定包含， 因为 resultSet 可以利用字段下标获取对应数据，ResultSet 一定知道字段个数
     */
    // 5.2 获取 ResultSet 结果集元数据
    ResultSetMetaData metaData = resultSet.getMetaData();

    // 5.3 获取结果集中字段个数
    int columnCount = metaData.getColumnCount();
    
    // 获取字段名称
    String fieldName = metaData.getColumnName(i);
4.4 数据库查询结果为符合JavaBean规范对象方式
/**
 * 通用查询方法，根据用户提供的 SQL 语句和 SQL 对应参数得到 Class<T> 约束数据类型 List 集合
 *
 * @param sql             SQL 语句
 * @param cls             用于约束当前查询结果集对应的数据行 JavaBean 规范类型
 * @param parameterValues 对应的 SQL 语句参数
 * @param <T>             泛型约束，用于约束当前查询结果集对应的 JavaBean 规范数据类型，通过反射Class对象和泛型约束决定
 * @return List集合中带有泛型约束的 JavaBean 规范对象
 */
public <T> List<T> query(String sql, Class<T> cls, Object... parameterValues)
        throws SQLException, NoSuchMethodException, IllegalAccessException,
        InvocationTargetException, InstantiationException, NoSuchFieldException {
    // 1. 获取数据库连接对象
    Connection connection = JdbcUtils.getConnection();

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

    // 3. 赋值 SQL 语句参数
    // 3.1 获取 SQL 语句对应参数个数
    int parameterCount = statement.getParameterMetaData().getParameterCount();

    // 3.2 利用循环对应的 Statement 进行 SQL 语句赋值操作
    if (!(0 == parameterCount || parameterCount != parameterValues.length)) {
        for (int i = 0; i < parameterCount; i++) {
            statement.setObject(i + 1, parameterValues[i]);
        }
    }

    // 4. 执行 SQL 语句，得到 ResultSet 结果集对象
    ResultSet resultSet = statement.executeQuery();

    // 5. 进行解析数据，映射数据行到指定 JavaBean 规范对象中
    /*
     BeanUtils 工具类 setProperty(Object bean, String fieldName, String value)
        给予符合 JavaBean 规范对象，指定成员变量赋值对应数据内容，数据内容为字符串类型
        方法内部可以完成字符串类型转其他任意类型。
     */
    // 5.1 准备一个 List 集合
    List<T> list = new ArrayList<>();

    /*
    需要通过 ResultSet 得到 字段名称，同时利用字段名获取对应的数据内容。
    ResultSet 中有两组方法
        XXX getXXX(String columnName);
        XXX getXXX(int columnIndex);

    ResultSet 结果集中是否会包含字段名称???
        一定包含，因为 resultSet 可以利用字段名称获取对应数据，字段名称在 ResultSet 一定存在。
    是否会包含字段个数???
        一定包含， 因为 resultSet 可以利用字段下标获取对应数据，ResultSet 一定知道字段个数
     */
    // 5.2 获取 ResultSet 结果集元数据
    ResultSetMetaData metaData = resultSet.getMetaData();

    // 5.3 获取结果集中字段个数
    int columnCount = metaData.getColumnCount();

    // 5.4 利用 while 循环开始解析 ResultSet 结果集
    while (resultSet.next()) {
        // while 循环执行一次，对应处理一行数据。 一行数据对应一个 泛型约束 T 类型数据
        T t = cls.getConstructor().newInstance();

        for (int i = 1; i <= columnCount; i++) {
            // 获取字段名称
            String fieldName = metaData.getColumnName(i);
            // 根据字段名称获取对应数据
            String value = resultSet.getString(fieldName);

            // 利用 BeanUtils 工具类，给予执行 JavaBean 规范类对象，指定成员变量名称赋值对应数据
            BeanUtils.setProperty(t, fieldName, value);
        }

        // for 循环执行完毕，数据行中的所有数据解析到 JavaBean 规范对象中
        list.add(t);
    }

    return list;
}

5. 查询结果数据分析

5.1 查询数据对应 Java 数据存储形式
JavaBean 对象是大家可以接受的方式，但是不是所有的查询结构都可以做成对象方式来存储
例如:
	多表查询结果
	单表统计结果
	单表某一个字段数据

有没有什么类型建议???
	ResultSet ==> 方便 Java 操作的数据
	ResultSet ==> JavaBean 
	ResultSet ==> Map
	ResultSet ==> Object[]

六个方法：	
	T queryBean
	List<T> queryBeanList
	Map<String, Object> queryMap
	List<Map<String, Object>> queryMapList
	Object[] queryArray
	List<Object[]> queryArrayList

需要封装一个 ResultSetHandler 处理器接口，插件式编程
5.2 查询结果数据行对应 Map<String, Object> 双边队列
public Map<String, Object> queryMap(String sql, Object... parameterValues);
Map 双边队列
	Key => String 类型 键 ==> 字段
	Value = > Object 类型 值 ==> 字段对应数据 Object 类型包容万象，使用方便。

一行数据 ==> Map 双边队列
id name age gender
1 段某某 16 男 
Map<String, Object>
	数据形式
		"id"=1,
		"name"="段某某",
		"age"=16,
		"gender"="男"

/**
 * 查询一行数据，数据内容最终转换为 Map 双边队列。Map Key 对应数据类型为 String 类型
 * 对应字段名称，Map Value 对应 Object 类型，对应字段数据内容
 *
 * @param sql             String 字符串 SQL 语句
 * @param parameterValues 对应 SQL 语句的参数数组
 * @return Map双边队列
 */
public Map<String, Object> queryMap(String sql, Object... parameterValues) throws SQLException {
    // 1. 获取数据库连接对象
    Connection connection = JdbcUtils.getConnection();

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

    // 3. 给予 SQL 语句赋值参数操作
    int parameterCount = statement.getParameterMetaData().getParameterCount();

    if (!(0 == parameterCount || parameterCount != parameterValues.length)) {
        for (int i = 0; i < parameterCount; i++) {
            statement.setObject(i + 1, parameterValues[i]);
        }
    }

    // 4. 执行 SQL 语句得到 ResultSet 结果集对象
    ResultSet resultSet = statement.executeQuery();

    // 5. 解析数据
    // 5.1 获取结果集元数据
    ResultSetMetaData metaData = resultSet.getMetaData();
    // 5.2 获取查询结果集中的字段个数
    int columnCount = metaData.getColumnCount();

    // 5.3 准备查询结果对应的 Map 双边队列
    HashMap<String, Object> map = new HashMap<>();
    if (resultSet.next()) {
        for (int i = 1; i <= columnCount ; i++) {
            /*
            metaData.getColumnName(i) 获取指定下标字段名称
            resultSet.getObject(i) 对应下标的数据内容
             */
            map.put(metaData.getColumnName(i), resultSet.getObject(i));
        }
    }

    return map;
}
5.3 查询结果数据行对应 Object[] 数组
id name age gender
1 段某某 16 男 
查询结果数据行，每一行数据值，对应一个 Object类型数组
Object[] values = {1, "段某某", 16, "男"};

查询结果解析到使用过程，完全明确字段的查询顺序，查询目标，直接按照数组下标使用。

public Object[] queryArray(String sql, Object... parameterValues) throws SQLException 

/**
 * 查询一行数据，数据内容按照查询字段顺序，仅保留数据转换为一个 Object 类型数组
 *
 * @param sql             String 类型 SQL 语句
 * @param parameterValues 对应 SQL 语句的 Object 数组参数
 * @return Object类型数组
 * @throws SQLException SQL 异常
 */
public Object[] queryArray(String sql, Object... parameterValues) throws SQLException {
    // 1. 获取数据库连接对象
    Connection connection = JdbcUtils.getConnection();

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

    // 3. 赋值 SQL 语句参数
    int parameterCount = statement.getParameterMetaData().getParameterCount();
    if (!(0 == parameterCount || parameterCount != parameterValues.length)) {
        for (int i = 0; i < parameterCount; i++) {
            statement.setObject(i + 1, parameterValues[i]);
        }
    }

    // 4. 执行 SQL 语句，得到结果集对象
    ResultSet resultSet = statement.executeQuery();

    // 5.解析过程
    // 5.1 获取字段个数
    int columnCount = resultSet.getMetaData().getColumnCount();

    // 5.2 根据字段个数创建 Object 类型数组
    Object[] arr = new Object[columnCount];

    if (resultSet.next()) {
        for (int i = 0; i < arr.length; i++) {
            // 根据下标从查询结果集中获取数据，存储到对应的数组下标位置
            arr[i] = resultSet.getObject(i + 1);
        }
    }

    JdbcUtils.close(connection, statement, resultSet);
    return arr;
}
posted @   qtyanan  阅读(174)  评论(0)  编辑  收藏  举报
相关博文：
·  MySQL
·  Servlet 的三种创建方式、请求响应常用方法
·  PreparedStatement预编译原理及基础使用
·  PreparedStatement 对象详解★★★
·  JDBC使用PreparedStatement实现CRUD操作
阅读排行：
· 使用C#创建一个MCP客户端
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 按钮权限的设计及实现
点击右上角即可分享
微信分享提示
SQL AI 助手