Anotações do Spring Boot mais Comuns – Tutorial Passo a Passo

O Spring Boot é conhecido por simplificar o desenvolvimento de aplicativos Java, hoje vamos criar vários exemplos sobre as principais Anotações do Spring Boot, oferecendo uma variedade de recursos que agilizam a configuração e o desenvolvimento.

As anotações são indispensáveis nesse ecossistema, fornecendo maneiras simples e eficazes de configurar e controlar o comportamento dos componentes.

Assim como as anotações do Java, este framework também tem as suas de formas isoladas e que cada uma delas tem uma função especifica no projeto.

O Papel das Anotações no Spring Boot

As anotações no Spring Boot são marcadores especiais que podem ser aplicados a classes, métodos ou campos para fornecer informações e instruções adicionais ao framework durante a execução.

Elas são essenciais para definir a configuração, o comportamento dos componentes e a integração com outros módulos.

Vamos começar um tutorial passo a passo com 9 das anotações mais comuns do Spring Boot.

1º Anotação @SpringBootApplication

Essa anotação é frequentemente encontrada na classe principal de um aplicativo Spring Boot. Ela combina três outras anotações: @Configuration, @EnableAutoConfiguration e @ComponentScan.

Isso permite que o Spring Boot realize a configuração automática com base nas dependências presentes no classpath, além de identificar e registrar beans e componentes no contexto da aplicação.

Exemplo simples:

package br.com.virandoprogramador.anotacoes

@SpringBootApplication
public class MinhaAplicacaoSpringBootApplication {

    public static void main(String[] args) {
        SpringApplication.run(MinhaAplicacaoSpringBootApplication.class, args);
    }
}

Neste exemplo, a classe MinhaAplicacaoSpringBootApplication é a classe principal do aplicativo. A anotação @SpringBootApplication é usada para configurar automaticamente o aplicativo Spring Boot. O método main inicia a aplicação, usando SpringApplication.run().

A anotação @SpringBootApplication também permite a personalização de diferentes aspectos do aplicativo, por meio de atributos:

• exclude: Permite a exclusão de classes de autoconfiguração específicas.
• scanBasePackages: Define pacotes adicionais a serem escaneados para componentes.
• scanBasePackageClasses: Define classes adicionais a serem escaneadas para componentes.

2º Anotação @RestController

A anotação @RestController é uma extensão da anotação @Controller, sendo específica para aplicativos que implementam RESTful APIs.

Ela combina a funcionalidade das anotações @Controller e @ResponseBody, permitindo que cada método dessa classe retorne diretamente dados serializados em um formato aceitável, como JSON ou XML, sem a necessidade de usar explicitamente a anotação @ResponseBody.

Criando Endpoints RESTful

No contexto do Spring Boot, os controladores anotados com @RestController são responsáveis por definir os pontos de extremidade (endpoints) para lidar com as requisições HTTP.

Exemplo:

package br.com.virandoprogramador.controller; 

import br.com.virandoprogramador.models.User;
import br.com.virandoprogramador.services.UserService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        List<User> users = userService.getAllUsers();
        return new ResponseEntity<>(users, HttpStatus.OK);
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable("id") Long id) {
        User user = userService.getUserById(id);
        if (user != null) {
            return new ResponseEntity<>(user, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User createdUser = userService.createUser(user);
        return new ResponseEntity<>(createdUser, HttpStatus.CREATED);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable("id") Long id, @RequestBody User user) {
        User updatedUser = userService.updateUser(id, user);
        if (updatedUser != null) {
            return new ResponseEntity<>(updatedUser, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable("id") Long id) {
        userService.deleteUser(id);
        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
    }
}

Neste exemplo, a classe UserController é anotada com @RestController e define endpoints RESTful para lidar com operações CRUD (Create, Read, Update, Delete) em recursos de usuários /api/users.

• @GetMapping: Mapeia requisições HTTP GET para recuperar todos os usuários ou um usuário por ID.
• @PostMapping: Mapeia requisições HTTP POST para criar um novo usuário.
• @PutMapping: Mapeia requisições HTTP PUT para atualizar um usuário existente.
• @DeleteMapping: Mapeia requisições HTTP DELETE para excluir um usuário por ID.

Utilizando ResponseEntity

O uso de ResponseEntity permite um controle preciso das respostas HTTP retornadas pelos endpoints. Ele permite definir o corpo da resposta, status HTTP e cabeçalhos de maneira flexível.

3º Anotação @RequestMapping

No desenvolvimento de aplicativos web usando o Spring Boot, a anotação @RequestMapping é usada para mapear solicitações HTTP para métodos específicos em controladores, permitindo que os desenvolvedores criem APIs RESTful ou endpoints web de maneira flexível e personalizada.

O Que é @RequestMapping?

A anotação @RequestMapping é uma anotação versátil que mapeia solicitações HTTP para métodos específicos dentro de um controlador.

Ela pode ser aplicada a nível de classe ou de método, permitindo a definição de mapeamentos de URL para diferentes métodos de manipulação de solicitações HTTP, como GET, POST, PUT, DELETE, entre outros.

package br.com.virandoprogramador.controller; 

@RestController
@RequestMapping("/api")
public class VirandoProgramadorController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

Neste exemplo, a classe VirandoProgramadorController é anotada com @RestController e @RequestMapping(“/api”), indicando que todos os endpoints dentro desta classe serão mapeados com o prefixo /api. O método hello() é mapeado para a URL relativa /hello. Assim, quando uma solicitação GET é feita para /api/hello, o método hello() é invocado e retorna a mensagem “Hello, World!”.

4º Anotação @Component

A anotação @Component desempenha um papel importante no contexto do Spring, sendo a base para outras anotações especializadas que ajudam na definição e gerenciamento de componentes.

O Que é @Component?

A anotação é uma das mais simples e genéricas no Spring Boot. Ela é usada para identificar uma classe como um componente gerenciado pelo Spring, permitindo que o framework a reconheça automaticamente e a registre no contexto da aplicação como um bean.

Utilizando Componentes Gerenciados

Os componentes gerenciados pelo Spring podem ser injetados em outras classes usando as anotações @Autowired ou através da injeção de dependências em construtores, métodos setters ou diretamente em campos.

@Component
public class MinhaClasseComponente {
}

@Service
public class MeuServico {

    private final MinhaClasseComponente minhaComponente;

    @Autowired
    public MeuServico(MinhaClasseComponente minhaComponente) {
        this.minhaComponente = minhaComponente;
    }
}

Neste exemplo, a classe MeuServico é uma classe de serviço que injeta MinhaClasseComponente usando a anotação @Autowired no construtor. Isso permite o uso direto do componente dentro do serviço.

5º Anotação @Service

A anotação @Service é uma das anotações especializadas do Spring Framework. Ela é usada para marcar classes que representam a camada de serviço em uma aplicação Spring.

Essa camada contém a lógica de negócios, implementando regras e processos específicos do domínio da aplicação.

Exemplo de uma classe Service:

package br.com.virandoprogramador.service; 

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User salvar(User user) {
        return userRepository.save(user);
    }

    public User buscarPorId(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    public User atualizar(Long id, User userDetails) {
        User user = userRepository.findById(id).orElse(null);
        if (user != null) {
            user.setNome(userDetails.getNome());
            user.setEmail(userDetails.getEmail());
            return userRepository.save(user);
        }
        return null;
    }

    public void deletar(Long id) {
        userRepository.deleteById(id);
    }
}

Neste exemplo, temos uma classe UserService anotada com @Service que gerencia operações relacionadas aos usuários (User). A classe UserService é injetada com um UserRepository via construtor para acessar e manipular os dados no banco de dados.

• salvar: Método para salvar um novo usuário no banco de dados.
• buscarPorId: Método para buscar um usuário pelo ID no banco de dados.
• atualizar: Método para atualizar um usuário existente no banco de dados com base no ID fornecido.
• deletar: Método para deletar um usuário do banco de dados com base no ID fornecido.

6º Anotação @Repository

Ela é usada para marcar classes que atuam como componentes responsáveis pelo acesso a dados, oferecendo uma abstração de camada de persistência para o framework Spring.

O Que é @Repository?

A anotação @Repository é uma anotação especializada do Spring Framework usada para indicar que uma classe serve como um repositório, encapsulando o acesso a dados ou a uma fonte de dados específica.

É comumente usada em conjunto com classes que acessam o banco de dados, realizam operações de leitura e escrita, e lidam com operações CRUD como(Create, Read, Update, Delete).

Exemplo de uma classe Repository:

package br.com.virandoprogramador.repository; 

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByEmail(String email);

    List<User> findByNomeIgnoreCaseContaining(String nome);

    List<User> findByAtivoTrue();
}

• findByEmail: Método que busca um usuário pelo email.
• findByNomeIgnoreCaseContaining: Método que busca usuários por parte do nome, ignorando maiúsculas e minúsculas.
• findByAtivoTrue: Método que busca todos os usuários ativos.

Esses métodos são gerados automaticamente pelo Spring Data JPA, sem a necessidade de implementação manual.

Eles utilizam a convenção de nomenclatura do Spring Data, onde o método é analisado e a consulta SQL correspondente é gerada automaticamente.

Além dos métodos padrão oferecidos pelo JpaRepository, você pode adicionar métodos personalizados à interface do repositório, seguindo a convenção de nomenclatura do Spring Data.

7º Anotação @Value

A anotação @Value é uma anotação do Spring Framework que permite injetar valores de propriedades em campos de classe, construtores ou métodos.

Ela é usada para buscar valores de propriedades a partir de arquivos de configuração, como application.properties ou application.yml, configurados diretamente em componentes gerenciados pelo Spring.

Veja um exemplo simples desta anotação:

app:
  minhaPropriedade: Valor da minha propriedade
  outraPropriedade: Valor de outra propriedade
  propriedadePadrao: Valor Padrão

Primeiro precisamos adicionar os valores em nosso arquivo application.yml e em seguida utilizar em uma classe Java:

package br.com.virandoprogramador.component; 

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class MeuComponente {

    @Value("${app.minhaPropriedade}")
    private String minhaPropriedade;

    @Value("${app.outraPropriedade}")
    private String outraPropriedade;

    @Value("${app.propriedadeInexistente:Valor Padrão Personalizado}")
    private String propriedadeInexistente;

    public String getMinhaPropriedade() {
        return minhaPropriedade;
    }

    public String getOutraPropriedade() {
        return outraPropriedade;
    }

    public String getPropriedadeInexistente() {
        return propriedadeInexistente;
    }
}

Neste exemplo, a classe MeuComponente possui três campos (minhaPropriedade, outraPropriedade e propriedadeInexistente) anotados com @Value. Eles estão mapeados para as propriedades correspondentes no arquivo application.yml.

Se a propriedade não for encontrada no arquivo de configuração YAML, o valor padrão especificado após os dois-pontos será usado (como no caso da propriedade propriedadeInexistente).

Esse é um exemplo básico de como a anotação @Value pode ser usada em conjunto com um arquivo de configuração YAML no Spring Boot para injetar valores de propriedades em componentes gerenciados pelo Spring.

8º Anotação @Autowired

A anotação @Autowired é uma anotação do Spring Framework utilizada para realizar a injeção de dependências automaticamente em classes gerenciadas pelo Spring.

Ela permite que o Spring identifique as dependências necessárias para uma classe e as forneça automaticamente, reduzindo a necessidade de criar instâncias manualmente ou usar o padrão Singleton.

Exemplo simples:

@Component
public class MeuComponente {

    private OutroComponente outroComponente;

    @Autowired
    public MeuComponente(OutroComponente outroComponente) {
        this.outroComponente = outroComponente;
    }
}

Neste exemplo, a classe MeuComponente possui um campo outroComponente anotado com @Autowired no construtor. Quando o Spring inicializa MeuComponente, ele automaticamente fornece uma instância de OutroComponente por meio da injeção de dependências.

9º Anotação @Configuration

A anotação @Configuration é uma anotação do Spring usada para marcar classes de configuração. Essas classes geralmente contêm métodos anotados com @Bean, que definem e configuram beans específicos dentro do contexto da aplicação.

Exemplo:

@Configuration
public class AppConfig {

    @Bean
    public MeuBean meuBean() {
        return new MeuBean();
    }

    @Bean
    public OutroBean outroBean() {
        return new OutroBean();
    }
}

A classe AppConfig é anotada com @Configuration. Ela define dois métodos, meuBean() e outroBean(), anotados com @Bean, que são responsáveis por instanciar e configurar os beans dentro do contexto da aplicação.

Métodos @Bean

Os métodos anotados com @Bean dentro de uma classe @Configuration são usados para definir beans gerenciados pelo Spring. Esses métodos retornam instâncias dos objetos que serão gerenciados e injetados pelo contêiner do Spring.

Importando Configurações

A anotação @Configuration também permite importar outras classes de configuração usando a anotação @Import, veja um exemplo:

@Configuration
@Import(OutraConfiguracao.class)
public class AppConfig {
}

Dessa forma, é possível compor diferentes classes de configuração em uma aplicação Spring, dividindo a configuração em módulos ou separando por funcionalidades específicas.

Usando com @ComponentScan

A anotação @Configuration é frequentemente usada em conjunto com @ComponentScan. Ela escaneia pacotes em busca de componentes, enquanto as classes anotadas com @Configuration fornecem configurações.

Conclusão sobre as Anotações do Spring Boot

As anotações como @Autowired, @Component, @Service, @Repository promovem a inversão de controle e a injeção de dependências, reduzindo a necessidade de gerenciamento manual.

A anotação @Configuration permite a criação de classes para configurar e personalizar o comportamento da aplicação, aumentando a flexibilidade e a modularidade do código.

A legibilidade do código é aprimorada com o uso de anotações, tornando mais fácil entender a função e o comportamento de diferentes componentes da aplicação. Contudo, a separação de responsabilidades é facilitada, ajudando na organização e na manutenção do código-fonte.