在 Spring Boot 中开发一个 API 接口并读写数据库，通常需要编写以下核心类和对象，遵循 MVC（Model-View-Controller）分层架构。以下是一个清晰的分步指南，适合刚入门的开发者：

---

1. 项目结构示例

src/main/java
├── com.example.demo
│   ├── controller       # API 接口层（处理 HTTP 请求）
│   ├── service          # 业务逻辑层（处理业务逻辑）
│   ├── repository       # 数据访问层（操作数据库）
│   ├── model            # 数据模型层（映射数据库表）
│   └── dto              # 数据传输对象（用于接口输入/输出）

---

2. 核心类与对象说明

(1) 实体类（Model）

• 作用：映射数据库表，定义表结构和字段。
• 位置：model 包下。
• 关键注解：@Entity, @Table, @Id, @Column。
• 示例（User.java）：

  import javax.persistence.*;
  
  @Entity
  @Table(name = "users")  // 对应数据库表名
  public class User {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
  
      @Column(nullable = false)  // 非空字段
      private String name;
  
      @Column(unique = true)     // 唯一字段
      private String email;
  
      // Getter & Setter
  }
  

---

(2) Repository 接口（数据访问层）

• 作用：定义数据库操作方法，Spring Data JPA 会自动生成实现。
• 位置：repository 包下。
• 关键接口：JpaRepository。
• 示例（UserRepository.java）：

  import org.springframework.data.jpa.repository.JpaRepository;
  
  public interface UserRepository extends JpaRepository<User, Long> {
      // 可自定义查询方法（如根据邮箱查找用户）
      User findByEmail(String email);
  }
  

---

(3) Service 类（业务逻辑层）

• 作用：封装业务逻辑，调用 Repository 操作数据库。
• 位置：service 包下。
• 关键注解：@Service, @Transactional。
• 示例（UserService.java）：

  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  
  @Service
  public class UserService {
      private final UserRepository userRepository;
  
      // 通过构造器注入依赖
      public UserService(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
  
      // 保存用户
      @Transactional
      public User createUser(User user) {
          return userRepository.save(user);
      }
  
      // 获取所有用户
      public List<User> getAllUsers() {
          return userRepository.findAll();
      }
  }
  

---

(4) Controller 类（API 接口层）

• 作用：处理 HTTP 请求，返回 JSON 响应。
• 位置：controller 包下。
• 关键注解：@RestController, @GetMapping, @PostMapping, @RequestBody。
• 示例（UserController.java）：

  import org.springframework.web.bind.annotation.*;
  
  @RestController
  @RequestMapping("/api/users")
  public class UserController {
      private final UserService userService;
  
      public UserController(UserService userService) {
          this.userService = userService;
      }
  
      // 创建用户（POST请求）
      @PostMapping
      public User createUser(@RequestBody User user) {
          return userService.createUser(user);
      }
  
      // 获取用户列表（GET请求）
      @GetMapping
      public List<User> getAllUsers() {
          return userService.getAllUsers();
      }
  }
  

---

(5) DTO（数据传输对象）

• 作用：隔离 API 接口与实体类，防止暴露敏感字段或冗余数据。
• 位置：dto 包下。
• 示例（UserDTO.java）：

  public class UserDTO {
      private String name;
      private String email;
  
      // Getter & Setter
  }
  

---

3. 完整流程说明

1. 客户端发起请求（如 POST /api/users）。
2. Controller 接收请求，解析参数（如 @RequestBody UserDTO）。
3. Service 处理业务逻辑（如数据校验、转换 DTO 为实体类）。
4. Repository 操作数据库（如 save(user)）。
5. 返回响应（如 User 实体类自动转换为 JSON）。

---

4. 配置与依赖

(1) 添加依赖（pom.xml）

<!-- Spring Data JPA -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!-- 数据库驱动（如 MySQL） -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

(2) 配置数据库（application.yml）

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb?useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update  # 自动更新表结构（生产环境建议设为 none）
    show-sql: true      # 显示 SQL 日志

---

5. 示例：创建用户接口

(1) 请求示例（POST /api/users）

{
  "name": "张三",
  "email": "zhangsan@example.com"
}

(2) 响应示例

{
  "id": 1,
  "name": "张三",
  "email": "zhangsan@example.com"
}

---

6. 常见问题

(1) 如何处理参数校验？

使用 javax.validation 注解（如 @NotBlank）并在 Controller 方法添加 @Valid：

@PostMapping
public User createUser(@Valid @RequestBody UserDTO userDTO) {
    // ...
}

(2) 如何返回统一响应格式？

定义通用响应类（如 ApiResponse<T>）：

public class ApiResponse<T> {
    private int code;
    private String message;
    private T data;
    // Getter & Setter
}

(3) 如何分页查询？

在 Repository 中继承 PagingAndSortingRepository：

public interface UserRepository extends JpaRepository<User, Long>, PagingAndSortingRepository<User, Long> {
}

// Controller 中使用 Pageable
@GetMapping
public Page<User> getUsers(Pageable pageable) {
    return userRepository.findAll(pageable);
}

---

总结

通过定义 Model → Repository → Service → Controller 的分层结构，结合 Spring Boot 的自动配置和注解驱动开发，可以快速实现 API 接口与数据库的交互。关键步骤：

1. 实体类映射数据库表。
2. Repository 定义数据操作。
3. Service 封装业务逻辑。
4. Controller 处理 HTTP 请求。
5. DTO 隔离接口与实体类。