Инжектиране на зависимости през пролетта

Инжектиране на зависимости през пролетта — практическо въведение

В тази статия ще обясним на практика концепцията за инжектиране на зависимост (DI) и ще покажем как да я използвате във вашия код с Spring Framework.

Въведение

Инжектирането на зависимости е една от двете основни функционалности на Spring освен инверсията на контрола.

Правилно, Dependency Injection (DI) е прилагането на принципа на инверсия на контрола и се управлява от Контейнер за инверсия на контрол през пролетта.

Вероятно това е най-важният елемент от пролетната инфраструктура.

Принципът на хлабавото свързване

DI също е принцип, който позволява да се запази правилото за слабо свързване на програмирането.

Принципът на свободното свързване е важен в съвременните системи, защото осигурява по-добри условия за внедряване на промени в нашия софтуер.

Определение

Инжектирането на зависимости (накратко — DI) е модел на проектиране, при който обектите не инициализират своите зависимости сами, а ги приемат отвън чрез „инжектирането“.

Причината, поради която този вид начин за инициализиране на обекти е правилен, е фактът, че освен всичко друго, е по-лесно да се пишат модулни тестове.

DI е модел, който реализира принципа на IoC.

В модела DI зависимостите се инициализират от рамка, ако говорим за Spring например.

Обяснение

DI означава предаване на зависим обект по подобен начин на предаване на параметри към метод, вместо използване на метод за създаване на зависим обект.

По-долу е дадено обяснение въз основа на примерни кодове:

Традиционен подход

Ако искаме да създадем обект в клас, използваме ключова дума new:

new ConcreteImpl();

Ето пълен пример за използване на обект в друг клас:

public class Book {
    private Cover cover;

    public Book() {
        cover = new CrimeBookCover();    
    }
}

В примера по-горе, докато инициализираме, трябва да вземем решение за конкретната реализация на класа Cover.

Има възможност да имаме покритие за:

Корицата на книгата "Криминале".
Корицата на книгата на урока
Корица на детска книга

Основният недостатък на този подход е фактът, че трябва да изберем само една реализация на ниво код, така че в бъдеще ще бъде трудно да се правят промени в целия софтуер.

Не можем да предадем друго изпълнение на класа Cover (интерфейс или абстрактен клас) в конструктора. Кодът не е разхлабен! Определено е тясно свързан.

Има по-добър начин за решаване на този вид проблем.

Подход за инжектиране на зависимости

Като използваме DI, можем да променим кода във форма, където не указваме конкретната реализация на обекта Cover.

public class Book {
    private Cover cover;

    public Book(Cover cover) {
        this.cover = cover;
    }
}

В следващите параграфи ще разгледаме други начини за запазване на модела на инжектиране на зависимости.

Инжектиране на зависимост през пролетта

В тази статия се докосваме само до основните начини за предоставяне на DI през пролетта. В следващия ще представя по-широка гама от възможности, свързани с DI и Spring.

Три вида инжектиране на зависимост (DI)

В момента, използвайки контейнера на Spring, няма причина да мислим за DI, защото Spring ще го направи вместо нас по няколко прости начина.

Има три най-често срещани типа DI:

инжектиране на конструктор
метод (задаване) инжекция
инжектиране на свойство (поле).

Тези видове свързвания се изпълняват с помощта на анотация @Autowired

Инжектиране на конструктор

Ако искаме да инжектираме зависимост в конструктора, трябва да добавим анотация @Autowired над конструктора.

public class Book {
    private Cover cover;

    @Autowired
    public Book(Cover cover) {
        this.cover = cover;
    }
}

Метод (сетер) инжектиране

Ако искаме да инжектираме зависимост в сетер, трябва да добавим анотация @Autowired над метода. Инжектирането на сетер се използва рядко и не се препоръчва от създателите на Spring, но си струва да знаете, че има нещо подобно.

public class Book {
    private Cover cover;

    @Autowired
    public void setCover(Cover cover) {
        this.cover = cover;
    }
}

Инжектиране на свойства (поле).

Ако искаме да инжектираме зависимост в свойство, трябва да добавим анотация @Autowired над свойството.

public class Book {
    @Autowired
    private Cover cover;

    public Book() {}
}

Заключение

Както виждаме, DI не е толкова трудно. Надявам се, че обяснението ми беше достатъчно за разбиране (ако не — пишете ми DM или просто напишете коментар, ако да — можете да направите същото ;) ).

Най-важното нещо, което трябва да запомните, е, че най-голямото предимство на използването на DI шаблон е постигането на слабо свързан код и улесняването на тестването.

Следващата статия ще бъде свързана с Dependency Injection, но в контекста на Spring’s Beans и по-напреднали концепции.

Първоначално публикувано на https://unicodely.net.

Инжектиране на зависимости през пролетта — практическо въведение