从AI编程到业务落地：基于腾讯云AI代码助手与向量数据库的智能开发实践

[产品经理] 输入自然语言需求（TAPD 描述）
    ↓
[后端服务] 调用 AI 代码助手 API（携带向量检索的上下文）
    ↓
[AI 生成] 返回完整的 Controller/Service/DAO 代码 + 单元测试
    ↓
[代码审查] 自动执行静态扫描（Checkstyle/SonarQube）
    ↓
[自动化部署] 通过 TKE 的 Jenkins Pipeline 构建镜像并发布至测试环境
    ↓
[业务验证] 执行集成测试，验证业务逻辑是否符合需求

# 使用腾讯云 VectorDB SDK 构建知识库
import tcvectordb
from tcvectordb.model.document import Document
from tcvectordb.model.collection import Collection

# 1. 初始化向量数据库客户端
client = tcvectordb.RpcClient(
    url='http://vectordb.xxx.tencentcloudapi.com',
    username='root',
    key='your-api-key'
)

# 2. 创建 Collection（如果不存在）
collection: Collection = client.create_collection(
    database_name='ai_coding_kb',
    collection_name='business_docs',
    shard=1,
    replicas=1,
    description='企业业务知识库',
    embedding_model='text-embedding-ada-002'  # 使用内置 Embedding 模型
)

# 3. 将业务文档切分成 Chunk 并插入
def build_knowledge_base(docs_dir):
    chunks = []
    for file in os.listdir(docs_dir):
        content = read_file(file)
        # 按 Markdown 标题或代码块分割
        chunks.extend(split_by_semantic(content, max_length=500))
    
    documents = []
    for idx, chunk in enumerate(chunks):
        documents.append(
            Document(
                id=f"doc_{idx}",
                content=chunk,
                # 自定义元数据，用于过滤
                metadata={
                    "source": file,
                    "type": "api_doc" if "api" in file else "business_rule"
                }
            )
        )
    
    # 批量插入（自动调用 Embedding 模型生成向量）
    collection.upsert(documents)
    print(f"成功插入 {len(documents)} 个文档片段")

def retrieve_context(query, top_k=5, filter_type=None):
    # 将查询文本向量化并检索
    results = collection.search(
        content=query,
        limit=top_k,
        # 可选过滤条件
        filter=f"type='api_doc' AND module='order'" if filter_type else None
    )
    
    # 返回最相关的文档片段
    contexts = []
    for doc in results:
        contexts.append({
            "content": doc.content,
            "score": doc.score,
            "source": doc.metadata.get("source")
        })
    return contexts

# 示例调用
context = retrieve_context(
    "订单取消接口需要校验状态并释放库存", 
    top_k=3
)

# 构造发给 AI 代码助手的 Prompt
prompt = f"""
请根据以下业务规则和 API 规范，生成 Spring Boot 的订单取消接口代码。

业务规则：
1. 只有状态为 'PENDING'（待支付）的订单才能取消
2. 取消时需要调用 inventory-service 释放已锁定的库存
3. 取消后发送订单取消事件到 Kafka

参考 API 规范：
{context[0]['content']}

已有 Controller 风格参考：
{context[1]['content']}

生成要求：
- 使用 Lombok
- 参数校验使用 JSR-303
- 返回格式统一为 Result<T>
"""

// Java 实现调用 AI 代码助手
@Service
public class AICodeGenerator {
    
    @Value("${tencent.ai.code-assistant.url}")
    private String apiUrl;
    
    @Value("${tencent.ai.code-assistant.api-key}")
    private String apiKey;
    
    public GeneratedCode generateCode(String prompt) {
        HttpHeaders headers = new HttpHeaders();
        headers.set("Content-Type", "application/json");
        headers.set("Authorization", "Bearer " + apiKey);
        
        Map<String, Object> request = new HashMap<>();
        request.put("model", "code-assistant-v2");
        request.put("prompt", prompt);
        request.put("language", "java");
        request.put("framework", "spring-boot");
        request.put("temperature", 0.3);  // 低温度确保输出稳定
        request.put("max_tokens", 2048);
        
        ResponseEntity<CodeResponse> response = restTemplate.postForEntity(
            apiUrl, 
            new HttpEntity<>(request, headers), 
            CodeResponse.class
        );
        
        return response.getBody().getGeneratedCode();
    }
}

@RestController
@RequestMapping("/api/order")
@Slf4j
@RequiredArgsConstructor
public class OrderController {
    
    private final OrderService orderService;
    
    @PostMapping("/cancel")
    public Result<Void> cancelOrder(@RequestBody @Valid CancelOrderRequest request) {
        // 1. 参数校验（由 JSR-303 自动处理）
        // 2. 调用业务服务
        orderService.cancelOrder(request.getOrderId(), request.getReason());
        // 3. 返回统一结果
        return Result.success();
    }
}

@Service
@Slf4j
@RequiredArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class OrderService {
    
    private final OrderRepository orderRepository;
    private final InventoryClient inventoryClient;
    private final KafkaTemplate<String, Object> kafkaTemplate;
    
    public void cancelOrder(Long orderId, String reason) {
        // 1. 查询订单
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new BusinessException("订单不存在"));
        
        // 2. 业务规则校验（由 AI 从文档中学习）
        if (order.getStatus() != OrderStatus.PENDING) {
            throw new BusinessException("只有待支付订单才能取消");
        }
        if (order.getLockedInventory() <= 0) {
            throw new BusinessException("订单未锁定库存，无需取消");
        }
        
        // 3. 调用库存服务释放库存（Feign 客户端）
        Result<Void> result = inventoryClient.unfreeze(orderId);
        if (!result.isSuccess()) {
            throw new BusinessException("库存释放失败: " + result.getMessage());
        }
        
        // 4. 更新订单状态
        order.setStatus(OrderStatus.CANCELLED);
        order.setCancelReason(reason);
        order.setCancelTime(LocalDateTime.now());
        orderRepository.save(order);
        
        // 5. 发送取消事件
        OrderCancelEvent event = new OrderCancelEvent(orderId, reason);
        kafkaTemplate.send("order-cancel-topic", event);
        
        log.info("订单取消成功, orderId: {}, reason: {}", orderId, reason);
    }
}

@SpringBootTest
@AutoConfigureMockMvc
class OrderControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private OrderService orderService;
    
    @Test
    @DisplayName("取消订单 - 正常场景")
    void shouldCancelOrderSuccessfully() throws Exception {
        // Given
        CancelOrderRequest request = new CancelOrderRequest();
        request.setOrderId(100L);
        request.setReason("用户主动取消");
        
        doNothing().when(orderService).cancelOrder(100L, "用户主动取消");
        
        // When & Then
        mockMvc.perform(post("/api/order/cancel")
                .contentType(MediaType.APPLICATION_JSON)
                .content(new ObjectMapper().writeValueAsString(request)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(0))
                .andExpect(jsonPath("$.data").value(null));
    }
    
    @Test
    @DisplayName("取消订单 - 状态非法")
    void shouldFailWhenOrderStatusInvalid() throws Exception {
        // Given
        CancelOrderRequest request = new CancelOrderRequest();
        request.setOrderId(200L);
        
        doThrow(new BusinessException("只有待支付订单才能取消"))
            .when(orderService).cancelOrder(200L, null);
        
        // When & Then
        mockMvc.perform(post("/api/order/cancel")
                .contentType(MediaType.APPLICATION_JSON)
                .content(new ObjectMapper().writeValueAsString(request)))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(500))
                .andExpect(jsonPath("$.message").value("只有待支付订单才能取消"));
    }
}

# GitLab API 创建 MR
def create_mr_with_ai_code(branch_name, code_content):
    api_url = "https://git.woa.com/api/v4/projects/{}/merge_requests".format(project_id)
    headers = {"PRIVATE-TOKEN": git_token}
    
    # 先创建分支并提交代码
    commit_file(project_id, branch_name, "OrderController.java", code_content)
    
    # 创建 MR
    payload = {
        "source_branch": branch_name,
        "target_branch": "main",
        "title": "[AI 生成] 订单取消接口",
        "description": "本次代码由 AI 代码助手自动生成，请 Review 业务逻辑是否符合需求",
        "assignee_ids": [reviewer_id]
    }
    response = requests.post(api_url, headers=headers, json=payload)
    return response.json()

// Jenkinsfile (声明式流水线)
pipeline {
    agent any
    environment {
        DOCKER_REGISTRY = 'ccr.ccs.tencentyun.com'
        TKE_CLUSTER = 'cls-xxxxx'
    }
    stages {
        stage('Compile & Test') {
            steps {
                sh 'mvn clean compile test'
                junit 'target/surefire-reports/*.xml'
            }
        }
        stage('Build Image') {
            steps {
                sh 'docker build -t ${DOCKER_REGISTRY}/order-service:${BUILD_NUMBER} .'
                sh 'docker push ${DOCKER_REGISTRY}/order-service:${BUILD_NUMBER}'
            }
        }
        stage('Deploy to TKE') {
            steps {
                sh """
                kubectl set image deployment/order-service \
                    order-service=${DOCKER_REGISTRY}/order-service:${BUILD_NUMBER} \
                    --kubeconfig /path/to/kubeconfig
                kubectl rollout status deployment/order-service \
                    --kubeconfig /path/to/kubeconfig
                """
            }
        }
        stage('Smoke Test') {
            steps {
                sh 'mvn test -Psmoke-test'
            }
        }
    }
}