Inversão de Controle (IoC) e Injeção de Dependência (DI) são dois conceitos fundamentais no Spring Framework. Tradicionalmente, os objetos são responsáveis ​​por criar e gerenciar suas próprias dependências. No entanto, a IoC inverte essa responsabilidade ao entregar o controle da criação de objetos e do gerenciamento de dependências para uma estrutura como o Spring.

Essa mudança oferece diversas vantagens:

• Troca de implementação mais fácil: Diferentes implementações podem ser trocadas com alterações mínimas na base de código.
• Maior Modularidade: Os componentes do aplicativo tornam-se mais modulares, facilitando a separação de interesses.
• Testabilidade aprimorada: os componentes podem ser testados isoladamente, o que simplifica a zombaria e outras estratégias de teste.

IoC pode ser implementado por meio de vários mecanismos, incluindo padrões de design como Factory Pattern, Strategy Pattern ou Service Locator Pattern. No entanto, a maneira mais comum e poderosa de obter IoC é por meio da injeção de dependência.

Compreendendo a injeção de dependência

Injeção de dependência (DI) é uma técnica em que a estrutura injeta dependências em um objeto, em vez de o próprio objeto criar as dependências. Existem diferentes tipos de DI no Spring:

• Injeção de Construtor: As dependências são fornecidas através do construtor da classe.
• Injeção de Setter: As dependências são injetadas por meio de métodos setter.
• Injeção de campo: as dependências são atribuídas diretamente aos campos usando anotações.

Por exemplo, em uma classe de serviço simples, você pode ver algo assim:

@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void processOrder(Order order) {
        paymentService.processPayment(order.getPaymentDetails());
    }
}

Aqui, PaymentService é injetado em OrderService por meio de injeção de construtor, que geralmente é preferido por suas dependências claras e facilidade de teste.

Contêiner IoC: BeanFactory vs.

Spring fornece um contêiner IoC responsável por gerenciar o ciclo de vida dos beans (objetos gerenciados pelo Spring). A interface básica para este contêiner é BeanFactory. No entanto, a maioria dos aplicativos usa ApplicationContext, que estende o BeanFactory e oferece recursos adicionais.

Fábrica de feijão

• Contêiner IoC básico: Fornece funcionalidades básicas para criar e gerenciar beans.
• Inicialização lenta: Beans são criados quando são solicitados pela primeira vez.

ApplicationContext

• Contêiner IoC avançado: Além dos recursos básicos do BeanFactory, ele fornece:
  • Suporte à internacionalização (i18n)
  • Propagação e tratamento de eventos
  • Tratamento de solicitação assíncrona
  • Integração com Programação Orientada a Aspectos (AOP)
• Eager Initialization: Beans podem ser instanciados quando a aplicação é iniciada, tornando-os disponíveis para uso imediato.

Exemplo:

// Getting a bean from the ApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MyBean myBean = context.getBean(MyBean.class);

Neste exemplo, ApplicationContext é usado para recuperar um bean. Se você estivesse usando um BeanFactory básico, ele ofereceria funcionalidade semelhante, mas sem os benefícios adicionais do ApplicationContext.

Acessando o ApplicationContext

Existem duas maneiras comuns de acessar o ApplicationContext atual:

1. Autowired: injete o ApplicationContext diretamente em seu componente.
   

   @Autowired
   private ApplicationContext applicationContext;
   

2. ApplicationContextAware: implemente a interface ApplicationContextAware, que permite recuperar o ApplicationContext conforme necessário.
   

   public class MyBean implements ApplicationContextAware {
       private ApplicationContext applicationContext;
   
       @Override
       public void setApplicationContext(ApplicationContext context) throws BeansException {
           this.applicationContext = context;
       }
   }
   

Ciclo de vida de um aplicativo Spring

Quando um aplicativo Spring é iniciado, uma série de etapas ocorre:

1. Processando variáveis ​​e propriedades de ambiente: O objeto Environment é criado, incorporando configurações de application.properties ou application.yml.

2. Criando o ApplicationContext: O tipo ApplicationContext apropriado é determinado e instanciado. Por exemplo, um aplicativo Spring Boot pode usar AnnotationConfigServletWebServerApplicationContext para configurações baseadas em Java.

3. Carregando definições de bean: Spring carrega definições de bean de várias fontes, como classes anotadas, classes @Configuration ou arquivos XML. Cada definição de bean inclui informações sobre o tipo, escopo, dependências e retornos de chamada do ciclo de vida do bean.

4. Processing BeanFactoryPostProcessors: Esses processadores modificam as definições de bean antes que os beans reais sejam criados.

5. Resolução de Dependências e Criação de Beans: O ApplicationContext resolve dependências e cria os beans. Se um bean tiver dependências de outros beans, essas dependências serão criadas primeiro.

Escopos de feijão na primavera

Spring oferece suporte a vários escopos de bean, que definem o ciclo de vida e a visibilidade de um bean dentro do contêiner:

• Singleton (padrão): Uma única instância do bean é criada para todo o contexto do aplicativo.
• Protótipo: Uma nova instância é criada toda vez que o bean é solicitado.
• Request: Uma nova instância de bean é criada para cada solicitação HTTP (aplicativos web).
• Sessão: Uma nova instância de bean é criada para cada sessão HTTP (aplicativos web).

Exemplo:

@Bean
@Scope("prototype")
public MyPrototypeBean myPrototypeBean() {
    return new MyPrototypeBean();
}

Neste exemplo, uma nova instância MyPrototypeBean é criada cada vez que é solicitada do contêiner.

Objetos proxy em escopos de bean

Considere um cenário em que um bean com escopo Singleton depende de um bean com escopo Prototype. Normalmente, o bean protótipo seria criado apenas uma vez durante a inicialização do singleton. Para garantir que uma nova instância do bean protótipo seja fornecida a cada vez, o Spring usa objetos proxy.

Exemplo com proxies:

@Component
@Scope(value = "singleton")
public class SingletonBean {

    @Autowired
    @Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
    private PrototypeBean prototypeBean;

    public void showMessage() {
        System.out.println(prototypeBean.getMessage());
    }
}

Aqui, ScopedProxyMode.TARGET_CLASS garante que uma nova instância PrototypeBean seja retornada cada vez que getMessage() for chamado.

Diferença entre Spring Framework e Spring Boot

Spring Boot é uma extensão do Spring Framework que simplifica a configuração e o desenvolvimento de novos aplicativos Spring. Ele fornece:

• Servidores de aplicativos incorporados: execute facilmente aplicativos Spring como aplicativos independentes com Tomcat, Jetty ou Undertow incorporados.
• Configuração automática: configura beans automaticamente com base no caminho de classe e outras configurações.
• Embalagem Simplificada: Empacota aplicativos como JARs ou WARs executáveis.
• Monitoramento integrado e verificações de integridade: endpoints integrados para monitorar a integridade e o status do aplicativo.

Configuração automática no Spring Boot

A configuração automática é um recurso poderoso do Spring Boot que configura muitas coisas para você com base nas dependências do seu caminho de classe. Isso é controlado por anotações condicionais como:

• @ConditionalOnClass
• @ConditionalOnMissingClass
• @CondicionalOnBean
• @ConditionalOnMissingBean

Exemplo:

Por exemplo, se você tiver Jackson em seu caminho de classe, o Spring Boot configurará automaticamente um ObjectMapper para serialização JSON:

@Configuration
@ConditionalOnClass(ObjectMapper.class)
public class JacksonAutoConfiguration {
    // Configuration details...
}

Se o ObjectMapper estiver presente, esta configuração será aplicada automaticamente. Caso contrário, ele será ignorado.

Visualizando configurações automáticas ativas

Você pode registrar as configurações automáticas ativas durante a inicialização adicionando o seguinte ao seu application.properties:

logging.level.org.springframework.boot.autoconfigure=DEBUG

Isso gerará um relatório detalhado mostrando quais configurações foram aplicadas e quais não foram, ajudando você a solucionar problemas ou entender a configuração do aplicativo.

Conclusão

Inversão de controle e injeção de dependência são conceitos básicos que permitem a flexibilidade, modularidade e testabilidade que tornam o Spring tão poderoso. Ao compreender como funciona o contêiner IoC do Spring, como os beans são gerenciados e como o Spring Boot estende esses recursos, você pode desenvolver aplicativos robustos e de fácil manutenção com mais eficiência.