在Java中，如何进行数据库操作？有哪些常见的数据库访问技术（JDBC等）？它们的使用方法和步骤是什么？

在Java中进行数据库操作主要通过JDBC（Java Database Connectivity）及其扩展技术实现。以下是核心技术、使用步骤及示例：

1. 核心数据库访问技术

JDBC（Java Database Connectivity）

• 标准API：Java自带的数据库访问接口，支持所有主流数据库（MySQL、Oracle、PostgreSQL等）。
• 核心类：DriverManager、Connection、Statement、PreparedStatement、ResultSet。

ORM（对象关系映射）框架

• Hibernate：全自动ORM工具，通过映射文件或注解将Java对象与数据库表关联。
• MyBatis：半自动化ORM框架，支持SQL手动编写与对象映射。

JPA（Java Persistence API）

• 标准规范：基于ORM的Java持久化标准，Hibernate是其主流实现。

数据库连接池

• HikariCP：高性能连接池，Spring Boot默认选择。
• Apache DBCP：老牌连接池，稳定性高。

2. JDBC操作步骤

步骤1：加载驱动类

// MySQL 8+ 驱动
Class.forName("com.mysql.cj.jdbc.Driver");

// 或使用自动加载（JDBC 4.0+ 支持）
// String url = "jdbc:mysql://localhost:3306/mydb";

步骤2：建立连接

import java.sql.*;

String url = "jdbc:mysql://localhost:3306/mydb";
String username = "root";
String password = "password";
Connection conn = DriverManager.getConnection(url, username, password);

步骤3：执行SQL（查询示例）

try (Statement stmt = conn.createStatement();
     ResultSet rs = stmt.executeQuery("SELECT id, name FROM users")) {
    
    while (rs.next()) {
        int id = rs.getInt("id");
        String name = rs.getString("name");
        System.out.println("ID: " + id + ", Name: " + name);
    }
}

步骤4：预处理语句（PreparedStatement）

String sql = "INSERT INTO users (name, age) VALUES (?, ?)";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
    pstmt.setString(1, "Alice");
    pstmt.setInt(2, 30);
    pstmt.executeUpdate();
}

步骤5：事务管理

try {
    conn.setAutoCommit(false);  // 关闭自动提交
    
    // 执行多个操作
    Statement stmt = conn.createStatement();
    stmt.executeUpdate("UPDATE accounts SET balance = balance - 100 WHERE id = 1");
    stmt.executeUpdate("UPDATE accounts SET balance = balance + 100 WHERE id = 2");
    
    conn.commit();  // 提交事务
} catch (SQLException e) {
    conn.rollback();  // 回滚事务
    e.printStackTrace();
} finally {
    conn.setAutoCommit(true);  // 恢复自动提交
}

步骤6：关闭资源

使用try-with-resources自动关闭Connection、Statement、ResultSet：

try (Connection conn = DriverManager.getConnection(url, username, password);
     Statement stmt = conn.createStatement();
     ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
    // 使用资源
}  // 自动关闭所有资源

3. ORM框架（以Hibernate为例）

步骤1：配置hibernate.cfg.xml

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>
        <mapping class="com.example.User"/>
    </session-factory>
</hibernate-configuration>

步骤2：定义实体类

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(name = "name")
    private String name;
    
    // 构造函数、Getter/Setter
}

步骤3：执行CRUD操作

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

// 获取SessionFactory
SessionFactory factory = new Configuration().configure().buildSessionFactory();

// 保存对象
try (Session session = factory.openSession()) {
    session.beginTransaction();
    
    User user = new User();
    user.setName("Bob");
    session.save(user);
    
    session.getTransaction().commit();
}

// 查询对象
try (Session session = factory.openSession()) {
    User user = session.get(User.class, 1L);
    System.out.println("User: " + user.getName());
}

4. JPA（以Spring Data JPA为例）

步骤1：添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

步骤2：配置application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

步骤3：定义实体和Repository

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    // Getter/Setter
}

// 继承JpaRepository接口
public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByName(String name);
}

步骤4：使用Repository

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public void saveUser(String name) {
        User user = new User();
        user.setName(name);
        userRepository.save(user);
    }
    
    public List<User> findUsersByName(String name) {
        return userRepository.findByName(name);
    }
}

5. 数据库连接池（以HikariCP为例）

步骤1：添加依赖

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.0</version>
</dependency>

步骤2：配置连接池

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("root");
config.setPassword("password");
config.setMaximumPoolSize(10);
config.setAutoCommit(true);

HikariDataSource dataSource = new HikariDataSource(config);

步骤3：使用连接池获取连接

try (Connection conn = dataSource.getConnection();
     Statement stmt = conn.createStatement();
     ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
    // 使用连接
}

6. 选择建议

• 简单场景：直接使用JDBC（适合小项目或需要精细控制SQL的场景）。
• 企业应用：Spring Data JPA + Hibernate（简化开发，提供ORM和事务管理）。
• 高性能需求：JDBC + HikariCP（减少连接创建开销）。
• 复杂SQL：MyBatis（支持手动编写SQL，灵活映射结果）。

总结

Java数据库操作从底层JDBC到高层ORM形成完整生态，开发者可根据项目规模和需求选择合适的技术。核心流程通常包括连接建立、SQL执行、结果处理和资源释放，现代框架则通过自动化和注解进一步简化了开发过程。