Spring Boot 的 JDBC API 和 Spring Data JPA

Spring Boot 的 JDBC API 和 Spring Data JPA 是两种不同的持久化技术，它们在功能、使用方式和抽象层次上有显著的差异。以下是它们的主要相同点和不同点：

相同点

目标：
- 两者都用于与关系型数据库进行交互，实现数据持久化。
集成：
- 都可以集成到 Spring Boot 应用中，通过配置文件进行数据库连接配置。
依赖管理：
- 都需要在 pom.xml 文件中添加相应的依赖。

不同点

抽象层次

JDBC API：
- 是 Java 标准库的一部分，提供低级别的数据库访问。
- 需要手动管理数据库连接、事务、SQL 语句和结果集。
- 适合需要细粒度控制的场景。
Spring Data JPA：
- 是 Spring Data 的一部分，基于 JPA (Java Persistence API) 提供高级别的数据库访问抽象。
- 通过注解和接口自动生成常见的 CRUD 操作，大大简化了开发工作。
- 适合快速开发和简化数据库访问代码的场景。

配置和使用

JDBC API：
- 需要配置数据源（DataSource）并手动创建 JDBC 模板（JdbcTemplate）。
- 需要编写 SQL 语句来进行数据库操作。
Spring Data JPA：
- 需要配置 JPA 提供商（如 Hibernate）。
- 通过注解和 Repository 接口来定义实体和数据库操作，不需要编写 SQL 语句。

事务管理

JDBC API：

需要手动管理事务，通常通过 DataSourceTransactionManager 或编程式事务管理。

@Resource 复制代码

PlatformTransactionManager platformTransactionManager;
 @Resource
TransactionDefinition transactionDefinition;

private void save(Record record){
        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);
    try {
	   //do sth 
        demoService.saveOrUpdate(record);
        updateShopContactRelation(sourceAdminInfo.getAdminId(), recordEdit.getAuthAdminId());
        platformTransactionManager.commit(transactionStatus);
    }catch (Exception e){
        log.error("updateShopRelationError",e);
        platformTransactionManager.rollback(transactionStatus);
    }
}

spring框架中也可以结合@Transactional自动管理事务
@Transactional(rollbackFor = Exception.class)

Spring Data JPA：
- 自动管理事务，通常通过 @Transactional 注解来声明事务范围。
- @Transactional(rollbackFor = Exception.class)

查询能力

JDBC API：
- 需要编写原生 SQL 查询。
- 提供基本的查询功能，但缺乏高级特性。
Spring Data JPA：
- 支持 JPQL (Java Persistence Query Language) 和原生 SQL 查询。
- 提供丰富的查询功能，包括动态查询、分页和排序。

学习曲线

JDBC API：
- 学习曲线较低，适合初学者。
- 需要详细了解 SQL 和数据库操作。
Spring Data JPA：
- 学习曲线较高，但一旦掌握可以极大提高开发效率。
- 需要了解 JPA 和 ORM (Object-Relational Mapping) 概念。

示例对比

使用 JDBC API

依赖（在 pom.xml 中）：

xml 复制代码

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
			<groupId>com.mysql</groupId>
			<artifactId>mysql-connector-j</artifactId>
			<scope>runtime</scope>
</dependency>

配置文件（application.properties）：

properties 复制代码

spring.datasource.url=jdbc:mysql://localhost:3306/demo
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

DAO 类：

java 复制代码

package com.example.demo.dao;

import com.example.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@Repository
public class UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    private static final class UserMapper implements RowMapper<User> {
        public User mapRow(ResultSet rs, int rowNum) throws SQLException {
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setName(rs.getString("name"));
            user.setEmail(rs.getString("email"));
            return user;
        }
    }

    public List<User> findAll() {
        return jdbcTemplate.query("SELECT * FROM users", new UserMapper());
    }

    public User findById(int id) {
        return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", new Object[]{id}, new UserMapper());
    }

    public int save(User user) {
        return jdbcTemplate.update("INSERT INTO users (name, email) VALUES (?, ?)",
                user.getName(), user.getEmail());
    }

    public int update(User user) {
        return jdbcTemplate.update("UPDATE users SET name = ?, email = ? WHERE id = ?",
                user.getName(), user.getEmail(), user.getId());
    }

    public int deleteById(int id) {
        return jdbcTemplate.update("DELETE FROM users WHERE id = ?", id);
    }
}

使用 Spring Data JPA

依赖（在 pom.xml 中）：

xml 复制代码

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
			<groupId>com.mysql</groupId>
			<artifactId>mysql-connector-j</artifactId>
			<scope>runtime</scope>
</dependency>

配置文件（application.properties）：

properties 复制代码

spring.datasource.url=jdbc:mysql://localhost:3306/demo
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA & Hibernate
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

实体类：

java 复制代码

package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Data
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String email;
}

Repository 接口：

java 复制代码

package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Integer> {
}

通过对比可以看出，Spring Data JPA 提供了更高级的抽象和功能，可以显著减少样板代码，提升开发效率。而 JDBC API 则提供了底层的数据库操作能力，适用于需要细粒度控制和优化的场景。

目前国内大厂带头使用mybatis、mybatis-plus，给国内程序员的感觉好像已经被mybatis全面覆盖了，其实不然，国外还是以JPA为主的。只是国内大厂毕业的人带着大厂文化不断传播导致的一直假象。那mybatis和jpa都属于高级的数据库操作，感兴趣的可以研究对比一下。

根据项目需求和开发团队的熟悉程度，选择合适的持久化技术可以更好地实现项目目标。