在线图书借阅平台的设计与实现

// 控制器 UserController.java（自动生成注册/登录逻辑）
@RestController
@RequestMapping("/api/user")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping("/register")
    public Result register(@RequestBody UserRegisterDTO dto) {
        if (userService.checkUsernameExists(dto.getUsername())) {
            return Result.error("用户名已存在");
        }
        User user = new User();
        user.setUsername(dto.getUsername());
        user.setPassword(BCrypt.hashpw(dto.getPassword(), BCrypt.gensalt())); // 密码加密
        user.setEmail(dto.getEmail());
        user.setRole(0); // 默认普通用户
        user.setCreateTime(LocalDateTime.now());
        userService.save(user);
        return Result.success("注册成功");
    }

    @PostMapping("/login")
    public Result login(@RequestBody UserLoginDTO dto) {
        User user = userService.getByUsername(dto.getUsername());
        if (user == null || !BCrypt.checkpw(dto.getPassword(), user.getPassword())) {
            return Result.error("用户名或密码错误");
        }
        String token = JwtUtil.generateToken(user.getId(), user.getRole()); // JWT 生成
        return Result.success(token);
    }
}

2.2.2 借阅管理与事务控制

借阅过程涉及库存扣减和记录生成，必须保证事务一致性。以下代码展示了如何结合 @Transactional 注解处理借书逻辑。

// BorrowController.java
@PostMapping("/borrow")
@Transactional // 飞算 AI 自动添加事务注解
public Result borrowBook(@RequestParam Integer userId, @RequestParam Integer bookId) {
    Book book = bookService.getById(bookId);
    if (book == null || book.getAvailableCount() <= 0) {
        return Result.error("该图书暂无库存");
    }
    // 减少可借库存（原子操作）
    book.setAvailableCount(book.getAvailableCount() - 1);
    bookService.updateById(book);

    // 生成借阅记录
    BorrowRecord record = new BorrowRecord();
    record.setUserId(userId);
    record.setBookId(bookId);
    record.setBorrowDate(LocalDateTime.now());
    record.setDueDate(LocalDateTime.now().plusDays(30));
    record.setStatus(0); // 0-未归还
    borrowRecordService.save(record);
    return Result.success("借书成功，应还日期：" + record.getDueDate());
}

2.2.3 图书资源管理

图书的增删改查是后台管理的核心。以下是基于 MyBatis-Plus 实现的 Service 层逻辑。

package com.feisuanyz.service.impl;
import com.feisuanyz.dto.BookDTO;
import com.feisuanyz.dto.BookQuery;
import com.feisuanyz.dto.RestResult;
import com.feisuanyz.entity.BookDO;
import com.feisuanyz.repository.BookRepository;
import com.feisuanyz.service.BookService;
import java.util.List;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Slf4j
@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookRepository bookRepository;

    @Override
    @Transactional
    public RestResult addBook(BookDTO bookDTO) {
        if (bookDTO.getIsbn() == null || bookDTO.getTitle() == null || bookDTO.getAuthor() == null) {
            return RestResult.failure("000001", "参数不完整");
        }
        if (bookRepository.existsByIsbn(bookDTO.getIsbn())) {
            return RestResult.failure("000001", "该图书已存在");
        }
        BookDO bookDO = new BookDO();
        BeanUtils.copyProperties(bookDTO, bookDO);
        bookRepository.save(bookDO);
        return RestResult.success("000000", "调用成功", bookDTO);
    }

    @Override
    @Transactional
    public RestResult updateBook(BookDTO bookDTO) {
        BookDO bookDO = bookRepository.findById(bookDTO.getId()).orElse(null);
        if (bookDO == null) {
            return RestResult.failure("000001", "图书不存在");
        }
        BeanUtils.copyProperties(bookDTO, bookDO, "id", "isbn");
        bookRepository.save(bookDO);
        return RestResult.success("000000", "调用成功", bookDTO);
    }

    @Override
    @Transactional
    public RestResult deleteBook(Long id) {
        BookDO bookDO = bookRepository.findById(id).orElse(null);
        if (bookDO == null) {
            return RestResult.failure("000001", "图书不存在");
        }
        bookRepository.delete(bookDO);
        return RestResult.success("000000", "调用成功", null);
    }

    @Override
    public RestResult getBooksByCategory(BookQuery bookQuery) {
        List<BookDO> books;
        if (bookQuery.getCategory() != null && !bookQuery.getCategory().isEmpty()) {
            books = bookRepository.findByCategory(bookQuery.getCategory());
        } else {
            books = bookRepository.findAll();
        }
        List<BookDTO> bookDTOS = books.stream().map(bookDO -> {
            BookDTO bookDTO = new BookDTO();
            BeanUtils.copyProperties(bookDO, bookDTO);
            return bookDTO;
        }).collect(Collectors.toList());
        return RestResult.success("000000", "调用成功", bookDTOS);
    }
}

2.3 逾期管理与数据统计

2.3.1 逾期计算逻辑

需求明确：每天凌晨检查借阅记录中 due_date < 当前日期 且 status=0 的记录，计算逾期天数。若逾期天数大于 0 则更新用户违约金；若逾期天数超过 30 天则将用户标记为黑名单。

AI 生成的定时任务代码如下：

// OverdueTask.java
@Component
public class OverdueTask {
    @Autowired
    private BorrowRecordService borrowRecordService;
    @Autowired
    private UserService userService;

    @Scheduled(cron = "0 0 0 * * ?") // 每天凌晨执行
    public void checkOverdue() {
        LocalDateTime now = LocalDateTime.now();
        List<BorrowRecord> overdueRecords = borrowRecordService.list(
            new LambdaQueryWrapper<BorrowRecord>()
                .lt(BorrowRecord::getDueDate, now)
                .eq(BorrowRecord::getStatus, 0)
        );
        overdueRecords.forEach(record -> {
            long daysOverdue = ChronoUnit.DAYS.between(record.getDueDate(), now);
            // 更新用户违约金（简化逻辑：累计 1 元/天）
            User user = userService.getById(record.getUserId());
            user.setFineAmount(user.getFineAmount() + (int) daysOverdue);
            if (daysOverdue > 30) {
                user.setRole(1); // 标记为黑名单
            }
            userService.updateById(user);
            record.setStatus(1); // 标记为已逾期
            borrowRecordService.updateById(record);
        });
    }
}

2.4 工程结构全景

最终生成的工程目录结构遵循标准分层架构：

online_library/
├── src/main/java/com/library/online/
│   ├── controller/ # 接口层（UserController, BookController...）
│   ├── entity/     # 实体类（User, Book, BorrowRecord...）
│   ├── mapper/     # 数据访问层（UserMapper, BookMapper...）
│   ├── service/    # 业务逻辑层（UserService, BookService...）
│   ├── dto/        # 数据传输对象（UserRegisterDTO, UserLoginDTO...）
│   ├── util/       # 工具类（JwtUtil, Result...）
│   └── OnlineLibraryApplication.java # 启动类
├── src/main/resources/
│   ├── application.yml # 数据库配置（spring.datasource.url 等）
│   └── mapper/         # MyBatis XML 文件（如 BorrowRecordMapper.xml）

三、优化与调试心得

3.1 典型问题 1：SQL 性能瓶颈（库存查询慢）

问题现象：当图书总量超过 1 万条时，SELECT * FROM book WHERE available_count > 0 查询耗时超过 2 秒。

解决方案：

• 添加索引：执行 SQL ALTER TABLE book ADD INDEX idx_available (available_count);
• 优化查询：修改生成的 BookController.java，限定返回字段（仅 id, title, available_count），避免全表扫描。

优化后效果：查询时间从 2.1s 降至 120ms。

3.2 典型问题 2：JWT 令牌过期处理缺失

问题现象：用户登录后，若 30 分钟内无操作，再次请求接口返回 401 未授权。

解决步骤：

1. 定位到 JwtUtil.java 中的过期时间配置（原为 30 分钟）。
2. 调整配置：修改 JwtUtil.generateToken() 方法中的 expiration 参数为 2 小时（new Date(System.currentTimeMillis() + 2 * 60 * 60 * 1000)）。
3. 前端配合：在 Vue 中存储 JWT 时，通过拦截器自动刷新令牌（本文聚焦后端，前端逻辑略）。

3.3 其他优化：代码规范性调整

AI 生成的初始代码虽功能完整，但部分命名可读性不足（如 Result 类未明确区分成功/失败字段）。通过手动调整：

• 统一响应格式：修改 Result.java 为 {code: 200, msg: "success", data: {...}} 结构。
• 日志增强：在关键业务方法（如借阅、归还）中添加 @Slf4j 注解，记录操作流水（例如：'用户 ID 1001 借阅图书 ID 2001，应还日期 202X-XX-XX'）。

四、成果展示与总结

4.1 最终工程结构图

首页展示清晰，支持对图书进行管理操作。对于类型的管理操作也已完成集成。在图书信息管理页面可以查看图书名称、图书分类、图片、作者、出版社、数量、可借天数、可借数量、图书简介等信息，进行入库、出库、操作盘点，并可根据需要对已有图书信息进行修改或删除等详细操作。同时可查看对应借阅状态。

4.2 技术优势与不足

优势总结：

1. 需求驱动开发：通过自然语言描述功能需求，自动生成符合 Spring Boot 规范的代码，减少 60% 以上的重复编码工作量。
2. 智能引导精准：对复杂业务逻辑（如借阅事务、定时任务）的描述支持度高，生成的代码可直接运行并通过基础测试。
3. 调试辅助强大：内置性能分析、接口测试功能，快速定位 SQL 慢查询、令牌过期等问题。
4. 工程结构标准：自动生成的分层结构符合企业级开发规范，降低后期维护成本。

不足与改进建议：

1. 复杂逻辑扩展性：对于高度定制化的业务规则（如多级权限校验），生成的代码可能需要手动补充逻辑。
2. 前端集成局限：当前版本更聚焦后端开发，若需前后端联调，需额外手动编写前端调用代码。

4.3 个人使用体会

本次通过 AI 辅助开发在线图书借阅平台，深刻体会到智能化工具对开发效率的提升：

• 新手友好：即使对 Spring Boot 或 MyBatis-Plus 不熟悉，也能通过需求描述快速生成可用代码，降低了学习曲线。
• 效率革命：原本需要 3-5 天完成的基础功能开发（用户 + 图书 + 借阅），通过 AI 实现核心链路打通，剩余时间用于业务逻辑优化。

未来若结合更多高级功能，可进一步缩短全流程开发周期，值得在更多项目中推广使用。