在线图书借阅平台设计与实现：AI 辅助开发实战

4. 数据库表结构设计

数据模型是应用的骨架。AI 会根据 API 涉及的数据实体及其关系，智能生成数据库表结构。以下是经过微调确认后的详细 SQL DDL 脚本：

借阅记录表 (t_borrow_record)

CREATE TABLE `t_borrow_record` (
  `id` BIGINT AUTO_INCREMENT PRIMARY KEY COMMENT '借阅记录唯一 ID',
  `user_id` BIGINT NOT NULL COMMENT '借阅用户的 ID',
  `book_id` BIGINT NOT NULL COMMENT '被借阅图书的 ID',
  `borrow_date` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '借出时间',
  `due_date` DATETIME NOT NULL COMMENT '应归还日期',
  `return_date` DATETIME COMMENT '实际归还时间',
  `status` VARCHAR(20) NOT NULL COMMENT '状态 (BORROWED, RETURNED, OVERDUE)',
  `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  INDEX `idx_user_id` (`user_id`),
  INDEX `idx_book_id` (`book_id`),
  CONSTRAINT `fk_borrow_user` FOREIGN KEY (`user_id`) REFERENCES `t_user` (`id`) ON DELETE CASCADE,
  CONSTRAINT `fk_borrow_book` FOREIGN KEY (`book_id`) REFERENCES `t_book` (`id`) ON DELETE RESTRICT
) COMMENT '图书借阅记录表';

图书表 (t_book)

CREATE TABLE `t_book` (
  `id` BIGINT AUTO_INCREMENT PRIMARY KEY COMMENT '图书唯一 ID',
  `title` VARCHAR(255) NOT NULL COMMENT '书名',
  `author` VARCHAR(100) NOT NULL COMMENT '作者',
  `isbn` VARCHAR(20) NOT NULL UNIQUE COMMENT '国际标准书号',
  `publisher` VARCHAR(100) COMMENT '出版社',
  `publication_date` DATE COMMENT '出版日期',
  `description` TEXT COMMENT '内容简介',
  `cover_image_url` VARCHAR(512) COMMENT '封面图片 URL',
  `total_quantity` INT NOT NULL DEFAULT 0 COMMENT '总入库数量',
  `available_quantity` INT NOT NULL DEFAULT 0 COMMENT '当前可借阅库存',
  `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) COMMENT '图书信息表';

用户表 (t_user)

CREATE TABLE `t_user` (
  `id` BIGINT AUTO_INCREMENT PRIMARY KEY COMMENT '用户唯一 ID',
  `username` VARCHAR(50) NOT NULL UNIQUE COMMENT '用户名',
  `password_hash` VARCHAR(255) NOT NULL COMMENT '加密后的密码哈希值',
  `email` VARCHAR(100) UNIQUE COMMENT '用户邮箱',
  `role` VARCHAR(20) NOT NULL DEFAULT 'USER' COMMENT '用户角色',
  `created_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_at` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) COMMENT '用户表';

核心业务逻辑生成与深度解析

设计阶段完成后，进入代码生成环节。AI 会构建出一个完整的、结构化的 Spring Boot 后端项目。生成过程非常迅速，我们将深入几个核心功能的代码进行解析。

模块一：用户认证

这是任何系统的入口，安全性至关重要。

Controller 层

package com.example.library.controller;

import com.example.library.dto.LoginRequestDto;
import com.example.library.dto.UserRegistrationDto;
import com.example.library.service.AuthService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;

@RestController
@RequestMapping("/api/auth")
public class AuthController {
    @Autowired
    private AuthService authService;

    /**
     * 处理用户注册请求
     */
    @PostMapping("/register")
    public ResponseEntity<?> registerUser(@Valid @RequestBody UserRegistrationDto registrationDto) {
        try {
            authService.registerUser(registrationDto);
            return ResponseEntity.ok("用户注册成功！");
        } catch (RuntimeException e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }

    /**
     * 处理用户登录请求
     */
    @PostMapping("/login")
    public ResponseEntity<?> authenticateUser(@Valid @RequestBody LoginRequestDto loginRequestDto) {
        try {
            String jwt = authService.loginUser(loginRequestDto);
            return ResponseEntity.ok(new JwtAuthenticationResponse(jwt));
        } catch (Exception e) {
            return ResponseEntity.status(401).body("认证失败：" + e.getMessage());
        }
    }
}

Service 层

这里需要注意密码加密的处理。我们使用 PasswordEncoder 对密码进行加密存储，确保即使数据库泄露，密码也不会明文暴露。

package com.example.library.service;

import com.example.library.dto.LoginRequestDto;
import com.example.library.dto.UserRegistrationDto;
import com.example.library.model.User;
import com.example.library.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class AuthService {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Transactional
    public void registerUser(UserRegistrationDto registrationDto) {
        if (userRepository.existsByUsername(registrationDto.getUsername())) {
            throw new RuntimeException("错误：用户名已被占用!");
        }
        if (userRepository.existsByEmail(registrationDto.getEmail())) {
            throw new RuntimeException("错误：电子邮箱已被注册!");
        }
        User user = new User();
        user.setUsername(registrationDto.getUsername());
        user.setPasswordHash(passwordEncoder.encode(registrationDto.getPassword()));
        user.setEmail(registrationDto.getEmail());
        user.setRole("USER");
        userRepository.save(user);
    }

    public String loginUser(LoginRequestDto loginRequestDto) {
        // 此处省略了与 Spring Security AuthenticationManager 的集成逻辑
        // 简单的模拟逻辑：验证密码并返回 Token
        return "dummy-jwt-token-for-user";
    }
}

模块二：图书借阅与归还

这是平台的核心业务流程，涉及多表操作，需要保证事务的一致性。特别注意并发控制，防止超卖或重复借阅。

Controller 层

在实际项目中，userId 应从安全上下文中获取，而不是从请求体中传递。例如使用 @AuthenticationPrincipal。

package com.example.library.controller;

import com.example.library.dto.BorrowRequestDto;
import com.example.library.service.BorrowService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/borrows")
public class BorrowController {
    @Autowired
    private BorrowService borrowService;

    @PostMapping
    public ResponseEntity<?> borrowBook(@RequestBody BorrowRequestDto borrowRequestDto) {
        try {
            Long currentUserId = 1L; // 假设从上下文获取
            borrowService.borrowBook(currentUserId, borrowRequestDto.getBookId());
            return ResponseEntity.ok("图书借阅成功！");
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }

    @PutMapping("/{recordId}/return")
    public ResponseEntity<?> returnBook(@PathVariable Long recordId) {
        try {
            Long currentUserId = 1L;
            borrowService.returnBook(currentUserId, recordId);
            return ResponseEntity.ok("图书归还成功！");
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }
}

Service 层

这里使用了悲观锁 (PESSIMISTIC_WRITE) 来锁定图书信息，防止并发问题。同时检查库存和用户是否已借阅此书。

package com.example.library.service;

import com.example.library.model.Book;
import com.example.library.model.BorrowRecord;
import com.example.library.repository.BookRepository;
import com.example.library.repository.BorrowRecordRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

@Service
public class BorrowService {
    @Autowired
    private BookRepository bookRepository;
    @Autowired
    private BorrowRecordRepository borrowRecordRepository;
    private static final int BORROW_DURATION_DAYS = 30;

    @Transactional
    public void borrowBook(Long userId, Long bookId) {
        // 1. 锁定并获取图书信息
        Book book = bookRepository.findByIdWithLock(bookId).orElseThrow(() -> new RuntimeException("图书不存在"));
        
        // 2. 检查库存
        if (book.getAvailableQuantity() <= 0) {
            throw new RuntimeException("图书《" + book.getTitle() + "》库存不足");
        }
        
        // 3. 检查是否已借阅
        if (borrowRecordRepository.existsByUserIdAndBookIdAndStatus(userId, bookId, "BORROWED")) {
            throw new RuntimeException("您已借阅该书，请勿重复借阅");
        }
        
        // 4. 更新库存
        book.setAvailableQuantity(book.getAvailableQuantity() - 1);
        bookRepository.save(book);
        
        // 5. 创建借阅记录
        BorrowRecord newRecord = new BorrowRecord();
        newRecord.setUserId(userId);
        newRecord.setBookId(bookId);
        newRecord.setBorrowDate(LocalDateTime.now());
        newRecord.setDueDate(LocalDateTime.now().plus(BORROW_DURATION_DAYS, ChronoUnit.DAYS));
        newRecord.setStatus("BORROWED");
        borrowRecordRepository.save(newRecord);
    }

    @Transactional
    public void returnBook(Long userId, Long recordId) {
        BorrowRecord record = borrowRecordRepository.findById(recordId).orElseThrow(() -> new RuntimeException("记录不存在"));
        
        if (!record.getUserId().equals(userId)) {
            throw new SecurityException("无权操作他人的借阅记录");
        }
        
        if ("RETURNED".equals(record.getStatus())) {
            throw new RuntimeException("该书已归还");
        }
        
        Book book = bookRepository.findByIdWithLock(record.getBookId()).orElseThrow(() -> new RuntimeException("图书不存在"));
        book.setAvailableQuantity(book.getAvailableQuantity() + 1);
        bookRepository.save(book);
        
        record.setStatus("RETURNED");
        record.setReturnDate(LocalDateTime.now());
        borrowRecordRepository.save(record);
    }
}

Repository 层扩展

package com.example.library.repository;

import com.example.library.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Lock;
import org.springframework.stereotype.Repository;
import javax.persistence.LockModeType;
import java.util.Optional;

@Repository
public interface BookRepository extends JpaRepository<Book, Long> {
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    Optional<Book> findByIdWithLock(Long id);
}

总结与思考

通过本次从零到一的开发实践，我们对 AI 辅助编程工具的价值有了更深刻的认识。

实践成果：

1. 开发效率飞跃：传统模式下完成此类项目至少需要数个工作日，而使用 AI 工具，从输入需求到获得可运行的 Spring Boot 项目，整个过程被压缩到了几分钟之内。
2. 代码质量保障：AI 生成的代码具有高度规范性，自动采用了业界主流的技术栈，实现了清晰的分层架构，正确应用了依赖注入、事务管理等核心概念。
3. 开发者角色转变：AI 将开发者从繁重、重复的编码工作中解放出来，使我们能更多地投入到需求澄清、复杂业务逻辑梳理及系统架构优化中。

深度思考：

尽管 AI 表现出色，但它并非万能的银弹。对于一些高度定制化的复杂业务逻辑，例如精细的权限控制、特定业务规则的计算，仍需要开发者进行手动的深度编码和优化。

AI 目前更像一个知识渊博的'架构师兼初级程序员'。它能为你完美地规划蓝图、搭建毛坯房，但内部的精装修和个性化设计，依然离不开人类设计师的匠心独运。

展望未来，AI 辅助开发工具的发展方向必然是向着更高层次的智能迈进。我们可以期待它们在未来能够自动生成单元测试、主动发现代码坏味并提出优化建议，甚至辅助进行技术选型和 CI/CD 部署。拥抱并善用这些工具，将成为未来优秀软件工程师的核心竞争力之一。