架构师成长之路：单体架构代码示例

单体架构代码示例：基于 Spring Boot 的用户管理 RESTful API

以下是完整的 Java 代码实现，采用经典三层架构（Controller / Service / Repository），使用 Spring Boot + JPA + H2 内存数据库。

---

项目结构

src/main/java
└── com
    └── example
        └── demo
            ├── controller
            │   └── UserController.java   # 控制层
            ├── service
            │   ├── UserService.java      # 服务接口
            │   └── UserServiceImpl.java  # 服务实现
            ├── repository
            │   └── UserRepository.java   # 数据访问层
            ├── model
            │   └── User.java             # 实体类
            └── DemoApplication.java      # 启动类

---

1. 实体类（Model Layer）

// src/main/java/com/example/demo/model/User.java
package com.example.demo.model;

import jakarta.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false)
    private String name;
    
    @Column(nullable = false, unique = true)
    private String email;

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

---

2. 数据访问层（Repository Layer）

// src/main/java/com/example/demo/repository/UserRepository.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, Long> {
    // 自定义查询方法：通过邮箱查找用户
    User findByEmail(String email);
}

---

3. 服务层（Service Layer）

// src/main/java/com/example/demo/service/UserService.java
package com.example.demo.service;

import com.example.demo.model.User;
import java.util.List;

public interface UserService {
    User createUser(User user);
    User getUserById(Long id);
    List<User> getAllUsers();
    User updateUser(Long id, User user);
    void deleteUser(Long id);
}

// src/main/java/com/example/demo/service/UserServiceImpl.java
package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public User createUser(User user) {
        return userRepository.save(user);
    }

    @Override
    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException("User not found with id: " + id));
    }

    @Override
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @Override
    public User updateUser(Long id, User userDetails) {
        User user = getUserById(id);
        user.setName(userDetails.getName());
        user.setEmail(userDetails.getEmail());
        return userRepository.save(user);
    }

    @Override
    public void deleteUser(Long id) {
        User user = getUserById(id);
        userRepository.delete(user);
    }
}

---

4. 控制层（Controller Layer）

// src/main/java/com/example/demo/controller/UserController.java
package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

---

5. 自定义异常处理

// src/main/java/com/example/demo/exception/UserNotFoundException.java
package com.example.demo.exception;

public class UserNotFoundException extends RuntimeException {
    public UserNotFoundException(String message) {
        super(message);
    }
}

// src/main/java/com/example/demo/exception/GlobalExceptionHandler.java
package com.example.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public String handleUserNotFound(UserNotFoundException ex) {
        return ex.getMessage();
    }
}

---

6. 启动类

// src/main/java/com/example/demo/DemoApplication.java
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

---

7. 配置文件（application.properties）

# 配置H2内存数据库
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=

# 配置JPA
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.format_sql=true

# 启用H2控制台
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

---

8. Maven 依赖（pom.xml）

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Spring Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    
    <!-- H2 Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

---

运行与测试

1. 启动应用：运行 DemoApplication，访问 http://localhost:8080/h2-console 查看数据库。
2. API 测试（使用 curl 或 Postman）：

   # 创建用户
   curl -X POST -H "Content-Type: application/json" \
        -d '{"name":"Alice","email":"alice@example.com"}' \
        http://localhost:8080/api/users
   
   # 查询所有用户
   curl http://localhost:8080/api/users
   
   # 更新用户
   curl -X PUT -H "Content-Type: application/json" \
        -d '{"name":"Alice Updated","email":"alice.new@example.com"}' \
        http://localhost:8080/api/users/1
   
   # 删除用户
   curl -X DELETE http://localhost:8080/api/users/1
   

---

架构特点总结

1. 单体架构特征：
   • 所有功能模块（用户管理）集中在一个应用中
   • 共享同一个数据库（H2）
   • 代码分层清晰（Controller/Service/Repository）
2. 三层架构规范：
   • Controller：处理 HTTP 请求/响应
   • Service：封装业务逻辑
   • Repository：负责数据持久化操作
3. RESTful 设计：
   • 使用标准 HTTP 方法（GET/POST/PUT/DELETE）
   • 资源路径语义化（/api/users）
   • 状态码符合 REST 规范（201 Created / 404 Not Found）