Cum se poate aplica injecția de dependențe folosind…

Containerul IoC al Spring gestionează ciclul de viață al Spring Bean-urilor (obiecte). Beans sunt blocurile principale de construcție ale aplicațiilor Spring. Injectarea dependențelor (DI) folosind Beans Spring se realizează prin configurări care indică containerului cum să creeze și să conecteze componentele.

Există trei moduri principale de injectare a dependențelor în Spring:

Injectare prin constructor: Spring apelează constructorul corespunzător al clasei la crearea unui Bean. Aceasta este metoda preferată deoarece garantează că toate dependențele necesare sunt inițializate la crearea obiectului și permite ca dependențele să fie imuabile.
Injectare prin setter: Spring apelează metodele setter ale clasei pentru a seta dependențele după crearea Bean-ului. Această metodă este utilă pentru dependențe opționale.
Injectare prin câmp: Spring folosește reflecția pentru a injecta direct dependențele în câmpurile clasei. Nu este recomandat deoarece îngreunează testarea și încalcă încapsularea.

Configurarea pentru injectarea dependențelor poate fi realizată cu:

Anotații: @Autowired, @Qualifier, @Value. Abordarea cea mai răspândită în aplicațiile moderne Spring.

// Exemplu de injectare prin constructor cu anotație
@Component // Transformăm clasa în Bean Spring
public class MyService {

    private final MyDependency dependency;

    @Autowired // Indică Spring să injecteze dependența prin constructor
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

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

// Exemplu de injectare prin setter cu anotație
@Component
public class AnotherService {

    private AnotherDependency dependency;

    @Autowired // Spring injectează dependența prin setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

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

// Exemplu de injectare prin câmp cu anotație (nu recomandat)
@Component
public class FieldInjectedService {

    @Autowired // Spring injectează dependența direct în câmp
    private FinalDependency dependency;

    // ...
}

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

Configurație XML: Folosită în proiecte mai vechi sau specifice.

<!-- Exemplu de injectare prin constructor în XML -->
<beans>
    <bean id="myDependency" class="com.example.MyDependency"/>

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

<!-- Exemplu de injectare prin setter în XML -->
<beans>
    <bean id="anotherDependency" class="com.example.AnotherDependency"/>

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

Configurație Java (@Configuration și @Bean): Abordare modernă care permite configurarea containerului Spring cu ajutorul codului Java.

// Exemplu de configurație Java
@Configuration // Indică faptul că este o clasă de configurație
public class AppConfig {

    @Bean // Declară Bean-ul myDependency
    public MyDependency myDependency() {
        return new MyDependency();
    }

    @Bean // Declară Bean-ul myService
    public MyService myService(MyDependency myDependency) {
        // Injectare prin constructor la crearea Bean-ului
        return new MyService(myDependency);
    }
}

Containerul IoC al Spring scanează configurația (anotații, XML, clase Java), creează instanțe ale Bean-urilor, gestionează ciclul lor de viață și realizează automat injectarea dependențelor. Acest lucru reduce cuplajul componentelor, facilitează testarea (poți înlocui cu ușurință dependențele cu obiecte mock) și face codul mai ușor de întreținut.

Cum se poate aplica injecția de dependențe folosind Spring Bean?