@Controller

Define uma classe como um componente controlador no ecossistema Spring MVC, responsável por processar requisições web e retornar respostas, geralmente resolvendo uma visualização (view).

@Controller
public class InventoryController {
    
    @GetMapping("/inventory/list")
    public String displayInventory(Model model) {
        model.addAttribute("items", inventoryService.getAll());
        return "inventory-view";
    }
}

@RestController

Introduzido no Spring 4, é uma anotação de conveniência que combina @Controller e @ResponseBody. Indica que o retorno dos métodos deve ser serializado diretamente para o corpo da resposta HTTP (em formatos como JSON ou XML), ideal para a construção de APIs RESTful.

@RestController
@RequestMapping("/api/v1/orders")
public class OrderApiController {
    
    @GetMapping("/{id}")
    public OrderResponse fetchOrderDetails(@PathVariable Long id) {
        return orderService.findById(id);
    }
}

@Service

É uma especialização da anotação @Component destinada à camada de lógica de negócios. Permite que o contêiner IoC (Inversão de Controle) descubra e gerencie a classe automaticamente.

@Service
public class BillingService {
    
    public Invoice generateInvoice(Long clientId) {
        return new Invoice(clientId, 150.00);
    }
}

@Autowired

Responsável pela injeção de dependências automática baseada no tipo (byType). Pode ser aplicada em construtores, campos ou métodos. O atributo required controla se a dependência é estritamente obrigatória ou se aceita valores nulos.

@RestController
public class ReportController {

    private final AnalyticsService analytics;

    @Autowired(required = false)
    private ExportService exporter;

    public ReportController(AnalyticsService analytics) {
        this.analytics = analytics;
    }
}

@RequestMapping

Mapeia requisições HTTP para métodos manipuladores específicos. Pode ser aplicada no nível da classe para definir um caminho base, e no nível do método para rotas detalhadas.

@RestController
@RequestMapping("/users")
public class UserEndpoint {

    @RequestMapping(value = "/profile", method = RequestMethod.GET)
    public UserProfile getProfile() {
        return new UserProfile("admin");
    }
}

@RequestParam

Extrai parâmetros da query string de uma requisição HTTP e os vincula diretamente aos argumentos de um método no controlador.

@GetMapping("/search")
public List<item> searchItems(
        @RequestParam(value = "keyword", defaultValue = "all") String query,
        @RequestParam("limit") int maxResults) {
    return searchEngine.find(query, maxResults);
}
</item>

@NonNull e @Nullable

Anotações semânticas utilizadas para validação e clareza de nulos. @NonNull indica que um parâmetro, campo ou retorno não deve aceitar valores nulos, enquanto @Nullable declara explicitamente que valores nulos são permitidos e esperados em certos cenários.

public class EmployeeRecord {
    
    @NonNull
    private String employeeId;
    
    @Nullable
    private String department;

    public void setDepartment(@Nullable String dept) {
        this.department = dept;
    }
}

@Resource

Originária da especificação JSR-250. Diferente do @Autowired, que prioriza a injeção por tipo, o @Resource realiza a injeção primordialmente pelo nome do bean (byName). Se o nome não for especificado ou encontrado, ele recua para a injeção por tipo.

@Component
public class NotificationDispatcher {

    @Resource(name = "emailSender")
    private MessageSender primarySender;

    @Resource(type = SmsSender.class)
    private MessageSender fallbackSender;
}

@Qualifier

Utilizada em conjunto com @Autowired para resolver ambiguidades quando existem múltiplas implementações de uma mesma interface registradas no contexto Spring.

public interface PaymentGateway {}

@Service("paypalGateway")
public class PayPalGateway implements PaymentGateway {}

@Service("stripeGateway")
public class StripeGateway implements PaymentGateway {}

// Injeção de uma implementação específica
@Autowired
@Qualifier("stripeGateway")
private PaymentGateway selectedGateway;

@Component

Anotação genérica para marcar qualquer classe gerenciada pelo Spring. Atua como a base para estereótipos mais específicos e é usada quando a classe não se encaixa nas categorias de controlador, serviço ou repositório.

@Component
public class StringSanitizer {
    
    public String clean(String input) {
        return input.trim().toLowerCase();
    }
}

@Repository

Indica que a classe atua como um repositório de dados (DAO). Além de registrar o bean, esta anotação habilita a tradução automática de exceções nativas de persistência (como SQLException) para a hierarquia de exceções não verificadas (DataAccessException) do Spring.

public interface AccountRepository {
    void persist(Account account);
}

@Repository("jpaAccountRepo")
public class JpaAccountRepository implements AccountRepository {
    
    @Override
    public void persist(Account account) {
        // Lógica de persistência com JPA
    }
}

@Scope

Define o ciclo de vida e a visibilidade de um bean no contêiner IoC. Os escopos mais comuns incluem singleton (uma única instância por contêiner, padrão do Spring) e prototype (nova instância a cada injeção). Em aplicações web, também existem os escopos request, session e application.

@Component
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class RequestTask {
    private UUID taskId = UUID.randomUUID();
    // Cada injeção receberá um RequestTask com um taskId diferente
}

@Bean

Utilizada em métodos dentro de classes anotadas com @Configuration. Endica que o método produz um objeto que deve ser registrado, configurado e gerenciado como um bean pelo contêiner Spring.

@Configuration
public class InfrastructureConfig {

    @Bean(initMethod = "connect", destroyMethod = "disconnect")
    public DatabaseClient databaseClient() {
        return new DatabaseClient("jdbc:mysql://localhost:3306/db");
    }
}

@Transactional

Habilita o gerenciamento de transações declarativas. Quando aplicada, o Spring cria um proxy que inicia uma transação antes da execução do método e realiza o commit ao final, ou um rlolback caso ocorram exceções especificadas.

@Service
public class BankService {

    @Transactional(
        propagation = Propagation.REQUIRES_NEW, 
        isolation = Isolation.READ_COMMITTED,
        rollbackFor = InsufficientFundsException.class
    )
    public void transferFunds(Account from, Account to, BigDecimal amount) {
        // Lógica de transferência
    }
}

Anotações de AOP (Programação Orientada a Aspectos)

O Spring AOP permite separar preocupações transversais (cross-cutting concerns), como logs, auditoria e monitoramento, da lógica principal da aplicação.

@Aspect: Declara uma classe como um aspecto, contendo conselhos e pontos de corte.

@Pointcut: Define uma expressão que determina os pontos exatos onde os conselhos devem ser interceptados.

@Before: Executa o código antes que o método alvo seja invocado.

@AfterReturning: Executa após o método alvo retornar com sucesso, permitindo acesso ao valor retornado.

@Around: Envolve completamente a execução do método alvo. Pode controlar se o método será executado, modifiacr argumentos ou alterar o retorno.

@AfterThrowing: Disparado apenas se o método alvo lançar uma exceção.

@After: Executa independentemente do resultado do método alvo (sucesso ou falha), atuando como um bloco finally.

@Aspect
@Component
public class PerformanceMonitorAspect {

    @Pointcut("execution(* com.ecommerce.services.*.*(..))")
    public void serviceLayerExecution() {}

    @Before("serviceLayerExecution()")
    public void logMethodEntry(JoinPoint joinPoint) {
        System.out.println("Iniciando: " + joinPoint.getSignature().getName());
    }

    @AfterReturning(pointcut = "serviceLayerExecution()", returning = "result")
    public void logSuccess(JoinPoint joinPoint, Object result) {
        System.out.println("Sucesso em: " + joinPoint.getSignature().getName());
    }

    @Around("serviceLayerExecution()")
    public Object measureExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = joinPoint.proceed();
        long duration = System.currentTimeMillis() - start;
        System.out.println("Tempo de execução: " + duration + "ms");
        return proceed;
    }

    @AfterThrowing(pointcut = "serviceLayerExecution()", throwing = "error")
    public void logExceptions(JoinPoint joinPoint, Throwable error) {
        System.err.println("Erro em " + joinPoint.getSignature().getName() + ": " + error.getMessage());
    }

    @After("serviceLayerExecution()")
    public void cleanupResources(JoinPoint joinPoint) {
        System.out.println("Finalizando execução do método.");
    }
}

@Cacheable

Indica que o resultado da invocação de um método pode ser armazenado em cache. Se o método for chamado novamente com os mesmos argumentos, o resultado é retornado diretamente do cache sem executar a lógica interna.

@Service
public class CatalogService {
    
    @Cacheable(value = "products", key = "#sku")
    public ProductDetails getProductBySku(String sku) {
        return database.fetchProduct(sku);
    }
}

@CacheEvict

Utilizada para remover entradas do cache. É frequentemente aplicada em métodos de atualização ou exclusão para garantir a consistência dos dados armazenados.

@CacheEvict(value = "products", key = "#product.sku")
public void updateProduct(Product product) {
    database.save(product);
}

@Required

Nota: Esta anotação foi descontinuada a partir do Spring 5.1. Aplicada a métodos setter, forçava a verificação durante a configuração do contêiner para garantir que a propriedade fosse injetada explicitamente, lançando uma exceção de inicialização caso contrário.

@ModelAttribute

No Spring MVC, esta anotação é usada para vincular parâmetros de requisição a objetos de modelo ou para adicionar atributos comuns ao modelo antes da execução dos métodos mapeados. Pode ser aplicada em métodos (para popular o modelo globalmente no controlador) ou em parâmetros (para vincular dados de formulários a objetos).

@Controller
@RequestMapping("/profile")
public class ProfileController {

    @ModelAttribute("accountStatus")
    public String populateStatus() {
        return "ACTIVE"; // Disponível na view como ${accountStatus}
    }

    @PostMapping("/update")
    public String updateProfile(@ModelAttribute("userForm") UserFormData formData, Model model) {
        userService.save(formData);
        return "redirect:/profile";
    }
}