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

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 '出版社',
  `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 '图书信息表';

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 层负责接收请求，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());
        }
    }

    /**
     * 处理用户登录请求，返回 JWT 令牌
     */
    @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());
        }
    }
}

class JwtAuthenticationResponse {
    private String accessToken;
    public JwtAuthenticationResponse(String accessToken) { this.accessToken = accessToken; }
    public String getAccessToken() { return accessToken; }
}

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

    /**
     * 用户登录逻辑，模拟生成 Token
     */
    public String loginUser(LoginRequestDto loginRequestDto) {
        // 此处省略与 Spring Security AuthenticationManager 的集成逻辑
        // 简单的模拟逻辑
        return "dummy-jwt-token-for-" + loginRequestDto.getUsername();
    }
}

模块二：图书借阅与归还

这是核心业务流程，涉及多表操作，需保证事务一致性。

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 工具，从输入需求到获得可运行的 Spring Boot 项目，仅需几分钟。这种数量级的效率提升是显而易见的。

代码规范性保障

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

开发者角色的转变

AI 将开发者从繁重重复的编码中解放出来。我们不再需要耗费大量时间编写模板化代码，而是可以将精力投入到需求澄清、复杂业务逻辑梳理、系统架构优化等更具创造性的工作中。

理性看待局限性

尽管表现出色，但 AI 并非万能。对于高度定制化的复杂业务逻辑，如精细的权限控制、特定并发场景下的数据一致性保障、以及复杂的业务规则计算，仍需要开发者进行手动深度编码和优化。AI 更像是一位知识渊博的'初级程序员'，它能完美规划蓝图、搭建毛坯房，但内部的精装修依然离不开人类设计师的匠心。

未来，AI 辅助开发工具将向更高层次迈进，如自动生成测试用例、智能重构建议、辅助技术选型等。拥抱这些工具，将成为未来优秀软件工程师的核心竞争力之一。