Como Usar o GitHub Copilot para Gerar Controladores REST no Spring Boot

Você quer gerar um controlador REST do Spring Boot rapidamente usando o GitHub Copilot. Escrever endpoints CRUD, mapeamentos de requisição e entidades de resposta manualmente é repetitivo e propenso a erros. O Copilot pode autocompletar classes de controlador inteiras com base no seu modelo e nas camadas de serviço. Este artigo explica como configurar o Copilot na sua IDE, escrever prompts eficazes e gerar controladores REST completos para projetos Spring Boot.

Como o GitHub Copilot Gera Controladores REST Spring Boot

O GitHub Copilot é um programador par de IA que sugere código enquanto você digita. Ele entende convenções do Spring Boot como @RestController, @RequestMapping, @GetMapping e @PostMapping. Quando você fornece uma classe de modelo como Product e uma classe de serviço como ProductService, o Copilot pode gerar os métodos do controlador que mapeiam requisições HTTP para chamadas de serviço. A qualidade do código gerado depende do contexto que você fornece. Escrever um comentário de classe descritivo ou uma assinatura de método é a maneira mais confiável de obter uma sugestão útil.

Pré-requisitos

Você precisa destes itens antes de usar o Copilot para geração de controladores:

• Visual Studio Code, IntelliJ IDEA ou outra IDE compatível com a extensão GitHub Copilot instalada e ativada
• Um projeto Spring Boot com arquivos de build Maven ou Gradle que incluam a dependência spring-boot-starter-web
• Uma classe de modelo (entidade) e uma classe de serviço já escritas no projeto
• Uma assinatura ativa do GitHub Copilot (plano individual, empresarial ou corporativo)

Passos para Gerar um Controlador REST Spring Boot com Copilot

1. Abra o pacote do controlador e crie uma nova classe Java
   Na sua IDE, navegue até o pacote do controlador em src/main/java. Clique com o botão direito no pacote e selecione New > Java Class. Nomeie-a de acordo com sua entidade, por exemplo ProductController. Pressione Enter para criar o arquivo vazio.
2. Escreva um comentário de classe que descreva a finalidade do controlador
   No topo do arquivo, digite um comentário como // Controlador REST para a entidade Product com endpoints CRUD. Esse comentário dá ao Copilot uma intenção clara. Após digitar o comentário, pressione Enter para ir para a próxima linha.
3. Adicione a anotação @RestController manualmente
   Digite @RestController na linha após o comentário. Em seguida, digite @RequestMapping("/api/products") na próxima linha. Essas anotações informam ao Copilot que você está construindo um controlador REST e fornecem o caminho base da URL.
4. Declare a classe e injete a dependência do serviço
   Digite public class ProductController { e pressione Enter. Na próxima linha, digite private final ProductService productService;. Em seguida, digite um construtor que receba ProductService como parâmetro. O Copilot pode sugerir o construtor automaticamente. Pressione Tab para aceitá-lo.
5. Gere o primeiro endpoint GET digitando a assinatura do método
   Digite public ResponseEntity> getAllProducts() e pressione Enter. O Copilot sugerirá o corpo do método, incluindo @GetMapping, a chamada para productService.findAll() e a instrução de retorno. Pressione Tab para aceitar a sugestão.
6. Gere o endpoint GET por ID
   Na próxima linha, digite public ResponseEntity getProductById(@PathVariable Long id). O Copilot sugerirá o método com @GetMapping("/{id}") e a chamada ao serviço. Aceite com Tab.
7. Gere o endpoint POST para criar um recurso
   Digite public ResponseEntity createProduct(@RequestBody Product product). O Copilot sugerirá @PostMapping e a chamada ao serviço para salvar. Aceite a sugestão.
8. Gere o endpoint PUT para atualizar um recurso
   Digite public ResponseEntity updateProduct(@PathVariable Long id, @RequestBody Product product). O Copilot sugerirá @PutMapping("/{id}") e a lógica de atualização. Aceite.
9. Gere o endpoint DELETE
   Digite public ResponseEntity deleteProduct(@PathVariable Long id). O Copilot sugerirá @DeleteMapping("/{id}") e a chamada ao serviço para exclusão. Aceite a sugestão.
10. Revise e edite o código gerado
    Verifique cada método para códigos de status HTTP corretos. O Copilot pode usar ResponseEntity.ok() por padrão. Altere para ResponseEntity.status(HttpStatus.CREATED) para POST ou ResponseEntity.noContent().build() para DELETE, se necessário. Adicione anotações @Valid nos parâmetros @RequestBody para validação.

Erros Comuns e Limitações ao Usar Copilot para Controladores

O Copilot gera código que não compila devido a imports ausentes

O Copilot frequentemente omite instruções de import para ResponseEntity, List ou PathVariable. Após aceitar uma sugestão, use o recurso de correção rápida da IDE. No VS Code, passe o mouse sobre o sublinhado vermelho e pressione Ctrl+. para adicionar o import ausente. No IntelliJ, pressione Alt+Enter no erro.

O Copilot sugere métodos que chamam métodos de serviço inexistentes

Se sua classe de serviço não tiver um método chamado findAll() ou save(), o controlador gerado não compilará. Antes de gerar o controlador, certifique-se de que sua classe de serviço contenha os métodos esperados. Alternativamente, você pode aceitar a sugestão e depois implementar os métodos de serviço ausentes.

O Copilot repete o mesmo padrão de endpoint para cada entidade

Ao gerar controladores para múltiplas entidades, o Copilot pode produzir estruturas de método idênticas. Isso é aceitável para CRUD padrão, mas pode levar a código duplicado. Para evitar isso, considere criar uma classe de controlador base genérica e estendê-la para cada entidade. O Copilot pode ajudar a gerar a classe base se você escrever um comentário como // Controlador CRUD genérico com métodos comuns.

O Copilot não gera endpoints de consulta personalizados automaticamente

O Copilot funciona melhor com padrões CRUD padrão. Se você precisar de um endpoint personalizado como /api/products/search?name=, deve escrever a assinatura do método manualmente. Por exemplo, digite public ResponseEntity> searchProducts(@RequestParam String name). O Copilot então sugerirá a implementação com base no nome do parâmetro e no tipo de retorno.

Sugestões do GitHub Copilot vs Codificação Manual para Controladores Spring Boot

Item	Gerado pelo Copilot	Escrito Manualmente
Tempo de configuração	Menos de 2 minutos para um controlador completo com 5 endpoints	5-10 minutos para o mesmo controlador
Precisão das anotações	Correta para CRUD padrão; pode omitir @Valid ou @ResponseStatus	Controle total sobre cada anotação
Tratamento de erros	Apenas ResponseEntity.ok() básico	Pode incluir manipuladores de exceção personalizados e códigos de status
Consistência entre controladores	Pode variar se o contexto for diferente	Estrutura uniforme ao usar um modelo
Curva de aprendizado	Baixa; requer apenas digitar assinaturas de método	Requer conhecimento de anotações e padrões do Spring Boot

O Copilot é melhor para gerar a estrutura inicial de um controlador REST. Você ainda precisa revisar e personalizar a saída para uso em produção. Combine o Copilot com edições manuais para tratamento de erros, validação e logging.

Usando o Copilot para Gerar Camadas de Serviço e Repositório

O Copilot também pode gerar camadas de serviço e repositório, o que melhora a precisão das sugestões do controlador. Para gerar uma classe de serviço, crie um novo arquivo Java chamado ProductService. Escreva um comentário como // Camada de serviço para a entidade Product com operações CRUD. Em seguida, digite public class ProductService {. O Copilot sugerirá métodos que chamam um repositório. Para o repositório, crie uma interface chamada ProductRepository que estenda JpaRepository. O Copilot sugerirá a declaração da interface e métodos de consulta comuns. Após essas camadas existirem, a geração do controlador se torna mais confiável porque o Copilot usa as assinaturas reais dos métodos do seu serviço.

Se o Copilot Parar de Sugerir Código Durante a Geração do Controlador

Às vezes, o Copilot para de mostrar sugestões. Isso pode acontecer quando o contexto do arquivo é muito curto ou o comentário é vago. Para reiniciar as sugestões, apague a última linha e digite-a novamente. Alternativamente, feche o arquivo e reabra-o. Se o problema persistir, verifique se a extensão GitHub Copilot está ativada e se você está conectado com sua conta do GitHub. No VS Code, olhe na barra de status inferior para o ícone do Copilot. Se mostrar um círculo riscado, clique nele e selecione Sign In.

Agora você pode gerar um controlador REST Spring Boot completo com endpoints CRUD usando o GitHub Copilot. Comece escrevendo um comentário de classe claro e assinaturas de método para cada endpoint. Após aceitar as sugestões, adicione imports ausentes e personalize o tratamento de erros. Para projetos mais complexos, gere primeiro as camadas de serviço e repositório para melhorar a qualidade das sugestões do controlador. Tente usar o Copilot para gerar um método de conversão DTO dentro do controlador digitando private ProductDTO convertToDTO(Product product) e pressionando Enter.