Controlador Spring
Um controlador Spring (ou Spring Controller) é um componente essencial do framework
Spring MVC (Model-View-Controller) que gerencia as requisições HTTP e as respostas em
uma aplicação web. Ele serve como um intermediário entre o modelo (dados) e a
visualização (interface do usuário), processando entradas do usuário, invocando lógica de
negócio e retornando a resposta adequada ao cliente.
Funções de um Controlador Spring
1. Gerenciar Requisições HTTP: Recebe requisições HTTP (GET, POST, PUT,
DELETE, etc.) e determina como processá-las.
2. Invocar Lógica de Negócio: Chama métodos de serviços ou componentes para
executar a lógica de negócio necessária.
3. Selecionar View: Determina qual view (página HTML, JSON, XML, etc.) deve ser
retornada como resposta.
4. Passar Dados para a View: Atribui dados ao modelo para que possam ser usados
na view.
Estrutura Básica de um Controlador Spring
Um controlador Spring é uma classe anotada com @Controller ou @RestController e
contém métodos anotados com @RequestMapping (ou outras anotações específicas de
métodos HTTP como @GetMapping, @PostMapping, etc.). Aqui está um exemplo básico:
Exemplo Simples com @Controller
import [Link];
import [Link];
import [Link];
@Controller
public class HomeController {
@GetMapping("/home")
public String home(Model model) {
[Link]("message", "Bem-vindo ao Spring MVC!");
return "home"; // Retorna o nome do template Thymeleaf
"[Link]"
}
}
Exemplo com @RestController
import [Link];
import [Link];
@RestController
public class ApiController {
@GetMapping("/api/greeting")
public Greeting greeting() {
return new Greeting("Olá, mundo!");
}
}
class Greeting {
private String message;
public Greeting(String message) {
[Link] = message;
}
// Getter e Setter
public String getMessage() {
return message;
}
public void setMessage(String message) {
[Link] = message;
}
}
Anotações Comuns em Controladores Spring
1. @Controller: Indica que a classe é um controlador Spring. Usado para
controladores que retornam views.
2. @RestController: Indica que a classe é um controlador REST. Combina
@Controller e @ResponseBody, retornando dados diretamente no corpo da
resposta (geralmente JSON ou XML).
3. @RequestMapping: Mapeia requisições HTTP para métodos específicos. Pode ser
usado na classe ou nos métodos.
4. @GetMapping, @PostMapping, @PutMapping, @DeleteMapping: Mapeiam
requisições HTTP específicas (GET, POST, PUT, DELETE) para métodos.
5. @RequestParam: Vincula parâmetros de requisição aos parâmetros do método.
6. @PathVariable: Vincula variáveis de URL aos parâmetros do método.
7. @ModelAttribute: Vincula atributos de modelo aos parâmetros do método e permite
preencher objetos de modelo.
8. @RequestBody: Vincula o corpo da requisição HTTP ao parâmetro do método
(usado em APIs REST).
Exemplo Avançado com Várias Anotações
import [Link];
import [Link].*;
@Controller
@RequestMapping("/users")
public class UserController {
@GetMapping("/{id}")
public String getUser(@PathVariable Long id, Model model) {
User user = [Link](id);
[Link]("user", user);
return "userDetails"; // Retorna o template Thymeleaf
"[Link]"
}
@PostMapping
public String createUser(@ModelAttribute User user, Model model)
{
[Link](user);
return "redirect:/users"; // Redireciona para a lista de
usuários
}
}
Resumo
● Controladores Spring são usados para gerenciar a lógica de roteamento e
manipulação de requisições HTTP em uma aplicação web.
● @Controller é usado para controladores que retornam views.
● @RestController é usado para controladores que retornam dados diretamente
(APIs REST).
● @RequestMapping e outras anotações específicas de métodos HTTP ajudam a
mapear requisições para métodos de controlador.
Esses controladores são fundamentais para criar aplicações web dinâmicas e robustas
usando o Spring Framework.