Java AI 开发实战：从代码生成到架构优化指南

Service 层实现：

@Service
public class CategoryServiceImpl implements CategoryService {
    @Autowired
    private CategoryMapper categoryMapper;

    @Override
    public Category getCategoryById(Long id) {
        return categoryMapper.selectByPrimaryKey(id);
    }

    @Override
    public List<Category> getAllCategories() {
        return categoryMapper.selectAll();
    }

    @Override
    @Transactional // 自动添加事务注解
    public boolean addCategory(Category category) {
        // 自动填充时间戳
        category.setCreateTime(new Date());
        category.setUpdateTime(new Date());
        return categoryMapper.insert(category) > 0;
    }

    // 其他方法实现省略
}

控制器层：

@RestController
@RequestMapping("/api/categories")
public class CategoryController {
    @Autowired
    private CategoryService categoryService;

    @GetMapping("/{id}")
    public Result<Category> getCategory(@PathVariable Long id) {
        Category category = categoryService.getCategoryById(id);
        return Result.success(category);
    }

    @GetMapping
    public Result<List<Category>> getAllCategories() {
        List<Category> categories = categoryService.getAllCategories();
        return Result.success(categories);
    }

    @PostMapping
    public Result<Boolean> addCategory(@RequestBody Category category) {
        boolean result = categoryService.addCategory(category);
        return Result.success(result);
    }

    // 其他接口省略
}

开发效率对比：

• 传统开发：完成这套代码需要 2-3 小时（包含测试调整）
• AI 辅助：8 分钟生成可运行代码
• 代码质量：自动遵循阿里巴巴开发规范，包含完整的分层结构和必要注释

1.2 复杂业务逻辑生成，状态机实现示例

对于包含多状态流转的业务场景，AI 同样能轻松应对。以物流订单状态管理为例：

指令输入：

编写订单状态转换服务，要求：
1. 支持待付款、已付款、已发货、已签收、已取消五种状态
2. 定义状态转换规则：
   - 待付款可取消或付款
   - 已付款可发货或取消
   - 已发货可签收
3. 每次状态转换记录操作日志
4. 转换失败时抛出带有明确错误信息的异常

生成核心代码：

首先是状态枚举定义：

public enum OrderStatus {
    待付款(1, "待付款"),
    已付款(2, "已付款"),
    已发货(3, "已发货"),
    已签收(4, "已签收"),
    已取消(5, "已取消");

    private int code;
    private String desc;

    // 构造方法
    OrderStatus(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    // getter 方法
    public int getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }
}

状态转换服务实现：

@Service
public class OrderStatusService {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private OrderLogMapper orderLogMapper;

    // 付款操作实现
    public void payOrder(Long orderId) throws OrderStatusException {
        Order order = orderMapper.selectByPrimaryKey(orderId);
        if (order == null) {
            throw new OrderStatusException("订单不存在，ID：" + orderId);
        }

        // 状态合法性校验
        if (!order.getStatus().equals(OrderStatus.待付款.getCode())) {
            throw new OrderStatusException("订单状态异常，当前状态不支持付款操作");
        }

        // 执行状态转换
        order.setStatus(OrderStatus.已付款.getCode());
        order.setUpdateTime(new Date());
        int result = orderMapper.updateByPrimaryKey(order);
        if (result <= 0) {
            throw new OrderStatusException("付款操作失败，更新订单状态出错");
        }

        // 自动记录操作日志
        recordStatusLog(orderId, OrderStatus.待付款, OrderStatus.已付款, "用户付款");
    }

    // 发货操作实现（类似付款操作）
    public void shipOrder(Long orderId) throws OrderStatusException {
        // 代码省略...
    }

    // 日志记录私有方法
    private void recordStatusLog(Long orderId, OrderStatus fromStatus, OrderStatus toStatus, String operation) {
        OrderLog log = new OrderLog();
        log.setOrderId(orderId);
        log.setFromStatus(fromStatus.getCode());
        log.setToStatus(toStatus.getCode());
        log.setOperation(operation);
        log.setOperateTime(new Date());
        orderLogMapper.insert(log);
    }
}

代码亮点：

• 自动实现状态转换的合法性校验
• 包含完整的异常处理机制
• 采用枚举类管理状态，便于扩展
• 自动记录状态变更日志，满足审计需求

二、框架配置与集成：从 0 到 1 快速搭建

2.1 Spring Boot 项目一键初始化

智能开发工具能够根据业务需求，自动生成完整的项目结构和配置。以博客系统为例：

指令：创建 Spring Boot 博客系统，使用 MySQL 数据库，包含用户、文章、评论模块

生成的项目结构如下：

blog-system/
├── backend/
│   ├── src/
│   │   ├── main/
│   │   │   ├── java/com/blog/
│   │   │   │   ├── config/ # 配置类
│   │   │   │   ├── controller/ # 控制器
│   │   │   │   ├── entity/ # 实体类
│   │   │   │   ├── mapper/ # 数据访问
│   │   │   │   ├── service/ # 服务层
│   │   │   │   └── BlogApplication.java # 启动类
│   │   │   └── resources/
│   │   │       ├── mapper/ # MyBatis XML
│   │   │       └── application.yml # 配置文件
│   │   └── pom.xml # Maven 依赖
├── frontend/ # 前端 Vue 项目
└── doc/ # 文档

核心配置文件（application.yml）：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/blog_db?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  # 其他配置...
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.blog.entity
  configuration:
    map-underscore-to-camel-case: true # 自动驼峰命名转换

2.2 第三方组件集成：以 Redis 缓存为例

在现有项目中集成 Redis 缓存，只需简单指令即可完成：

指令：

在项目中集成 Redis 缓存，要求：
1. 配置 Redis 连接信息（主机 localhost，端口 6379）
2. 实现用户信息的缓存存取逻辑
3. 设置缓存过期时间为 30 分钟
4. 提供缓存命中率统计功能

生成的配置类：

@Configuration
@EnableCaching
public class RedisConfig {
    @Value("${spring.redis.host:localhost}")
    private String host;

    @Value("${spring.redis.port:6379}")
    private int port;

    // Redis 连接工厂配置
    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory() {
        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();
        configuration.setHostName(host);
        configuration.setPort(port);
        return new LettuceConnectionFactory(configuration);
    }

    // RedisTemplate 配置
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(lettuceConnectionFactory());
        // 设置序列化方式
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }

    // 缓存管理器配置
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30)) // 30 分钟过期
                .disableCachingNullValues() // 不缓存 null 值
                .computePrefixWith(cacheName -> cacheName + ":");
        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .transactionAware()
                .build();
    }
}

带缓存的服务实现：

@Service
public class UserServiceCacheImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String USER_CACHE_KEY = "user:id:";

    @Override
    public User getUserById(Long id) {
        // 先查缓存
        String cacheKey = USER_CACHE_KEY + id;
        User user = (User) redisTemplate.opsForValue().get(cacheKey);
        if (user != null) {
            return user; // 缓存命中
        }

        // 缓存未命中，查数据库
        user = userMapper.selectByPrimaryKey(id);
        if (user != null) {
            // 存入缓存，30 分钟过期
            redisTemplate.opsForValue().set(cacheKey, user, 30, TimeUnit.MINUTES);
        }
        return user;
    }

    @Override
    public void updateUser(User user) {
        // 更新数据库
        userMapper.updateByPrimaryKey(user);
        // 清除缓存
        String cacheKey = USER_CACHE_KEY + user.getId();
        redisTemplate.delete(cacheKey);
    }
}

三、老代码优化：从'垃圾山'到'艺术品'

3.1 代码异味修复：长方法拆分示例

面对动辄数百行的长方法，AI 能自动识别并拆分，让逻辑更清晰：

原始长方法：

public void processOrder(Order order) {
    // 1. 校验订单基本信息（100 行）
    // 2. 校验库存（80 行）
    // 3. 计算价格（50 行）
    // 4. 生成支付信息（70 行）
    // 5. 处理优惠券（60 行）
    // 6. 记录订单日志（40 行）
    // 7. 发送通知（50 行）
    // 8. 更新相关状态（50 行）
}

优化建议与代码：

// 拆分后的方法
public void processOrder(Order order) {
    validateOrderInfo(order);      // 订单信息校验
    checkInventory(order);         // 库存校验
    calculateOrderPrice(order);    // 价格计算
    generatePaymentInfo(order);    // 支付信息生成
    processCoupon(order);          // 优惠券处理
    recordOrderLog(order);         // 日志记录
    sendOrderNotifications(order); // 通知发送
    updateRelatedStatus(order);    // 状态更新
}

// 每个步骤单独实现
private void validateOrderInfo(Order order) {
    // 原 100 行校验代码
}

private void checkInventory(Order order) {
    // 原 80 行库存校验代码
}

// 其他方法省略...

3.2 性能优化：SQL 查询优化示例

原始低效查询：

public List<Transaction> getTransactionsByCondition(TransactionQuery query) {
    String sql = "SELECT t.*, u.username FROM transaction t " +
                 "JOIN user u ON t.user_id = u.id " +
                 "WHERE 1=1";
    // 字符串拼接 SQL，存在注入风险且效率低
    if (query.getUserId() != null) {
        sql += " AND t.user_id = " + query.getUserId();
    }
    if (query.getStartDate() != null) {
        sql += " AND t.create_time >= '" + query.getStartDate() + "'";
    }
    // 更多条件拼接...
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Transaction.class));
}

优化后代码：

// MyBatis 接口定义
public interface TransactionMapper {
    List<Transaction> getTransactionsByCondition(TransactionQuery query);
    int getTransactionsCount(TransactionQuery query);
}

// MyBatis XML 实现
<mapper namespace="com.finance.mapper.TransactionMapper">
    <resultMap id="TransactionResultMap" type="Transaction">
        <id column="id" property="id"/>
        <result column="user_id" property="userId"/>
        <result column="amount" property="amount"/>
        <result column="status" property="status"/>
        <result column="create_time" property="createTime"/>
        <association property="user" javaType="User">
            <result column="username" property="username"/>
        </association>
    </resultMap>
    <select id="getTransactionsByCondition" resultMap="TransactionResultMap">
        SELECT t.*, u.username FROM transaction t
        JOIN user u ON t.user_id = u.id
        <where>
            <if test="userId != null"> t.user_id = #{userId}</if>
            <if test="startDate != null"> AND t.create_time >= #{startDate}</if>
            <if test="endDate != null"> AND t.create_time <= #{endDate}</if>
            <if test="status != null"> AND t.status = #{status}</if>
        </where>
        <if test="pageable != null"> LIMIT #{pageable.offset}, #{pageable.pageSize}</if>
    </select>
</mapper>

优化效果：

• 响应时间从 3.2 秒缩短至 0.4 秒
• 消除 SQL 注入风险
• 支持分页查询，避免内存溢出

四、AI 编程助手使用技巧

4.1 高效指令编写规范

1. 明确技术栈：指定框架和版本，如 "使用 Spring Boot 3.2 + MyBatis Plus"
2. 细化业务需求： 不佳："写一个用户登录功能" 推荐："写一个基于 JWT 的用户登录功能，包含 Token 生成、校验和刷新逻辑"
3. 指定代码规范：如 "代码必须符合阿里巴巴 Java 开发规范，包含完整注释"
4. 提供输入输出示例：有助于 AI 更准确理解需求

4.2 IDE 集成最佳实践

• 设置快捷键：将常用功能绑定快捷键，如 Ctrl+Alt+G 触发代码生成
• 上下文调用：选中代码块后调用 AI，实现针对性优化
• 多会话并行：同时打开多个 AI 会话，处理不同模块开发任务

结语

利用 AI 辅助开发并非替代工程师，而是将我们从繁琐的样板代码中解放出来，专注于核心业务逻辑的设计与优化。掌握正确的提示词工程，配合良好的代码审查习惯，能让你的开发流程更加顺畅高效。