Java 程序
   ↓ 调用 Connection、PreparedStatement 等接口
JDBC 驱动
   ↓ 与服务器通信
MySQL / Oracle / PostgreSQL 等数据库

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>9.7.0</version>
</dependency>

CREATE DATABASE IF NOT EXISTS mytest1 DEFAULT CHARACTER SET utf8mb4;
USE mytest1;

CREATE TABLE test1 (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(20)
);
INSERT INTO test1 (name) VALUES ('张三'), ('李四'), ('王五');

Connection conn = DriverManager.getConnection(
    "jdbc:mysql://localhost:3307/mytest1",
    "root",
    "root"
);

PreparedStatement ps = conn.prepareStatement(
    "SELECT id, name FROM test1 WHERE id = ?"
);

// 这里使用已有 conn，结束时关闭 stmt 和查询结果。
try (Statement stmt = conn.createStatement();
     ResultSet rs = stmt.executeQuery(
         "SELECT id, name FROM test1 ORDER BY id")) {
    while (rs.next()) {
        System.out.println(rs.getInt("id") + " " + rs.getString("name"));
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcDemo {
    public static void main(String[] args) throws SQLException {
        String url = "jdbc:mysql://localhost:3307/mytest1";
        String sql = "SELECT id, name FROM test1 WHERE id = ?";

        try (Connection conn = DriverManager.getConnection(url, "root", "root");
             PreparedStatement ps = conn.prepareStatement(sql)) {
            // JDBC 参数编号从 1 开始：给第一个 ? 传入编号 1。
            ps.setInt(1, 1);

            try (ResultSet rs = ps.executeQuery()) {
                // 游标开始时在第一行之前，先 next() 才能读当前行。
                while (rs.next()) {
                    System.out.println(rs.getInt("id") + " " + rs.getString("name"));
                }
            }
        }
    }
}

1 张三

// 假设 rs 来自 SELECT id, name FROM test1。
while (rs.next()) {
    int id = rs.getInt(1);             // 当前行的第一列。
    String name = rs.getString("name");
    System.out.println(id + " " + name);
}

ResultSetMetaData meta = rs.getMetaData();
int count = meta.getColumnCount();

// JDBC 的列编号从 1 开始，所以最后一列的编号是 count。
for (int i = 1; i <= count; i++) {
    System.out.println(meta.getColumnLabel(i));
}

try (ResultSet rs = ps.executeQuery()) {
    while (rs.next()) {
        System.out.println(rs.getString("name"));
    }
}

// 假设 ps 已准备好增删改 SQL，并完成参数绑定。
int rows = ps.executeUpdate();
System.out.println("影响行数：" + rows);

boolean hasResultSet = ps.execute();

if (hasResultSet) {
    // true 表示第一个结果是结果集，不是“执行成功”的标志。
    try (ResultSet rs = ps.getResultSet()) {
        while (rs.next()) {
            System.out.println(rs.getObject(1));
        }
    }
} else {
    System.out.println("更新计数：" + ps.getUpdateCount());
}

Class.forName("com.mysql.cj.jdbc.Driver");

Class<User> clazz = User.class;

// 假设 User 在默认包中；有包名时必须写全限定名，例如 demo.User。
Class<?> clazz = Class.forName("User");

CREATE TABLE student (
    id INT PRIMARY KEY,
    name VARCHAR(20)
);
INSERT INTO student (id, name) VALUES (1, '小明'), (2, '小红');

List<User> users = jdbc.query(
    "SELECT id, name FROM test1 WHERE id > ? ORDER BY id",
    User.class,
    0
);

List<Student> students = jdbc.query(
    "SELECT id, name FROM student WHERE id > ? ORDER BY id",
    Student.class,
    0
);

SQL + User.class + 参数
          ↓
连接数据库，执行查询
          ↓
读取列标签和当前行的值
          ↓
创建 User，按字段名填入值
          ↓
返回 List<User>

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class JDBCUtils {
    private final String url;
    private final String user;
    private final String password;

    public JDBCUtils(String url, String user, String password) {
        this.url = url;
        this.user = user;
        this.password = password;
    }

    public Connection getConnection() {
        try {
            return DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
            // 保留原始异常，调用者才能继续查看驱动返回的原因。
            throw new RuntimeException("数据库连接失败", e);
        }
    }
}

JDBCUtils jdbc = new JDBCUtils(
    "jdbc:mysql://localhost:3307/mytest1", "root", "root"
);

public int execute(String sql, Object... params) {
    try (Connection conn = getConnection();
         PreparedStatement ps = conn.prepareStatement(sql)) {
        setParams(ps, params);
        return ps.executeUpdate();
    } catch (SQLException e) {
        throw new RuntimeException("SQL 执行失败：" + sql, e);
    }
}

int added = jdbc.execute(
    "INSERT INTO test1(id, name) VALUES (?, ?)", 10, "张三"
);
System.out.println(added); // 1

int updated = jdbc.execute(
    "UPDATE test1 SET name = ? WHERE id = ?", "李四", 10
);
int deleted = jdbc.execute("DELETE FROM test1 WHERE id = ?", 10);
System.out.println(updated + " " + deleted); // 1 1

params[0] = "李四"  → 第一个 ?，姓名
params[1] = 10      → 第二个 ?，编号

public class User {
    private Integer id;
    private String name;

    public User() {
    }

    @Override
    public String toString() {
        return "User(" + id + ", " + name + ")";
    }
}

public class Student {
    private Integer id;
    private String name;

    public Student() {
    }

    @Override
    public String toString() {
        return "Student(" + id + ", " + name + ")";
    }
}

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

// 这是 query 方法中的执行步骤；方法完整版在第 2.4.9 节。
Connection conn = getConnection();
PreparedStatement ps = conn.prepareStatement(sql);
setParams(ps, params);
ResultSet rs = ps.executeQuery();

ResultSetMetaData meta = rs.getMetaData();
int columnCount = meta.getColumnCount();

// 取得这个类声明的无参构造方法。
var constructor = clazz.getDeclaredConstructor();

// 调用构造方法，创建一个新的对象。
T obj = constructor.newInstance();

T obj = clazz.getDeclaredConstructor().newInstance();

String columnName = meta.getColumnLabel(1); // id
String fieldName = toCamelCase(columnName); // id
Field field = findField(clazz, fieldName);

private String toCamelCase(String name) {
    StringBuilder sb = new StringBuilder();
    boolean upperNext = false;

    for (char c : name.toCharArray()) {
        if (c == '_') {
            // 下划线本身不保留，让下一个字母变成大写。
            upperNext = true;
        } else {
            sb.append(upperNext ? Character.toUpperCase(c) : c);
            upperNext = false;
        }
    }
    return sb.toString();
}

private Field findField(Class<?> clazz, String name) {
    Class<?> current = clazz;

    while (current != null && current != Object.class) {
        try {
            return current.getDeclaredField(name);
        } catch (NoSuchFieldException e) {
            // 当前类没有，继续检查父类声明的字段。
            current = current.getSuperclass();
        }
    }
    return null;
}

field.setAccessible(true);
Object value = rs.getObject(1); // 当前行第一列，例如 Integer 类型的 1。

// 第一个参数是刚创建的对象，第二个参数是要写入字段的值。
field.set(obj, convertValue(value, field.getType()));

// 假设 User 在当前示例中可以访问，且有前面定义的无参构造方法。
User user = User.class.getDeclaredConstructor().newInstance();
Field nameField = User.class.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(user, "张三");
System.out.println(user);

User(null, 张三)

list.add(obj);

第一行：创建对象 → 填 id → 填 name → 加入列表
第二行：创建对象 → 填 id → 填 name → 加入列表
第三行：创建对象 → 填 id → 填 name → 加入列表

public <T> List<T> query(String sql, Class<T> clazz, Object... params) {
    List<T> list = new ArrayList<>();

    try (Connection conn = getConnection();
         PreparedStatement ps = conn.prepareStatement(sql)) {
        setParams(ps, params);

        try (ResultSet rs = ps.executeQuery()) {
            ResultSetMetaData meta = rs.getMetaData();
            int columnCount = meta.getColumnCount();

            while (rs.next()) {
                // 每一行都创建一个新对象，不能在循环外反复复用。
                T obj = clazz.getDeclaredConstructor().newInstance();

                for (int i = 1; i <= columnCount; i++) {
                    String fieldName = toCamelCase(meta.getColumnLabel(i));
                    Field field = findField(clazz, fieldName);
                    if (field == null) {
                        // 此版本允许结果中有实体类不需要的列。
                        continue;
                    }
                    if (Modifier.isStatic(field.getModifiers())
                            || Modifier.isFinal(field.getModifiers())) {
                        throw new IllegalArgumentException("不能映射静态或 final 字段：" + fieldName);
                    }

                    field.setAccessible(true);
                    Object value = rs.getObject(i);
                    field.set(obj, convertValue(value, field.getType()));
                }
                list.add(obj);
            }
        }
        return list;
    } catch (SQLException | ReflectiveOperationException e) {
        // 查询失败或构造、赋值失败，都保留具体原因。
        throw new RuntimeException("查询或对象封装失败：" + sql, e);
    }
}

List<User> users = jdbc.query(
    "SELECT id, name FROM test1 WHERE id > ? ORDER BY id", User.class, 0
);
System.out.println(users);

[User(1, 张三), User(2, 李四), User(3, 王五)]

List<Student> students = jdbc.query(
    "SELECT id, name FROM student WHERE id > ? ORDER BY id", Student.class, 0
);
System.out.println(students);

[Student(1, 小明), Student(2, 小红)]

public class NamedUser extends User {
    private String userName;

    public NamedUser() {
    }

    @Override
    public String toString() {
        return super.toString() + ", userName=" + userName;
    }
}

NamedUser user = jdbc.queryOne(
    "SELECT id, name AS user_name FROM test1 WHERE id = ?",
    NamedUser.class,
    1
);
System.out.println(user);

User(1, null), userName=张三

private Object convertValue(Object value, Class<?> targetType) {
    if (value == null) {
        if (targetType.isPrimitive()) {
            // int 等基本类型不能接收 null，不能悄悄改成 0。
            throw new IllegalArgumentException("NULL 不能赋给基本类型：" + targetType.getName());
        }
        return null;
    }

    if (targetType.isInstance(value)) {
        return value; // 类型已经匹配，例如 String → String。
    }

    if (value instanceof Number n) {
        if (targetType == int.class || targetType == Integer.class) {
            // 精确转整数：有小数或超出 int 范围时抛异常。
            return new BigDecimal(n.toString()).intValueExact();
        }
        if (targetType == long.class || targetType == Long.class) {
            return new BigDecimal(n.toString()).longValueExact();
        }
        if (targetType == double.class || targetType == Double.class) {
            return n.doubleValue();
        }
    }

    if (targetType == String.class) {
        return value.toString();
    }
    throw new IllegalArgumentException(
        "不支持的类型转换：" + value.getClass().getName() + " -> " + targetType.getName()
    );
}

private void setParams(PreparedStatement ps, Object... params)
        throws SQLException {
    if (params == null) {
        return;
    }
    for (int i = 0; i < params.length; i++) {
        // Java 数组从 0 开始，JDBC 参数编号从 1 开始。
        ps.setObject(i + 1, params[i]);
    }
}

List<User> users = jdbc.query(
    "SELECT id, name FROM test1 WHERE id > ? AND name = ? ORDER BY id",
    User.class,
    10,
    "张三"
);

params[0] 是 10     → ps.setObject(1, 10)
params[1] 是 "张三" → ps.setObject(2, "张三")

public <T> T queryOne(String sql, Class<T> clazz, Object... params) {
    List<T> list = query(sql, clazz, params);
    return list.isEmpty() ? null : list.get(0);
}

User user = jdbc.queryOne(
    "SELECT id, name FROM test1 WHERE id = ?", User.class, 1
);
System.out.println(user); // User(1, 张三)

try (Connection conn = getConnection();
     PreparedStatement ps = conn.prepareStatement(sql)) {
    setParams(ps, params);
    return ps.executeUpdate();
}

List<User> users = jdbc.query(
    "SELECT id, name FROM test1 WHERE id > ? ORDER BY id", User.class, 0
);
System.out.println(users);

[User(1, 张三), User(2, 李四), User(3, 王五)]

List<User> twoUsers = jdbc.query(
    "SELECT id, name FROM test1 WHERE id IN (?, ?) ORDER BY id",
    User.class, 1, 2
);
System.out.println(twoUsers);

[User(1, 张三), User(2, 李四)]