2. Controllers, actions, roteamento
Este capítulo examina o caminho que uma requisição percorre, do navegador até a action que a processa, e a resposta que essa action devolve. As views só serão abordadas no Capítulo 4: aqui, as actions devolvem texto ou JSON diretamente.
2.1. Exemplo 01: A estrutura de uma aplicação Spring MVC
O primeiro exemplo é a menor aplicação [Spring MVC] possível. Além dos arquivos [pom.xml] e [application.properties] apresentados na introdução, ela tem dois arquivos:
2.1.1. O ponto de entrada: Example01Application.java
Vamos percorrer este código:
- linha 1: o pacote da classe. Ele deve corresponder ao diretório do arquivo ([src/main/java/example01]);
- linhas 3–4: classes de outros pacotes usadas por este arquivo. Ao contrário do [C#], o [Java] não tem imports implícitos (exceto o pacote [java.lang], que contém [String], [Integer]...): cada arquivo importa explicitamente as classes que usa;
- linha 9: [@SpringBootApplication] é uma anotação. Uma anotação [Java] é escrita como [@Name], imediatamente antes do elemento que ela descreve (uma classe, um método, um parâmetro...): ela acrescenta informações que o framework lê na inicialização. Isso equivale aos atributos [[...]] do [C#]. [@SpringBootApplication] marca a classe de inicialização da aplicação e combina três anotações: [@Configuration] (a classe pode declarar objetos gerenciados pelo [Spring]; veja o Exemplo 06), [@EnableAutoConfiguration] (autoconfiguração: o [Spring Boot] configura automaticamente tudo o que as bibliotecas disponíveis permitem, neste caso [Spring MVC], [Tomcat] e [Jackson]) e [@ComponentScan] (varredura de componentes: o [Spring] procura classes anotadas com [@Controller], [@Service]... no pacote dessa classe, [example01], e em todos os seus subpacotes, como [example01.controllers]);
- linha 13: o método [main], o ponto de entrada de qualquer programa [Java]. Ele é [public] (visível de qualquer lugar) e [static] (pertence à classe, e não a um objeto da classe). O parâmetro [args] contém os argumentos da linha de comando;
- linha 16: [SpringApplication.run] inicia o [Spring]: lê a configuração (o arquivo [application.properties], as variáveis de ambiente, os argumentos da linha de comando...), cria os objetos da aplicação e então inicia o servidor web [Tomcat], que aguarda requisições até que a aplicação seja interrompida ([Ctrl-C]). [Example01Application.class] refere-se à própria classe: o [Spring] lê dela a anotação [@SpringBootApplication] e deduz o pacote a ser varrido.
Não há mais nada a escrever: nenhuma lista de controllers, nenhuma declaração de rotas. A varredura de componentes encontra os controllers, e a autoconfiguração cuida de todo o resto.
2.1.2. O controller: controllers/HomeController.java
- linha 1: a classe está no pacote [example01.controllers], um subpacote de [example01]: a varredura de componentes a encontra;
- linha 8: a anotação [@Controller] designa a classe como um controller do [Spring MVC]. A classe não precisa herdar de uma classe do framework (isso difere do [ASP.NET Core MVC]); por convenção, seu nome termina com [Controller]. O [Spring] cria o próprio objeto controller na inicialização;
- linha 12: a anotação [@GetMapping("/")] associa o método [index] às requisições do tipo [GET /]. Um método associado dessa forma a uma rota é uma action;
- linha 14: a anotação [@ResponseBody] especifica que o valor devolvido pela action é o corpo da resposta enviada ao navegador. Sem ela, o [Spring MVC] trataria a string devolvida como o nome de uma view a ser exibida (veremos isso no Exemplo 04 e depois no Capítulo 4);
- linhas 15–16: a action devolve uma string. Por convenção, os nomes dos métodos [Java] começam com letra minúscula.
2.1.3. Execução
Em uma janela de terminal aberta na pasta [01-structure], digite [../mvnw spring-boot:run] ([..\mvnw spring-boot:run] no [Windows]). Após a compilação, o [Spring Boot] exibe seu banner, seguido de suas mensagens de inicialização (substituímos a data, a hora, o número do processo e o nome da thread por [...] e abreviamos os caminhos):
As mensagens de inicialização indicam a versão do [Java], a porta de escuta (5000, definida em [application.properties]) e a versão do servidor [Tomcat] embutido na aplicação. Elas também indicam o perfil ativo: [default]. Um perfil é um conjunto de configurações (desenvolvimento, produção etc.); o estudo de caso usará um. Vamos requisitar a URL [http://localhost:5000/] com um navegador:
![]()
e depois com o [curl]. A opção [-i] também exibe os cabeçalhos HTTP da resposta (incluiremos aqui apenas alguns):
A primeira linha da resposta é o código de status, 200, sem o texto habitual [OK]: o [Tomcat] não o envia, porque o protocolo HTTP não o exige. O navegador e o [curl] aceitam apenas o código.
O [curl] recebeu a string com o cabeçalho [Content-Type: text/plain]: texto simples. No entanto, o navegador a exibiu como HTML (como se vê pela fonte, que é a mesma das páginas HTML). Isso acontece porque, para uma string devolvida por uma action sem outras especificações, o [Spring MVC] escolhe o tipo da resposta com base no cabeçalho [Accept] da requisição, pelo qual o cliente especifica os tipos que aceita: é a negociação de conteúdo. O [curl] envia [Accept: */*] (todos os tipos) e recebe [text/plain]; um navegador envia [Accept: text/html,...] e recebe [text/html]. Vamos verificar isso enviando um cabeçalho de navegador (opção [-H]) com o [curl]:
Isso difere do [ASP.NET Core MVC], que sempre enviava uma string como texto simples. O Exemplo 02 mostrará como especificar o tipo da resposta.
Na primeira requisição, o console exibe mais três linhas:
O [DispatcherServlet] é o ponto de entrada do [Spring MVC] (veja o diagrama na introdução): o [Tomcat] encaminha todas as requisições para ele, e é ele que seleciona a action atribuída a cada uma. O [Tomcat] só o prepara quando a primeira requisição é recebida.
2.2. Exemplo 02: Roteamento
O roteamento associa uma URL e um método HTTP (GET, POST...) a uma action. O Exemplo 02 tem dois controllers:
A classe [Example02Application] é idêntica, exceto pelo nome, à do Exemplo 01: isso vale para todos os exemplos. O arquivo [controllers/HomeController.java]:
- linha 8: [@RestController] combina [@Controller] e [@ResponseBody]: todas as actions da classe devolvem diretamente o corpo da resposta. Esta é a forma mais comum para um controller que não gera views; vamos usá-la até o Capítulo 4;
- linha 13: uma anotação pode ter vários atributos, escritos como [name = value]. [value] é o caminho da rota (quando está sozinho, [value =] pode ser omitido, como no Exemplo 01); [produces] especifica o tipo da resposta (o cabeçalho [Content-Type]), aqui [text/html], independentemente do cabeçalho [Accept] da requisição. [MediaType.TEXT_HTML_VALUE] é uma constante igual a ["text/html"]: um erro de digitação em seu nome causaria um erro de compilação, o que não acontece com uma string escrita à mão;
- linhas 15–26: um bloco de texto ([text block], [Java] 15), delimitado por três aspas. Ele pode ocupar várias linhas e conter aspas sem escapá-las. A indentação comum a todas as suas linhas (incluindo a das aspas de fechamento ["""]) é removida.
A action [index] devolve assim uma página HTML que contém links para as actions do outro controller:

O arquivo [controllers/FirstController.java]:
Vamos comentar este código:
- linhas 10–11: a anotação ***
[@RequestMapping("/first")]***, aplicada à classe, define o prefixo comum a todas as rotas do controller: suas actions tratam as rotas deURLque começam com***[/first]***; - linhas 15–16: [@GetMapping("")]: a action [index] trata [GET /first]. A URL da action é a concatenação do prefixo do controller com o caminho da action;
- linhas 21–22: a action [action01] trata [GET /first/action01];
- linhas 27–28: o mesmo caminho, mas para o método POST: [@PostMapping] substitui [@GetMapping]. Existem também [@PutMapping], [@DeleteMapping], [@PatchMapping]... (e [@RequestMapping], aplicada a um método, aceita todos os métodos HTTP). O nome do método [Java] ([action01Post]) é arbitrário: apenas as anotações importam para o roteamento. Além disso, em uma mesma classe, dois métodos não podem ter o mesmo nome com os mesmos parâmetros;
- linhas 33–34: [{id}] é uma variável de caminho: esse segmento da URL pode assumir vários valores. [\d+] é uma expressão regular: o segmento deve ser composto por um ou mais dígitos; caso contrário, a rota não corresponde. Em uma string [Java], o caractere [\] é escrito como [\\]: daí [{id:\\d+}]. A anotação [@PathVariable] instrui o [Spring MVC] a passar o valor do segmento ao parâmetro de mesmo nome da action, [id], após convertê-lo em [int]: para [/first/products/17], [id] é igual ao número 17. Este é o binding de dados ([data binding]), que o próximo capítulo examinará em detalhes. Para que o [Spring] conheça os nomes dos parâmetros, o compilador deve preservá-los nas classes compiladas (opção [-parameters]): o [spring-boot-starter-parent] cuida disso;
- linha 35: o operador [+] concatena uma string e um número;
- linhas 39–41: duas variáveis de caminho são passadas como dois parâmetros da action. O método [formatted] substitui cada ocorrência de [%d] no texto por um inteiro, na ordem dos argumentos;
- linhas 45–47: [{*path}] é uma variável “catch-all” ([catch-all]): ela aceita qualquer final de URL, inclusive [/]. Seu valor começa com [/].
Eis os resultados de algumas requisições:
Para enviar uma requisição POST, use a opção [-X POST] do [curl]:
Um método HTTP que não é tratado por nenhuma action para esse caminho resulta em um erro 405 ([Method Not Allowed]). O cabeçalho [Allow] lista os métodos aceitos:
Por fim, uma URL que não é tratada por nenhuma rota resulta em um erro 404. Isso também vale para um identificador que não respeita a expressão regular [\d+]: nenhuma rota corresponde a [/first/products/abc].
Ao contrário das do [ASP.NET Core], as respostas de erro do [Spring Boot] contêm as seguintes informações: a data do erro, o código de status, sua descrição, uma mensagem e o caminho requisitado. A mensagem [No static resource] se explica assim: quando nenhuma action corresponde à URL, o [Spring MVC] procura um arquivo estático com esse nome (uma imagem, uma folha de estilo... armazenada na pasta [src/main/resources/static] da aplicação); como não encontra nenhum, ele informa um erro 404. O [Spring Boot] gera então a resposta de erro, e a negociação de conteúdo entra em jogo novamente: o [curl] recebe JSON; um navegador, uma página HTML, a “Whitelabel Error Page” (uma página de erro “sem marca”):

O Capítulo 7 mostrará como substituir essa página por uma página de erro específica da aplicação.
2.3. Exemplo 03: Respostas das actions
O que uma action devolve determina a resposta HTTP. O Exemplo 03 revisa os principais casos. O arquivo [controllers/ResponsesController.java]:
Vamos detalhar este código:
- linhas 22–25: uma string, marcada como texto simples pelo atributo [produces] (veja o Exemplo 02): o navegador a exibe como está, tags incluídas;
- linhas 28–31: a mesma string, declarada como HTML: o navegador a interpreta;
- linhas 34–35: um record ([Java] 16): uma classe de dados, declarada em uma única linha. O compilador cria um campo privado e somente leitura para cada componente ([lastName], [firstName], [age]), um construtor que os inicializa, um método de acesso para cada um ([lastName()], [firstName()], [age()]) e métodos utilitários ([equals], [hashCode], [toString]). O record é declarado aqui dentro do controller: é uma classe aninhada, cujo nome completo é [ResponsesController.Person];
- linhas 38–41: um objeto é serializado em JSON, com o cabeçalho [Content-Type: application/json]. É a biblioteca [Jackson], fornecida pelo starter [spring-boot-starter-webmvc], que faz a conversão: os nomes das propriedades JSON correspondem aos componentes do record;
- linhas 44–47: uma lista é serializada em um array JSON. [List.of(...)] cria uma lista somente leitura. [List<String>] é um tipo genérico: uma lista cujos elementos são strings;
- linhas 51–54: quando a action precisa escolher o código de status, ela devolve um [ResponseEntity<T>]: um objeto que descreve a resposta completa (código, cabeçalhos, corpo do tipo [T]). Ele é criado por meio de métodos estáticos da classe [ResponseEntity], que são chamados em sequência: [status(HttpStatus.CREATED)] define o código como 201 ([Created]), [body(...)] define o conteúdo, que será serializado em JSON. [Map.of("message", "resource created")] cria um dicionário não modificável (um [Map]) com uma única chave, que o [Jackson] serializa no objeto JSON;
- linhas 57–60: [noContent()] devolve uma resposta 204 ([No Content]): “sem conteúdo”. [build()] devolve uma resposta sem corpo, resultando no tipo [ResponseEntity<Void>];
- linhas 63–70: uma action assíncrona. Ela devolve um [CompletableFuture<T>], um resultado “pendente” (o equivalente a uma tarefa [Task<T>] do [C#] ou a uma promise do [JavaScript]); o [Spring MVC] libera imediatamente a thread do [Tomcat] que estava processando a requisição e só envia a resposta quando o resultado estiver disponível. [supplyAsync(function, executor)] calcula o resultado por meio da função, que aqui é executada após um atraso de 500 ms. A função é escrita como uma lambda: [() -> expression] é uma função sem parâmetros que devolve o valor da expressão. [Duration.between] mede o tempo decorrido entre dois instantes;
- linhas 73–76: um erro previsto pelo programa: um [ResponseEntity] com código 404, contendo JSON. A classe [ResponseEntity] também tem atalhos: [ok(...)] (200), [badRequest()] (400), [notFound()] (404)...;
- linhas 79–82: um erro inesperado: a action lança uma exceção, que ela não trata. O [Spring Boot] responde então com um erro 500 ([Internal Server Error]).
Respostas recebidas:
Para a exceção, a resposta de erro do [Spring Boot] (veja o Exemplo 02) contém a mensagem da exceção, mas não a pilha de chamadas, o que é proibido pelo arquivo [application.properties] (veja a introdução). A própria mensagem só aparece ali porque as ferramentas de desenvolvimento ([Spring Boot DevTools]) estão ativas: em produção, sem elas, a resposta seria:
Uma mensagem de exceção pode, de fato, fornecer informações a um atacante. Os detalhes do erro são gravados no console do servidor (reproduzimos aqui apenas o início):
No navegador, a diferença entre [text/plain] e [text/html] é visível:


2.4. Exemplo 04: Redirecionamentos
Uma action pode responder com um redirecionamento: um código de status 301 ou 302 e um cabeçalho [Location] que informa ao navegador qual URL requisitar em seguida. O navegador a requisita imediatamente, sem nenhuma intervenção do usuário. Os redirecionamentos são onipresentes em uma aplicação web: após o envio bem-sucedido de um formulário, após o login, após a troca de idioma...
O arquivo [controllers/RedirectsController.java]:
Vamos comentar este código:
- linha 15: a classe é anotada como [@Controller], e não como [@RestController]. Uma string devolvida por uma action é, portanto (exceto com [@ResponseBody]), o nome de uma view; e um nome de view que começa com [redirect:] é um nome especial que dispara um redirecionamento;
- linhas 19–22: um redirecionamento permanente (código de status 301, [Moved Permanently]): a página mudou definitivamente para um novo endereço. Navegadores e mecanismos de busca podem guardar o novo endereço. Ele é criado com um [ResponseEntity] (veja o Exemplo 03): [location(...)] define o cabeçalho [Location], cujo valor é um objeto [URI] (um endereço);
- linhas 24–28: a anotação [@ResponseBody] é obrigatória aqui: a string devolvida é o corpo da resposta, e não um nome de view;
- linhas 31–34: ["redirect:" + url] gera um redirecionamento temporário (código de status 302, [Found]), neste caso para um endereço calculado;
- linhas 38–42: um redirecionamento para um endereço com template: em [redirect:/page/{name}], o [Spring MVC] substitui [{name}] pelo valor do atributo [name], que é armazenado no objeto [RedirectAttributes]. Esse objeto é fornecido pelo [Spring MVC] à action que o solicita como parâmetro. A vantagem em relação à forma anterior: o valor é corretamente codificado para uma URL (veja abaixo). O objeto [RedirectAttributes] também será usado, no Capítulo 4, para enviar mensagens à página seguinte;
- linhas 51–54: é possível redirecionar para outro site.
O [curl] demonstra o redirecionamento sem segui-lo de fato:
Com a opção [-L], o [curl] segue o redirecionamento, exatamente como faria um navegador. Vemos então as duas respostas sucessivas:
As duas actions resultam no mesmo redirecionamento. Observe que, desta vez, o endereço do cabeçalho [Location] é absoluto ([http://localhost:5000/...]), embora a action tenha devolvido um endereço relativo ([/page/contact]): um redirecionamento [redirect:] passa pelo servidor [Tomcat], que completa o endereço porque o [Spring Boot] assim o configura por padrão (propriedade [server.tomcat.use-relative-redirects], definida como [false]). O redirecionamento da action [oldPage], gerado por um [ResponseEntity], por outro lado, mantém o endereço como está. As duas formas são corretas.
A diferença entre as duas actions aparece quando o destino contém um caractere que precisa ser codificado em uma URL, como um espaço (codificado como [%20]):
A variável de caminho [destination] recebeu o valor decodificado, [my contact]. A concatenação da action [go] o copia exatamente como está: o cabeçalho [Location] contém um espaço bruto, o que o torna um endereço inválido (uma URL não contém espaço). Alguns clientes corrigem isso por conta própria ([curl -L], por exemplo, ainda segue o redirecionamento e chega à página [my contact]), enquanto outros não: isso é uma armadilha, pois o erro passa despercebido durante os testes. A URL com template da action [toTemplate], por outro lado, é codificada corretamente: esta é a maneira adequada de inserir o valor de uma variável em um redirecionamento. No navegador, apenas a página final é visível; a barra de endereços exibe a nova URL:
![]()
2.5. Exemplo 05: Os objetos Request e Response
[Spring MVC] se baseia na API [Servlet] e no [Jakarta EE] (antes chamado [Java EE]), o padrão de servidor web [Java]: [Tomcat] é um contêiner de servlets, e [DispatcherServlet] é um servlet — ou seja, um objeto ao qual o servidor delega requisições. Nesse padrão, cada requisição é representada por um objeto [HttpServletRequest], e a resposta em construção por um objeto [HttpServletResponse]. Uma action pode receber qualquer um deles: basta solicitá-los como parâmetros. Isso às vezes é necessário, e o faremos no estudo de caso (para ler ou definir um cookie, por exemplo), mas é preciso saber o que se está fazendo.
O arquivo [controllers/HttpController.java]:
Vamos comentar este código:
- linhas 12–13: as classes da API [Servlet] estão no pacote [jakarta.servlet...];
- linha 22: a action declara um parâmetro do tipo [HttpServletRequest]: o [Spring MVC] lhe passa a requisição atual. É assim que o [Spring MVC] fornece a uma action o que ela precisa: com base no tipo de seus parâmetros ou em suas anotações ([@PathVariable]...);
- linha 24: um dicionário mutável. [Map] é uma interface (um tipo que descreve operações sem implementá-las; voltaremos a isso no Exemplo 06), [LinkedHashMap] é uma de suas implementações; [<>] usa os tipos genéricos da declaração ([<String, String>]);
- linhas 25–29: a requisição: o método HTTP ([getMethod]), o caminho ([getRequestURI]), os parâmetros da URL ([getQueryString], sem o [?], ou [null] se não houver), um cabeçalho ([getHeader]) e o endereço IP do cliente ([getRemoteAddr]);
- linhas 34–38: a action adiciona um cabeçalho à resposta e depois devolve normalmente o valor dele, que o [Spring MVC] envia. Este é o uso mais comum do objeto de resposta;
- linhas 41–46: a action escreve a resposta ela mesma — código de status, tipo e depois o corpo — usando o objeto [PrintWriter] devolvido por [getWriter()]. Ela não devolve nada ([void]): o [Spring MVC] considera então que a resposta foi escrita pela action. A cláusula [throws IOException] declara que o método pode lançar uma [IOException] (um erro de escrita): em [Java], um método deve declarar dessa forma as chamadas exceções verificadas que ele não trata;
- linhas 49–56: o erro a evitar: escrever parte da resposta e depois devolver um resultado. Depois que os primeiros bytes do corpo foram enviados ao navegador (aqui, forçado por [flushBuffer]), o código de status e os cabeçalhos — que são enviados antes do corpo — não podem mais ser alterados.
As respostas obtidas:
(a opção [-A] do [curl] define o cabeçalho [User-Agent], que identifica o navegador)
Na última requisição, o cliente recebe um código de status 200 e o início da resposta, em vez do 404 solicitado. E, ao contrário do [ASP.NET Core], o servidor não informa nada: o console permanece em silêncio, e o erro pode passar despercebido. A resposta revela uma segunda falha: ela não tem cabeçalho [Content-Type]. A action não definiu o tipo da resposta antes de escrever nela: o objeto de resposta codifica então o texto de acordo com o conjunto de caracteres padrão do padrão [Servlet], [ISO-8859-1], enquanto o terminal espera UTF-8, de modo que quaisquer caracteres acentuados seriam substituídos por [�] (o texto desta resposta não contém nenhum). O navegador, por sua vez, não recebe nenhuma indicação de conjunto de caracteres; ele tenta adivinhar um — neste caso, com sucesso:

Mais adiante no documento, as actions quase sempre devolverão um valor (um objeto, um [ResponseEntity], um nome de view) e deixarão o [Spring MVC] escrever a resposta. [HttpServletRequest] e [HttpServletResponse] serão usados apenas para ler a requisição e definir cookies.
2.6. Exemplo 06: Serviços e injeção de dependência
Os controllers não devem conter lógica de aplicação; eles a delegam a serviços. Um serviço é um objeto comum que o [Spring] cria e fornece às classes que precisam dele: isso é a injeção de dependência. Os objetos que o [Spring] cria e gerencia dessa forma são chamados de beans (da palavra inglesa para “grãos”; os controllers também são beans). O conjunto de beans de uma aplicação forma o [Spring] contexto, ou contêiner de beans. O Exemplo 06 divide uma pequena aplicação em duas partes: produtos e clientes:
2.6.1. O produto
Um record (veja o Exemplo 03), desta vez em seu próprio arquivo. O tipo [BigDecimal] representa valores monetários sem erros de arredondamento, o que o tipo [double] não garante.
2.6.2. O contrato do serviço: ProductsService
- linha 7: uma interface descreve o que o serviço pode fazer, sem especificar como. As classes que usam o serviço conhecerão apenas essa interface. Ao contrário da convenção do [C#] ([IProductsService]), o nome de uma interface [Java] não começa com [I];
- linha 9: [List<Product>]: uma lista de produtos;
- linha 11: [Optional<Product>]: um produto, ou nada se nenhum produto tiver esse identificador. Um [Optional] é uma caixa, vazia ou contendo um valor: ele obriga o chamador a considerar o caso em que não há produto, ao passo que um [null] poderia ser esquecido (e causar uma [NullPointerException]).
2.6.3. A implementação: InMemoryProductsService
- linha 8: a classe implementa a interface ([implements]): ela deve fornecer todos os seus métodos;
- linhas 10–13: os dados, aqui em memória, em uma lista somente leitura. Os valores são construídos a partir de strings: [new BigDecimal("1.5")] é exatamente 1,5;
- linhas 15 e 20: a anotação [@Override] indica que o método pertence a uma interface (ou a uma classe pai): o compilador verifica se ele realmente existe;
- linha 22: um iterador ([stream]) percorre a lista: [filter] retém apenas os produtos que satisfazem a condição, escrita como uma lambda de um único parâmetro (veja o Exemplo 03), [p]; [findFirst] devolve o primeiro produto restante em um [Optional], que fica vazio se não houver nenhum. [p.id()] é o método de acesso ao componente [id] do record.
A classe não tem anotações: é uma classe [Java] comum, que não sabe nada sobre o [Spring]. Veremos mais adiante como ela se torna um bean.
2.6.4. O controller ProductsController
- linhas 17–22: injeção de dependência. O controller declara em seu construtor que precisa de um [ProductsService]; o [Spring], que cria o controller, lhe fornece um bean desse tipo (veja abaixo). O controller nunca chama [new InMemoryProductsService()]: ele nem sequer conhece essa classe, apenas a interface. Poderíamos substituir a implementação (por uma versão que lê um banco de dados ou por uma versão de teste) sem modificar o controller. O campo é declarado como
***[final]***: ele só pode ser atribuído uma vez, no construtor; - linhas 24–27: a action delega ao serviço. A lista é serializada como JSON;
- linhas 29–35: [{id:\\d+}] aceita apenas números; um produto inexistente devolve uma resposta 404. O [Optional] devolvido pelo serviço é processado em duas etapas: [map] transforma seu conteúdo, se houver, em uma resposta 200; [orElseGet] fornece a resposta a usar se o [Optional] estiver vazio — neste caso, uma resposta 404 acompanhada de uma mensagem. [ResponseEntity::ok] é uma referência de método: uma forma mais curta de escrever a lambda [p -> ResponseEntity.ok(p)]. O tipo [ResponseEntity<?>] ([?]: qualquer tipo de corpo) permite que a action devolva um produto ou um dicionário; a notação [.<ResponseEntity<?>>map(...)] especifica esse tipo ao compilador, que não consegue inferi-lo sozinho.
2.6.5. O controller ClientsController
- linhas 19–23: o [ClientsController] recebe o mesmo serviço que o [ProductsController]. A classe tem apenas um construtor: o [Spring] o usa para a injeção sem nenhuma outra especificação. Esta é a forma de injeção recomendada, e a usada em todo o documento;
- linhas 26–27: um record aninhado que descreve a resposta JSON;
- linha 33: o cálculo do total. [map] converte o stream de produtos em um stream de preços ([Product::price] é uma referência ao método de acesso [price()] do record), depois [reduce] os acumula, partindo de zero ([BigDecimal.ZERO]) e somando-os dois a dois ([BigDecimal::add]).
2.6.6. Declarando beans
O [Spring] só pode fornecer um serviço se o conhecer: cada serviço deve ser declarado como um bean. Os controllers são declarados por meio de sua anotação [@RestController], detectada durante a varredura de componentes (veja o Exemplo 01). A classe [InMemoryProductsService], por outro lado, não tem anotação: ela é declarada no arquivo [products/ProductsConfig.java]:
- linha 9: a anotação [@Configuration] designa a classe como uma classe de configuração; ela também é encontrada pela varredura de componentes, e o [Spring] executa seus métodos anotados com [@Bean] na inicialização. Ela reúne as declarações da parte de “produtos” da aplicação;
- linhas 14–17: um método anotado com [@Bean] cria um bean. Isso significa: “quando uma classe solicita um [ProductsService], forneça a ela o objeto devolvido por este método”. O nome do método ([productsService]) se torna o nome do bean.
Há outra forma, mais curta, de declarar um bean: anotar a própria classe com [@Service] (ou [@Component], do qual [@Service], [@Controller] e [@Repository] são variantes), que a varredura de componentes encontra da mesma forma que encontra os controllers. Colocar [@Service] antes da classe [InMemoryProductsService] tornaria desnecessário o arquivo [ProductsConfig.java] . O método [@Bean] é útil quando a classe não pode receber uma anotação (uma classe de uma biblioteca, por exemplo) ou quando a criação do objeto exige código. As duas formas serão usadas mais adiante neste documento.
Por padrão, um bean é um singleton: o [Spring] cria uma única instância na inicialização e a fornece a todas as classes que a solicitam durante toda a vida da aplicação. [ProductsController] e [ClientsController] recebem assim o mesmo objeto [InMemoryProductsService]. Existem outros escopos: [prototype] (uma nova instância a cada solicitação), [request] (uma instância por requisição HTTP), [session]... O Capítulo 6 voltará a esse assunto.
Os controllers também são singletons: um único objeto [ProductsController] trata todas as requisições, potencialmente ao mesmo tempo, em várias threads. Esta é uma diferença fundamental em relação ao [ASP.NET Core MVC], que cria um novo objeto controller para cada requisição. Um controller [Spring] não deve, portanto, armazenar em seus campos dados específicos de uma requisição: seus campos contêm apenas os serviços injetados, declarados como [final].
A classe [Example06Application] é igual à dos exemplos anteriores: não há nada a registrar nela; a varredura de componentes encontra os controllers e a classe de configuração nos subpacotes [clients] e [products].
2.6.7. Execução
O estudo de caso é estruturado exatamente assim: controllers enxutos que delegam a serviços injetados, descritos por interfaces e declarados como beans.