AI 辅助 Java 开发：在线图书借阅平台从 0 到 1 实战

优化后的方案：

-- 创建物化视图
CREATE MATERIALIZED VIEW mv_reader_borrow_stats AS 
SELECT reader_id, COUNT(*) as total_count, SUM(CASE WHEN status = 'OVERDUE' THEN 1 ELSE 0 END) as overdue_count 
FROM borrow_record GROUP BY reader_id;

-- 最终查询
SELECT * FROM mv_reader_borrow_stats WHERE total_count > 5 ORDER BY overdue_count DESC;

3.2 并发控制：乐观锁机制，解决超卖难题

借阅系统中，并发请求导致超卖现象频发，严重影响了系统的准确性和稳定性。为解决这一问题，我们引入了乐观锁机制。通过在实体类中添加 @Version 注解，记录数据的版本号。在并发更新时，系统会检查版本号是否一致，若不一致则说明数据已被其他事务修改，当前事务将回滚，从而避免了超卖问题的发生。

// 使用乐观锁解决并发更新问题
@Version
private Integer version;

3.3 缓存策略调整：从本地到分布式，应对高并发挑战

最初，平台采用简单的本地缓存，但在高并发场景下，出现了内存溢出的问题。为解决这一问题，我们对缓存策略进行了全面调整：

1. 改用 Redis 分布式缓存：将缓存数据存储在 Redis 中，利用 Redis 的高性能和分布式特性，提高了缓存的并发处理能力。
2. 设置合理的过期时间和淘汰策略：根据数据的访问频率和重要性，设置不同的过期时间，并采用 LRU 等淘汰策略，确保缓存空间的有效利用。
3. 对高频访问的数据进行预热：在系统启动时，将高频访问的数据提前加载到缓存中，减少缓存击穿的可能性。

四、成果展示与总结

工程结构图

（此处省略图片，实际项目中应包含清晰的目录结构截图）

核心 API 列表

核心代码的实现

密码工具类实现的代码：

package com.feisuanyz.util;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

/**
 * <p>
 * 密码工具类，提供密码加密和校验功能
 * </p>
 * @author user
 */
@Slf4j
public class PasswordUtil {
    private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();

    /**
     * 对原始密码进行加密处理
     *
     * @param rawPassword 原始密码
     * @return 加密后的密码字符串
     */
    public static String hashPassword(String rawPassword) {
        log.debug("正在对密码进行加密处理...");
        return encoder.encode(rawPassword);
    }

    /**
     * 验证输入密码是否匹配已加密的密码
     *
     * @param rawPassword 输入的原始密码
     * @param encodedPassword 已加密的密码
     * @return boolean 是否匹配
     */
    public static boolean verifyPassword(String rawPassword, String encodedPassword) {
        log.debug("正在进行密码验证...");
        return encoder.matches(rawPassword, encodedPassword);
    }
}

图书库存服务实现类

package com.feisuanyz.service.impl;
import com.feisuanyz.dto.AddBookInventoryDTO;
import com.feisuanyz.dto.QueryBookInventoryDTO;
import com.feisuanyz.dto.UpdateBookInventoryDTO;
import com.feisuanyz.entity.BookInventory;
import com.feisuanyz.exception.BusinessException;
import com.feisuanyz.repository.BookInventoryRepository;
import com.feisuanyz.service.BookInventoryService;
import com.feisuanyz.util.RestResult;
import com.feisuanyz.vo.BookInventoryVO;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
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;

/**
 * <p>
 * 图书库存服务实现类
 * </p>
 * @author user
 */
@Slf4j
@Service
@Transactional
public class BookInventoryServiceImpl implements BookInventoryService {
    @Autowired
    private BookInventoryRepository repository;

    /**
     * 新增图书库存
     *
     * @param dto 入参对象
     * @return RestResult 结果集
     */
    @Override
    public RestResult<?> addBookInventory(AddBookInventoryDTO dto) {
        log.info("新增图书库存请求参数：{}", dto);
        // 检查是否已存在该图书的库存记录
        Optional<BookInventory> existingRecord = repository.findByBookId(dto.getBookId());
        if (existingRecord.isPresent()) {
            return RestResult.fail("000001", "该图书库存记录已存在");
        }
        try {
            BookInventory entity = new BookInventory();
            BeanUtils.copyProperties(dto, entity);
            entity.setCreateTime(LocalDateTime.now());
            entity.setUpdateTime(LocalDateTime.now());
            repository.save(entity);
            log.info("成功新增图书库存记录，ID={}", entity.getInventoryId());
            return RestResult.success(entity);
        } catch (Exception e) {
            log.error("新增图书库存失败", e);
            throw new BusinessException("新增图书库存失败", e);
        }
    }

    /**
     * 修改图书库存
     *
     * @param dto 入参对象
     * @return RestResult 结果集
     */
    @Override
    public RestResult<?> updateBookInventory(UpdateBookInventoryDTO dto) {
        log.info("修改图书库存请求参数：{}", dto);
        // 根据库存记录 ID 查询是否存在该库存记录
        Optional<BookInventory> optionalEntity = repository.findById(dto.getInventoryId());
        if (!optionalEntity.isPresent()) {
            return RestResult.fail("000001", "库存记录不存在");
        }
        try {
            BookInventory entity = optionalEntity.get();
            // 如果传入了字段，则更新对应字段
            if (dto.getTotalQuantity() != null) {
                entity.setTotalQuantity(dto.getTotalQuantity());
            }
            if (dto.getAvailableQuantity() != null) {
                entity.setAvailableQuantity(dto.getAvailableQuantity());
            }
            if (dto.getBorrowedQuantity() != null) {
                entity.setBorrowedQuantity(dto.getBorrowedQuantity());
            }
            if (dto.getWarningThreshold() != null) {
                entity.setWarningThreshold(dto.getWarningThreshold());
            }
            entity.setUpdateTime(LocalDateTime.now());
            repository.save(entity);
            log.info("成功修改图书库存记录，ID={}", entity.getInventoryId());
            return RestResult.success(entity);
        } catch (Exception e) {
            log.error("修改图书库存失败", e);
            throw new BusinessException("修改图书库存失败", e);
        }
    }

    /**
     * 删除图书库存
     *
     * @param inventoryId 库存记录 ID
     * @return RestResult 结果集
     */
    @Override
    public RestResult<?> deleteBookInventory(Long inventoryId) {
        log.info("删除图书库存请求参数：inventoryId={}", inventoryId);
        // 根据库存记录 ID 查询是否存在该库存记录
        Optional<BookInventory> optionalEntity = repository.findById(inventoryId);
        if (!optionalEntity.isPresent()) {
            return RestResult.fail("000001", "库存记录不存在");
        }
        try {
            repository.deleteById(inventoryId);
            log.info("成功删除图书库存记录，ID={}", inventoryId);
            return RestResult.success();
        } catch (Exception e) {
            log.error("删除图书库存失败", e);
            throw new BusinessException("删除图书库存失败", e);
        }
    }

    /**
     * 查询图书库存详情
     *
     * @param dto 入参对象
     * @return RestResult 结果集
     */
    @Override
    public RestResult<?> queryBookInventoryDetail(QueryBookInventoryDTO dto) {
        log.info("查询图书库存详情请求参数：{}", dto);
        // 根据图书 ID 查询对应的库存记录
        Optional<BookInventory> optionalEntity = repository.findByBookId(dto.getBookId());
        if (!optionalEntity.isPresent()) {
            return RestResult.fail("000001", "未找到该图书的库存信息");
        }
        try {
            BookInventory entity = optionalEntity.get();
            BookInventoryVO vo = new BookInventoryVO();
            BeanUtils.copyProperties(entity, vo);
            log.info("成功查询图书库存详情，ID={}", entity.getInventoryId());
            return RestResult.success(vo);
        } catch (Exception e) {
            log.error("查询图书库存详情失败", e);
            throw new BusinessException("查询图书库存详情失败", e);
        }
    }

    /**
     * 获取所有图书库存列表
     *
     * @return RestResult 结果集
     */
    @Override
    public RestResult<List<BookInventoryVO>> getAllBookInventoryList() {
        log.info("获取所有图书库存列表");
        try {
            List<BookInventory> entities = repository.findAll();
            List<BookInventoryVO> vos = new ArrayList<>();
            for (BookInventory entity : entities) {
                BookInventoryVO vo = new BookInventoryVO();
                BeanUtils.copyProperties(entity, vo);
                vos.add(vo);
            }
            log.info("成功获取所有图书库存列表，共{}条记录", vos.size());
            return RestResult.success(vos);
        } catch (Exception e) {
            log.error("获取所有图书库存列表失败", e);
            throw new BusinessException("获取所有图书库存列表失败", e);
        }
    }
}

图书浏览服务实现类

package com.feisuanyz.service.impl;
import com.feisuanyz.dto.RecommendBookDTO;
import com.feisuanyz.dto.SearchBookDTO;
import com.feisuanyz.entity.BookCategory;
import com.feisuanyz.entity.BookInfo;
import com.feisuanyz.entity.BookTag;
import com.feisuanyz.exception.BusinessException;
import com.feisuanyz.repository.BookCategoryRepository;
import com.feisuanyz.repository.BookInfoRepository;
import com.feisuanyz.repository.BookTagRepository;
import com.feisuanyz.service.BookBrowseService;
import com.feisuanyz.util.RestResult;
import com.feisuanyz.vo.BookDetailVO;
import com.feisuanyz.vo.BookListVO;
import com.feisuanyz.vo.CategoryListVO;
import com.feisuanyz.vo.TagListVO;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

/**
 * <p>
 * 图书浏览服务实现类
 * </p>
 * @author user
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class BookBrowseServiceImpl implements BookBrowseService {
    private final BookInfoRepository bookInfoRepository;
    private final BookCategoryRepository bookCategoryRepository;
    private final BookTagRepository bookTagRepository;

    @Override
    public RestResult<List<BookListVO>> searchBooks(SearchBookDTO searchBookDTO) {
        log.info("开始执行图书搜索操作，参数为：{}", searchBookDTO);
        try {
            // 构建分页对象
            Pageable pageable = PageRequest.of(0, 100); // 假设最多返回 100 条
            // 调用 repository 进行查询
            List<BookInfo> books = bookInfoRepository.searchBooks(
                    searchBookDTO.getTitle(), 
                    searchBookDTO.getAuthor(), 
                    searchBookDTO.getCategoryId(), 
                    pageable
            );
            if (books == null || books.isEmpty()) {
                return RestResult.fail("无匹配结果");
            }
            // 转换为视图对象
            List<BookListVO> result = new ArrayList<>();
            for (BookInfo book : books) {
                BookListVO vo = new BookListVO();
                BeanUtils.copyProperties(book, vo);
                // 如果需要填充分类名称等额外字段，请在此处处理
                result.add(vo);
            }
            return RestResult.success(result);
        } catch (Exception e) {
            log.error("图书搜索异常", e);
            throw new BusinessException("系统内部错误");
        }
    }

    @Override
    public RestResult<BookDetailVO> getBookDetails(Long bookId) {
        log.info("开始获取图书详情，图书 ID 为：{}", bookId);
        Optional<BookInfo> optionalBook = bookInfoRepository.findById(bookId);
        if (!optionalBook.isPresent()) {
            return RestResult.fail("图书不存在");
        }
        BookInfo book = optionalBook.get();
        BookDetailVO detailVo = new BookDetailVO();
        BeanUtils.copyProperties(book, detailVo);
        // 可以在这里补充更多细节，比如分类和标签信息
        return RestResult.success(detailVo);
    }

    @Override
    public RestResult<List<CategoryListVO>> getCategoryList() {
        log.info("开始获取图书分类列表");
        try {
            List<BookCategory> categories = bookCategoryRepository.findAll();
            List<CategoryListVO> result = new ArrayList<>();
            for (BookCategory category : categories) {
                CategoryListVO vo = new CategoryListVO();
                BeanUtils.copyProperties(category, vo);
                result.add(vo);
            }
            return RestResult.success(result);
        } catch (Exception e) {
            log.error("获取分类列表失败", e);
            throw new BusinessException("系统内部错误");
        }
    }

    @Override
    public RestResult<List<TagListVO>> getTagList() {
        log.info("开始获取图书标签列表");
        try {
            List<BookTag> tags = bookTagRepository.findAll();
            List<TagListVO> result = new ArrayList<>();
            for (BookTag tag : tags) {
                TagListVO vo = new TagListVO();
                BeanUtils.copyProperties(tag, vo);
                result.add(vo);
            }
            return RestResult.success(result);
        } catch (Exception e) {
            log.error("获取标签列表失败", e);
            throw new BusinessException("系统内部错误");
        }
    }

    @Override
    public RestResult<List<BookListVO>> getRecommendedBooks(RecommendBookDTO recommendBookDTO) {
        log.info("开始获取推荐图书列表，用户 ID 为：{}", recommendBookDTO.getUserId());
        // 这里简单地返回所有图书作为示例推荐策略
        // 实际应用中可以根据用户的借阅历史、偏好等来实现更复杂的算法
        try {
            Pageable pageable = PageRequest.of(0, 20); // 最多返回 20 本书
            List<BookInfo> books = bookInfoRepository.findAll(pageable);
            List<BookListVO> result = new ArrayList<>();
            for (BookInfo book : books) {
                BookListVO vo = new BookListVO();
                BeanUtils.copyProperties(book, vo);
                result.add(vo);
            }
            return RestResult.success(result);
        } catch (Exception e) {
            log.error("获取推荐图书列表失败", e);
            throw new BusinessException("系统内部错误");
        }
    }
}

工具使用体验与效率评估

1. 开发效率提升：核心业务代码开发时间明显缩短，特别在事务控制、并发处理等复杂逻辑实现上表现突出
2. 质量保障体系：自动生成的代码通过静态检查，缺陷密度降低
3. 知识沉淀机制：平台内置的最佳实践模板，有效避免常见设计缺陷

当然，专业开发人员在实际操作中仍需结合具体业务场景进行二次确认与调整。

待改进方向

1. 复杂业务理解：在处理'书店借书图书馆买单'等创新业务模式时，需人工补充业务规则说明
2. 多技术栈支持：当前对非 Java 技术栈（如 Go、Python）的集成支持有限
3. UI/UX 设计：前端界面生成功能尚在完善阶段，需结合专业设计工具使用
4. 上下文逻辑分层：在复制粘贴智能会话生成的内容时，需注意格式保持与逻辑分层

开发体会

通过本次实践深刻认识到，AI 开发工具已从'代码生成器'进化为'业务理解伙伴'。在实现图书预约排队机制时，AI 不仅生成了基础代码，还主动提示需要考虑'读者优先级策略'和'校区库存均衡'等业务深层次问题。这种从技术实现到业务理解的跨越，标志着开发工具进入智能协同新阶段。建议开发者在使用时保持'人机协作'思维，充分发挥 AI 在重复性工作处理和知识检索方面的优势，同时保留人类在业务创新和复杂决策上的主导地位。