原生JDBC常用API整理

package com.snake;

import org.junit.jupiter.api.Test;

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

public class JDBCTest {

    private Connection connection;

    /*声明连接数据库必要的信息，url，用户名，密码*/
    private final String URL = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8";
    private final String USERNAME = "root";
    private final String PASSWORD = "root";

    {
        /*注册驱动*/
        try {
            /*新的驱动为com.mysql.cj.Driver
             * 手动加载驱动是不必要的*/
            Class.forName("com.mysql.cj.jdbc.Driver");
            /*通过驱动管理器获得一个数据库连接*/
            connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    @Test
    void test() {
        try {
            /*若当前连接的数据库是自动提交事务的则返回true*/
            boolean autoCommit = connection.getAutoCommit();
            /*设置是否自动提交事务*/
            connection.setAutoCommit(false);

            /*提交事务*/
            connection.commit();
            /*回滚事务*/
            connection.rollback();

            /*设置一个指定名称的事务保存点*/
            Savepoint point = connection.setSavepoint("point1");
            /*回滚事务到指定保存点前*/
            connection.rollback(point);
            /*移除一个指定的保存点，同时，在此保存点之后设置的保存点也会被移除*/
            connection.releaseSavepoint(point);

            /*将给定的SQL转换为系统原生的语法*/
            String sql = connection.nativeSQL("SQL");

            /*当此Connection被关闭则返回true*/
            connection.isClosed();
            



            /*Statement，用于向数据库提交SQL获取返回的结果集，但他是一个线程不安全的结构，
             * 所以避免其作为成员变量出现*/
            Statement statement = connection.createStatement();

            /*在命令列表中添加一条SQL*/
            statement.addBatch("INSERT INTO `users` values ('8888','11')");

            /*执行命令列表，返回一个int[]，其中元素值代表每条SQL影响的记录数量*/
            int[] ints = statement.executeBatch();

            /*使用executeQuery可以执行查询SQL并返回结果集*/
            ResultSet resultSet = statement.executeQuery("SELECT `id` `t_id` FROM `users`");

            /*从表头开始，将指针指向下一行记录，若到达末尾则返回false*/
            resultSet.next();

            /*获取当前记录中指定索引列的列值，
             * 注意：这里的索引从1开始*/
            Object o = resultSet.getObject(1);

            /*根据列标题获取值*/
            Object o1 = resultSet.getObject("t_id");

            /*返回一个ResultSetMetaData实例，他可以用于获取ResultSet对应表的属性和相关信息*/
            ResultSetMetaData metaData = resultSet.getMetaData();
            /*获取列的数量*/
            int columnCount = metaData.getColumnCount();
            /*获取第1列的列标题，这取决与SQL中是否为该列设置的别名*/
            String label = metaData.getColumnLabel(1);
            /*获取第一列的实际列名*/
            String columnName = metaData.getColumnName(1);
            /*获取第1列的数据类型名称*/
            String typeName = metaData.getColumnTypeName(1);
            /*获取第1列的数据类型的数字格式*/
            int columnType = metaData.getColumnType(1);
            /*获取第1列所属的表名*/
            String tableName = metaData.getTableName(1);
            /*若第1列是设置为自增的则返回true*/
            boolean autoIncrement = metaData.isAutoIncrement(1);
            /*若第1列是货币类型则返回true*/
            metaData.isCurrency(1);
            /*若对第1列的写入一定会成功则返回true*/
            metaData.isDefinitelyWritable(1);
            /*若第1列的数据允许为null则返回true*/
            metaData.isNullable(1);
            /*若第1列是只读状态则返回true*/
            metaData.isReadOnly(1);
            /*若第1列可以在where字句中使用则返回true*/
            metaData.isSearchable(1);
            /*若对第1列的写入是可能成功的则返回true*/
            metaData.isWritable(1);

            /*将此ResultSet的当前及后续警告链接到此SQLWarning实例中，每当指针移动时，会清除当前警告*/
            SQLWarning warnings = resultSet.getWarnings();

            /*若指针在最后一行后则返回true*/
            resultSet.isAfterLast();

            /*若指针在第一行前则返回true*/
            resultSet.isBeforeFirst();

            /*若此ResultSet已被关闭则返回true*/
            resultSet.isClosed();

            /*若指针在第一行则返回true*/
            resultSet.isFirst();

            /*若指针在最后一行则返回true*/
            resultSet.isLast();

            /*将指针移动至最后一行
             * 注意，要想自由移动指针必须设置两个ResultSet的操作参数
             * int TYPE_FORWARD_ONLY = 1003; 指针只能向前移动
             * int TYPE_SCROLL_INSENSITIVE = 1004; 指针可自由移动，但对数据变化不敏感
             * int TYPE_SCROLL_SENSITIVE = 1005; 指针可自由移动，同时对数据变化敏感
             * int CONCUR_READ_ONLY = 1007; 并发场景下数据可能不会被更新
             * int CONCUR_UPDATABLE = 1008; 并发场景下数据可以及时被更新
             * */
            statement = connection.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
            ResultSet query = statement.executeQuery("SELECT * FROM `users`");
            query.last();

            /*将指针移动至第一行*/
            query.first();

            /*获取当前指针所在行数*/
            int row = query.getRow();

            /*遍历当前ResultSet到指定的JavaBean中*/
            class Users {
                String id, password;

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

            query.last();
            int row1 = query.getRow();
            query.first();
            int count = query.getMetaData().getColumnCount();
            List<Users> list = new ArrayList<>(row1);
            Field[] fields = Users.class.getDeclaredFields();
            Users u;
            Field f;
            while (query.next()) {
                u = new Users();
                for (int i = 1; i <= count; i++) {
                    f = fields[i - 1];
                    f.setAccessible(true);
                    f.set(u, query.getObject(i));
                }
                list.add(u);
            }
            System.out.println(list);

            /*关闭ResultSet*/
            resultSet.close();
            query.close();

            /*此Statement已被关闭则返回true*/
            statement.isClosed();

            /*若通过此Statement获得的ResultSet均被关闭则返回true*/
            statement.isCloseOnCompletion();

            /*对于执行SQL的方法如果在指定时间内没有返回结果会抛出一个异常
             * 单位：秒*/
            statement.setQueryTimeout(10);

            /*设置查询返回的结果集记录最大数量，超过这个数值的会被忽略*/
            statement.setMaxRows(100000);

            /*关闭此Statement*/
            statement.close();




            /*获取一个PreparedStatement实例(Statement的子接口)，他可以在SQL中设置可变参数 "?" */
            PreparedStatement ps = connection.prepareStatement("SELECT * FROM `users` WHERE id = ?");

            /*设置索引为1的参数值为8888，这里索引同样从1开始
             * 若参数的Java类型与数据库类型不匹配则会引发异常
             * JDBC数据类型对照参考：https://blog.csdn.net/qq_43517117/article/details/86551215*/
            ps.setObject(1, "8888");

            /*获取ParameterMetaData实例：用于获取参数的相关信息*/
            ParameterMetaData parameterMetaData = ps.getParameterMetaData();
            /*统计参数数量*/
            int parameterCount = parameterMetaData.getParameterCount();

            /*执行查询SQL，返回一个ResultSet*/
            ResultSet resultSet1 = ps.executeQuery();

            /*执行更新SQL，返回数据发生变化的记录数*/
            int rows = ps.executeUpdate("insert into users values ('9999','8989')");

            resultSet1.close();
            ps.close();
            
            /*获取一个CallableStatement（Statement的子接口），用于调用存储过程*/
            CallableStatement call = connection.prepareCall("CALL save(?,?)");
            call.setInt(1,10);
            call.setInt(2,100);
            int i = call.executeUpdate();
            
            /*关闭连接*/
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}