Como funciona o Spring Framework por baixo do capô?

O Spring Framework funciona usando vários princípios e mecanismos-chave:

1. Inversão de controlo (Inversion of Control - IoC):

   • O contêiner Spring (o mais comum - ApplicationContext) gere o ciclo de vida dos objetos (beans).
   • Em vez de os objetos criarem as suas próprias dependências, eles declaram essas dependências e o contêiner as injeta (Injeção de Dependências - DI).
   • Isto é conseguido através de:
     • Configuração: XML, anotações (@Autowired, @Inject), JavaConfig (@Configuration, @Bean).
     • Reflexão: O Spring escaneia classes, anotações e metainformação para determinar os beans e as suas dependências.

2. Programação orientada a aspetos (Aspect-Oriented Programming - AOP):

   • Permite modularizar preocupações transversais (como logging, segurança, gestão de transações).
   • Essas preocupações são implementadas na forma de aspectos, que podem ser aplicados a diferentes pontos de corte na execução da aplicação.
   • O Spring AOP usa proxies (JDK Dynamic Proxies ou CGLIB) para interceptar chamadas de métodos e aplicar aspetos.
   • É aplicado em tempo de execução (weaving em tempo de execução).

3. Abstração:

   • O Spring fornece abstrações de alto nível sobre APIs de baixo nível, simplificando o desenvolvimento. Exemplos:
     • Gestão de transações (PlatformTransactionManager) abstrai diferentes implementações (JTA, JDBC, JPA).
     • Acesso a dados (JDBC, JPA/Hibernate) fornece modelos simplificados (JdbcTemplate, JpaTemplate) e tratamento de exceções.
     • O framework MVC abstrai o tratamento de pedidos HTTP.

4. Contêiner Spring (ApplicationContext):

   • Componente principal que gere os beans.
   • Escaneia classes, lê metainformação (configuração), cria, configura e gere o ciclo de vida dos beans.
   • Regista definições de beans e cria instâncias de beans sob demanda ou na inicialização (dependendo do âmbito e da inicialização preguiçosa).
   • Executa Injeção de Dependências.
   • Fornece serviços como localização, publicação de eventos, carregamento de recursos.

5. Reflexão:

   • É amplamente usada para:
     • Escanear o classpath em busca de classes com anotações (@Component, @Service, @Repository, @Controller).
     • Ler metainformação de anotações (@Autowired, @Value, @Transactional).
     • Obter construtores e métodos para criar instâncias de beans e injetar dependências.
     • Criar proxies dinâmicos para AOP.

6. Ciclo de vida do bean:

   • O contêiner Spring gere o ciclo de vida do bean, que inclui:
     • Criação da instância.
     • Injeção de dependências.
     • Execução de BeanNameAware, BeanFactoryAware, ApplicationContextAware.
     • Execução de BeanPostProcessor (método postProcessBeforeInitialization).
     • Execução de @PostConstruct ou afterPropertiesSet.
     • Execução do método de inicialização especificado em @Bean ou XML.
     • Uso do bean.
     • Execução de BeanPostProcessor (método postProcessAfterInitialization).
     • Execução de @PreDestroy ou destroyableBean.
     • Execução do método de destruição especificado em @Bean ou XML.

// Exemplo de uso da anotação @Autowired para injeção de dependências
@Component // Bean gerido pelo Spring
public class OrderService {

    private final ProductRepository productRepository; // Dependência

    @Autowired // Spring irá injetar aqui uma instância de ProductRepository
    public OrderService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    // ... métodos do serviço
}

// Exemplo de uso da anotação @Aspect para AOP
@Aspect // Esta classe é um aspeto
@Component
public class LoggingAspect {

    // Ponto de corte: execução de qualquer método em qualquer classe no pacote com.example.service
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}

    // Conselho: antes da execução do método no ponto de corte serviceLayer
    @Before("serviceLayer()")
    public void logMethodCall(JoinPoint joinPoint) {
        System.out.println("Chamada do método: " + joinPoint.getSignature().getName());
    }
}

O Spring atua como uma estrutura que gere a estrutura e execução da aplicação, usando IoC, DI e AOP para garantir modularidade, testabilidade e facilidade de manutenção do código. Ele abstrai muitas complexidades do Java EE e outras tecnologias.