Como pode aplicar a injeção de dependências usando…

O contêiner IoC do Spring gere o ciclo de vida do Spring Bean (objetos). Os Beans são os principais blocos de construção das aplicações Spring. A injeção de dependências (DI) usando Beans do Spring é realizada através de configuração que indica ao contêiner como criar e ligar componentes.

Existem três formas principais de injetar dependências no Spring:

Injeção por construtor: O Spring chama o construtor correspondente da classe ao criar o Bean. É o método preferido, pois garante que todas as dependências necessárias sejam inicializadas ao criar o objeto e permite tornar as dependências imutáveis.
Injeção por setter: O Spring chama os métodos setters da classe para definir dependências após criar o Bean. Este método é útil para dependências opcionais.
Injeção por campo: O Spring usa reflexão para injetar diretamente dependências nos campos da classe. Não recomendado, pois dificulta os testes e viola a encapsulação.

A configuração para a injeção de dependências pode ser realizada através de:

Anotações: @Autowired, @Qualifier, @Value. Abordagem mais comum em aplicações Spring modernas.

// Exemplo de injeção por construtor com anotação
@Component // Torna a classe um Bean do Spring
public class MyService {

    private final MyDependency dependency;

    @Autowired // Indica ao Spring para injetar a dependência via construtor
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class MyDependency {
    // ...
}

// Exemplo de injeção por setter com anotação
@Component
public class AnotherService {

    private AnotherDependency dependency;

    @Autowired // Indica ao Spring para injetar a dependência via setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class AnotherDependency {
    // ...
}

// Exemplo de injeção por campo com anotação (não recomendado)
@Component
public class FieldInjectedService {

    @Autowired // Indica ao Spring para injetar a dependência no campo
    private FinalDependency dependency;

    // ...
}

@Component
public class FinalDependency {
    // ...
}

Configuração XML: Usada em projetos mais antigos ou específicos.

<!-- Exemplo de injeção por construtor em XML -->
<beans>
    <bean id="myDependency" class="com.example.MyDependency"/>

    <bean id="myService" class="com.example.MyService">
        <constructor-arg ref="myDependency"/>
    </bean>
</beans>

<!-- Exemplo de injeção por setter em XML -->
<beans>
    <bean id="anotherDependency" class="com.example.AnotherDependency"/>

    <bean id="anotherService" class="com.example.AnotherService">
        <property name="dependency" ref="anotherDependency"/>
    </bean>
</beans>

Configuração Java (usando @Configuration e @Bean): Abordagem moderna que permite configurar o contêiner Spring usando código Java.

// Exemplo de configuração Java
@Configuration // Indica que esta é uma classe de configuração
public class AppConfig {

    @Bean // Declara o Bean myDependency
    public MyDependency myDependency() {
        return new MyDependency();
    }

    @Bean // Declara o Bean myService
    public MyService myService(MyDependency myDependency) {
        // Injeção via construtor ao criar o Bean
        return new MyService(myDependency);
    }
}

O contêiner IoC do Spring escaneia a configuração (anotações, XML, classes Java), cria instâncias de Beans, gerencia seu ciclo de vida e injeta dependências automaticamente. Isso reduz o acoplamento dos componentes, facilita os testes (é fácil substituir dependências por objetos mock) e torna o código mais fácil de manter.

Como pode aplicar a injeção de dependências usando Spring Bean?