基于飞算 JavaAI 的在线图书借阅平台设计与实现

3. 数据库表结构设计

数据模型是应用的骨架。AI 根据实体关系生成 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 后端项目。以下对几个关键模块的代码进行解析。

1. 用户认证模块

安全性是入口的关键。Controller 层负责接收请求，Service 层处理业务逻辑。

AuthController.java

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());
        }
    }
}

AuthService.java

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 的集成逻辑
        // 简单的模拟逻辑：验证密码
        // User user = userRepository.findByUsername(...);
        // if (!passwordEncoder.matches(...)) { throw ...; }
        // return tokenProvider.generateToken(...);
        
        return "dummy-jwt-token-for-" + loginRequestDto.getUsername();
    }
}

2. 借阅与归还流程

这是核心业务，涉及多表操作和事务一致性。特别注意并发控制。

BorrowController.java

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;

    /**
     * 借阅一本书
     * 注意：在实际项目中，userId 应从安全上下文中获取，而非请求体
     */
    @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());
        }
    }
}

BorrowService.java

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("图书不存在，ID: " + bookId));

        // 2. 检查库存
        if (book.getAvailableQuantity() <= 0) {
            throw new RuntimeException("图书《" + book.getTitle() + "》库存不足，无法借阅。");
        }

        // 3. 检查是否已借阅且未归还
        if (borrowRecordRepository.existsByUserIdAndBookIdAndStatus(userId, bookId, "BORROWED")) {
            throw new RuntimeException("您已借阅《" + book.getTitle() + "》，请勿重复借阅。");
        }

        // 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) {
        // 1. 获取借阅记录
        BorrowRecord record = borrowRecordRepository.findById(recordId)
                .orElseThrow(() -> new RuntimeException("借阅记录不存在，ID: " + recordId));

        // 2. 验证权限
        if (!record.getUserId().equals(userId)) {
            throw new SecurityException("无权操作他人的借阅记录。");
        }

        // 3. 防止重复归还
        if ("RETURNED".equals(record.getStatus())) {
            throw new RuntimeException("该书已归还，请勿重复操作。");
        }

        // 4. 更新库存
        Book book = bookRepository.findByIdWithLock(record.getBookId())
                .orElseThrow(() -> new RuntimeException("关联的图书信息已不存在。"));
        book.setAvailableQuantity(book.getAvailableQuantity() + 1);
        bookRepository.save(book);

        // 5. 更新状态
        record.setStatus("RETURNED");
        record.setReturnDate(LocalDateTime.now());
        borrowRecordRepository.save(record);
    }
}

BookRepository.java

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> {

    /**
     * 通过 ID 查找图书并施加悲观写锁
     */
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    Optional<Book> findByIdWithLock(Long id);
}

总结与思考

通过本次从零到一的实战，可以看出 AI 辅助编程工具的价值。

效率提升显著：传统模式下完成框架搭建、数据库设计及基础 CRUD 代码编写至少需要数个工作日，而使用 AI 工具可将此过程压缩至几分钟。

代码规范性保障：AI 生成的代码自动采用主流技术栈，实现了清晰的分层架构（Controller, Service, Repository），正确应用了依赖注入和事务管理，为后续维护奠定基础。

开发者角色转变：工具将开发者从重复劳动中解放出来，使其能更专注于需求澄清、复杂逻辑梳理及系统架构优化。

当然，AI 并非万能。对于高度定制化的复杂业务逻辑（如精细权限控制、特定业务规则计算），仍需人工深度介入。当前 AI 更像是一位高效的'架构师兼初级程序员'，它能规划蓝图、搭建毛坯，但精装修依然需要人类设计师的匠心。未来，随着工具向单元测试生成、智能重构及自动化运维方向发展，AI 将成为工程师的核心竞争力之一。