Pular para o conteúdo principal

Capítulo 1: Anotações Core Spring

1. @SpringBootApplication​

A anotação de inicialização que combina três anotações em uma.

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

Equivalente a:

@SpringBootConfiguration   // Indica uma classe de configuração
@EnableAutoConfiguration   // Ativa a auto-configuração do Spring Boot
@ComponentScan             // Faz scan dos componentes no pacote atual e subpacotes

2. Anotações de Estereótipo​

Essas anotações identificam o papel de uma classe na arquitetura.

@Component​

Anotação genérica para qualquer bean Spring.

@Component
public class EmailValidator {
    public boolean isValid(String email) {
        return email != null && email.contains("@");
    }
}

@Service​

Indica uma classe de lógica de negócio (camada de serviço).

@Service
public class UserService {
    private final UserRepository userRepository;

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

    public User findById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new RuntimeException("Usuário não encontrado"));
    }
}

@Repository​

Indica uma classe de acesso a dados. Ativa a tradução automática de exceções SQL em exceções Spring.

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

@Controller​

Indica um controller MVC (retorna views HTML).

@Controller
public class PageController {
    @GetMapping("/accueil")
    public String accueil(Model model) {
        model.addAttribute("message", "Bem-vindo!");
        return "accueil";  // Retorna o nome de uma view (template)
    }
}

@RestController​

Combinação de @Controller + @ResponseBody. Cada método retorna JSON/XML diretamente.

@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping
    public List<User> getAll() {
        return userService.findAll();  // Retorna JSON automaticamente
    }
}

Resumo dos estereótipos​

AnotaçãoCamadaPapel
@ComponentGenéricaQualquer bean Spring
@ServiceServiçoLógica de negócio
@RepositoryDadosAcesso ao banco de dados
@ControllerWebController MVC (views)
@RestControllerWebController REST (JSON)

3. Anotações de Injeção de Dependências​

@Autowired​

Injeção automática de um bean Spring.

@Service
public class OrderService {

    // Injeção via construtor (RECOMENDADO)
    private final ProductService productService;

    @Autowired  // Opcional se houver apenas um construtor
    public OrderService(ProductService productService) {
        this.productService = productService;
    }
}
@Service
public class NotificationService {

    // Injeção por campo (não recomendado, mas comum)
    @Autowired
    private EmailService emailService;

    // Injeção via setter
    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}
Boa prática

Prefira sempre a injeção via construtor. Ela torna as dependências explícitas e facilita os testes.

@Qualifier​

Resolve ambiguidades quando vários beans implementam a mesma interface.

public interface NotificationSender {
    void send(String message);
}

@Component("emailSender")
public class EmailNotification implements NotificationSender {
    public void send(String message) { /* envio de email */ }
}

@Component("smsSender")
public class SmsNotification implements NotificationSender {
    public void send(String message) { /* envio de SMS */ }
}

@Service
public class AlertService {
    private final NotificationSender sender;

    public AlertService(@Qualifier("emailSender") NotificationSender sender) {
        this.sender = sender;
    }
}

@Primary​

Define o bean padrão quando existem vários candidatos.

@Primary
@Component
public class EmailNotification implements NotificationSender {
    // Este bean será injetado por padrão
}

@Value​

Injeta valores a partir dos arquivos de configuração.

@Service
public class AppConfig {

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

    @Value("${app.max-retry:3}")  // Valor padrão = 3
    private int maxRetry;

    @Value("${server.port}")
    private int port;

    @Value("#{2 + 3}")  // SpEL (Spring Expression Language)
    private int calculated;
}
# application.yml
app:
  name: MonApplication
  max-retry: 5
server:
  port: 8080

@Lazy​

Retarda a inicialização do bean até seu primeiro uso.

@Service
@Lazy
public class HeavyService {
    public HeavyService() {
        // Este construtor só será chamado quando o bean for utilizado
    }
}

4. Anotações de Configuração​

@Configuration​

Declara uma classe de configuração Spring (equivalente ao XML).

@Configuration
public class AppConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        return mapper;
    }
}

@Bean​

Declara um bean gerenciado pelo container Spring. Usado em classes @Configuration.

@Configuration
public class SecurityConfig {

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authManager(AuthenticationConfiguration config)
            throws Exception {
        return config.getAuthenticationManager();
    }
}

@ConfigurationProperties​

Vincula um grupo de propriedades a um objeto Java.

@Configuration
@ConfigurationProperties(prefix = "app.mail")
public class MailProperties {
    private String host;
    private int port;
    private String username;
    private String password;

    // Getters e setters obrigatórios
    public String getHost() { return host; }
    public void setHost(String host) { this.host = host; }
    // ...
}
# application.yml
app:
  mail:
    host: smtp.gmail.com
    port: 587
    username: user@gmail.com
    password: secret

@PropertySource​

Carrega um arquivo de propriedades adicional.

@Configuration
@PropertySource("classpath:custom-config.properties")
public class CustomConfig {
    @Value("${custom.property}")
    private String customProp;
}

@Import​

Importa outras classes de configuração.

@Configuration
@Import({SecurityConfig.class, DatabaseConfig.class})
public class AppConfig {
}

5. Anotações de Escopo e Lifecycle​

@Scope​

Define o escopo do bean.

@Component
@Scope("prototype")  // Nova instância a cada injeção
public class ShoppingCart {
    private List<Item> items = new ArrayList<>();
}
EscopoDescrição
singletonUma única instância (padrão)
prototypeNova instância a cada requisição
requestUma instância por requisição HTTP
sessionUma instância por sessão HTTP
applicationUma instância por ServletContext

@PostConstruct​

Executa um método após a injeção de todas as dependências.

@Service
public class CacheService {
    private Map<String, Object> cache;

    @PostConstruct
    public void init() {
        cache = new HashMap<>();
        // Carregar dados iniciais
    }
}

@PreDestroy​

Executa um método antes da destruição do bean.

@Service
public class ConnectionPool {

    @PreDestroy
    public void cleanup() {
        // Fechar todas as conexões
    }
}

6. Anotações de Profile e Condições​

@Profile​

Ativa um bean apenas para determinados profiles.

@Configuration
@Profile("dev")
public class DevDatabaseConfig {
    @Bean
    public DataSource dataSource() {
        // H2 em memória para desenvolvimento
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .build();
    }
}

@Configuration
@Profile("prod")
public class ProdDatabaseConfig {
    @Bean
    public DataSource dataSource() {
        // PostgreSQL para produção
        HikariDataSource ds = new HikariDataSource();
        ds.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
        return ds;
    }
}
# Ativar um profile
java -jar app.jar --spring.profiles.active=prod

@ConditionalOnProperty​

Ativa um bean conforme o valor de uma propriedade.

@Configuration
@ConditionalOnProperty(name = "app.feature.email", havingValue = "true")
public class EmailConfig {
    @Bean
    public EmailService emailService() {
        return new SmtpEmailService();
    }
}

@ConditionalOnClass​

Ativa um bean se uma classe estiver presente no classpath.

@Configuration
@ConditionalOnClass(name = "org.postgresql.Driver")
public class PostgresConfig {
    // Configurado automaticamente se o driver PostgreSQL estiver disponível
}

@ConditionalOnMissingBean​

Ativa um bean somente se nenhum outro bean do mesmo tipo existir.

@Bean
@ConditionalOnMissingBean
public ObjectMapper objectMapper() {
    return new ObjectMapper();
}

7. Anotações Lombok (Bônus)​

Lombok gera código automaticamente em tempo de compilação.

@Data​

Gera getters, setters, toString, equals, hashCode.

@Data
public class UserDto {
    private Long id;
    private String name;
    private String email;
}

@Getter / @Setter​

@Getter @Setter
public class Product {
    private Long id;
    private String name;
    private BigDecimal price;
}

@NoArgsConstructor / @AllArgsConstructor / @RequiredArgsConstructor​

@NoArgsConstructor
@AllArgsConstructor
public class Address {
    private String street;
    private String city;
    private String zipCode;
}

@RequiredArgsConstructor  // Construtor para campos final
@Service
public class UserService {
    private final UserRepository userRepository;  // Injetado automaticamente
    private final PasswordEncoder passwordEncoder;
}

@Builder​

Implementa o padrão Builder.

@Builder
@Data
public class UserDto {
    private Long id;
    private String name;
    private String email;
}

// Uso
UserDto user = UserDto.builder()
    .id(1L)
    .name("Jean")
    .email("jean@example.com")
    .build();

@Slf4j​

Adiciona um logger SLF4J automaticamente.

@Slf4j
@Service
public class PaymentService {
    public void processPayment(Payment payment) {
        log.info("Processando pagamento: {}", payment.getId());
        log.debug("Valor: {}", payment.getAmount());
    }
}

Resumo Rápido​

AnotaçãoPapel
@SpringBootApplicationPonto de entrada da aplicação
@ComponentBean genérico
@ServiceCamada de serviço (lógica de negócio)
@RepositoryCamada de dados (acesso ao banco)
@ControllerController MVC
@RestControllerController REST
@AutowiredInjeção de dependência
@QualifierEscolha do bean a ser injetado
@ValueInjeção de valor de configuração
@ConfigurationClasse de configuração
@BeanDeclaração manual de bean
@ConfigurationPropertiesBinding de propriedades
@ProfileAtivação por profile
@PostConstructInicialização após injeção
@PreDestroyLimpeza antes da destruição

➡️ Capítulo 2: Anotações Web e REST

⬅️ Voltar ao Módulo 17