Что такое инъекция зависимостей и инверсия управления в Spring Framework?

Я запишу свое простое понимание этих двух терминов:

For quick understanding just read examples*

инъекция зависимостей (DI):
Инъекция зависимостей обычно означает передача зависимого объекта в качестве параметра в метод, вместо того, чтобы метод создавал зависимый объект.
на практике это означает, что метод не имеет прямой зависимости от конкретной реализации; любая реализация, которая соответствует требования могут быть переданы в качестве параметра.

С этим объекты говорят свои зависимости. И весна делает его доступным.
это приводит к слабосвязанной разработки приложений.

Quick Example:EMPLOYEE OBJECT WHEN CREATED,IT WILL AUTOMATICALLY CREATE ADDRESS OBJECT (if address is defines as dependency by Employee object)*.<br>

инверсия контейнера управления(IoC):
Это общая характеристика основ, МОК управляет объектами java
- от создания экземпляра к уничтожению через его BeanFactory.
-компоненты Java, которые экземпляры контейнера IoC называются бобами, а контейнер IoC управляет областью действия компонента, событиями жизненного цикла и любыми функциями AOP для которого он был настроен и закодированы.

QUICK EXAMPLE:Inversion of Control is about getting freedom, more flexibility, and less dependency. When you are using a desktop computer, you are slaved (or say, controlled). You have to sit before a screen and look at it. Using keyboard to type and using mouse to navigate. And a bad written software can slave you even more. If you replaced your desktop with a laptop, then you somewhat inverted control. You can easily take it and move around. So now you can control where you are with your computer, instead of computer controlling it.

реализуя инверсию управления, потребитель программного обеспечения/объекта получает больше элементов управления/опций над программным обеспечением / объектами, вместо того, чтобы управляться или иметь меньше опций.

инверсия управления в качестве руководства по проектированию служит следующим целям:

происходит отделение выполнения определенной задачи от реализации.
Каждый модуль может сосредоточиться на том, для чего он предназначен.
Модули не делают никаких предположений о том, что делают другие системы, но полагаются на свои контракты.
Замена модулей не имеет побочных эффектов на другие модули
я буду держать вещи аннотация здесь, вы можете посетить следующие ссылки для детального понимания темы.
хороший читайте с примером

подробное объяснение

Spring: Spring-это контейнер "инверсия управления" для платформы Java.

инверсия управления (IoC): инверсия управления (IoC)-это объектно-ориентированная практика программирования, при которой объектная связь ограничена во время выполнения объектом "ассемблера" и обычно не может быть познана во время компиляции с использованием статического анализа.

Dependency Injection (DI): "Dependency injection-это шаблон разработки программного обеспечения, который позволяет удалять жестко закодированные зависимости и делает можно изменить их, будь то во время выполнения или во время компиляции." -вики.

в Spring объекты слабо связаны, т. е. каждый класс независим друг от друга, так что все может быть проверено индивидуально. Но при использовании этих классов, класс может зависеть от других классов, которые должны быть созданы в первую очередь. Итак, мы говорим spring, что класс A зависит от класса B. Поэтому при создании bean(например, класса) для класса A он создает экземпляр класса B до класса A и вводит его в класс A, используя методы setter или constructor DI. То есть, мы рассказываем весна зависимость во время выполнения. Это Ди. Поскольку мы возлагаем ответственность за создание объектов (бобов), поддержание их и их агрегаций на Spring вместо жесткого кодирования, мы называем это инверсией управления(IOC).

инверсия управления (IOC):

МОК - это шаблон проектирования, который описывает инвертирование потока управления в системе, поэтому поток выполнения не контролируется центральной части кода. Это означает, что компоненты должны зависеть только от абстракций других компонентов и не несет ответственность за обработку создания зависимых объектов. Вместо этого, экземпляры объектов предоставляются во время выполнения с помощью IOC-контейнером через внедрение зависимостей (ДИ.)

IoC обеспечивает лучший дизайн программного обеспечения, который облегчает повторное использование, свободное соединение и простое тестирование программных компонентов.

инъекция зависимостей (DI):

DI - это метод передачи зависимостей в конструктор объекта. Если объект был загружен из контейнера, то его зависимости будут автоматически предоставлены контейнером. Это позволяет использовать зависимость без необходимости вручную создание экземпляра. Это уменьшает связь и дает вам больший контроль над временем жизни экземпляров объекта.

нажмите, чтобы посмотреть больше

IoC-контейнер

---

контейнер IoC отвечает за создание экземпляров, настройку и сборку объектов. Контейнер IoC получает информацию из XML-файла и работает соответственно. Основными задачами, выполняемыми контейнером IoC, являются:

• для создания экземпляра класса приложения
• настройки объекта

• для сборки зависимостей между объектами Существует два типа контейнеров МОК. Они являются:

• BeanFactory

• ApplicationContext

инъекция зависимостей (DI)

Dependency Injection (DI) - это шаблон проектирования, который удаляет зависимость из программного кода, чтобы было легко управлять и тестировать приложение. Инъекция зависимостей делает наш программный код слабо связанным.

Spring framework предоставляет два способа введения зависимость

• Конструктор
• по сеттера

инверсия управления- Это означает предоставление контроля над созданием и созданием экземпляров spring beans контейнеру Spring IOC, и единственная работа, которую выполняет разработчик, - это настройка компонентов в файле spring xml.

инъекции зависимостей-

рассмотрим класс сотрудника

class Employee { 
   private int id;
   private String name;
   private Address address;

   Employee() {
     id = 10;
     name="name";
     address = new Address();
   }


}

и рассмотрим адрес класса

class Address {
   private String street;
   private String city;

   Address() {
     street="test";
     city="test1";

  }
}

в приведенном выше коде значения класса адреса будут установлены только при создании экземпляра класса Employee, который является зависимость класса адреса от класса сотрудника. И spring решает эту проблему, используя концепцию инъекции зависимостей, предоставляя два способа введения этой зависимости.

1. сеттер инъекций

метод Setter в классе Employee, который принимает ссылку на класс Address

public void setAddress(Address addr) {
    this.address = addr;
}

1. конструктор инъекций

конструктор в классе Employee, который принимает адрес

Employee(Address addr) {
      this.address = addr;
}

таким образом адрес значения класса могут быть установлены независимо с помощью инъекции setter/constructor.

традиционным способом получения экземпляра адреса в Employee было бы создание нового экземпляра класса Address.Весна создает все зависимые от нас объекты, поэтому нам не нужно беспокоиться об объекте.

поэтому весной мы просто зависим от контейнера spring, который предоставляет нам объект зависимости.

инверсия управления-это общий принцип проектирования архитектуры программного обеспечения, который помогает создавать многоразовые модульные программные платформы, которые просты в обслуживании.

это принцип проектирования, в котором поток управления "получен" из универсальной библиотеки или многоразового кода.

чтобы понять это лучше, давайте посмотрим, как мы использовали код в наши ранние дни кодирования. В процедурных / традиционных языках бизнес-логика обычно управляет потоком приложения и "вызывает" общий или многоразовый код/функции. Например, в простом консольном приложении Мой поток управления управляется инструкциями моей программы, которые могут включать вызовы некоторых общих многоразовых функций.

print ("Please enter your name:");
scan (&name);
print ("Please enter your DOB:");
scan (&dob);

//More print and scan statements
<Do Something Interesting>

//Call a Library function to find the age (common code)
print Age

В отличие от IoC, фреймворки-это многоразовый код, который "вызывает" бизнес-логику.

например, в системе на базе windows, платформа уже будет доступна для создания элементов пользовательского интерфейса, таких как кнопки, меню, окна и диалоговые окна. Когда я пишу бизнес-логику своего приложения, это будут события framework, которые будут вызывать мой код бизнес-логики (когда событие запускается), а не наоборот.

хотя код фреймворка не знает о моей бизнес-логике, он все равно будет знать, как вызвать мой код. Это достигается с помощью событий/делегатов, обратные вызовы и т. д. Здесь управление потоком "перевернуто".

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

Dependency Injection-это шаблон проектирования, реализующий принцип IoC для разрешения зависимостей объектов.

проще говоря, когда вы пытаетесь написать код, вы будете создавать и использовать различные классы. Один класс (класс A) может использовать другие классы (класс B и/или D). Итак, класс B и D являются зависимостями класса A.

простая аналогия будет классный автомобиль. Автомобиль может зависеть от других классов, таких как двигатель, Шины и многое другое.

инъекция зависимостей предполагает, что вместо зависимых классов (класс Car здесь), создающих свои зависимости (класс Engine и класс Tyre), класс должен быть введен с конкретным экземпляром зависимости.

давайте разберемся с более практическим примером. Считайте, что вы пишете свой собственный текстовый редактор. Среди прочего, вы можете иметь проверку орфографии, которая обеспечивает пользователь с возможностью проверить опечатки в его тексте. Простой реализацией такого кода может быть:

Class TextEditor
{

    //Lot of rocket science to create the Editor goes here

    EnglishSpellChecker objSpellCheck;
    String text;

    public void TextEditor()

    {   

        objSpellCheck = new EnglishSpellChecker();

    }

    public ArrayList <typos> CheckSpellings()
    {

        //return Typos;

    }

}

на первый взгляд, все выглядит радужно. Пользователь будет писать некоторый текст. Разработчик захватит текст и вызовет функцию CheckSpellings и найдет список опечаток, которые он покажет пользователю.

все, кажется, работает отлично, пока в один прекрасный день, когда один пользователь начинает писать французский язык в Редакторе.

обеспечить поддержку для более языки, нам нужно больше проверяющих орфографию. Вероятно, французский, немецкий, испанский и т. д.

здесь мы создали тесно связанный код с"английским" средством проверки орфографии, тесно связанным с нашим классом TextEditor, что означает, что наш класс TextEditor зависит от английского средства проверки орфографии или, другими словами, EnglishSpellCheker является зависимостью для TextEditor. Нам нужно устранить эту зависимость. Кроме того, наш текстовый редактор нуждается в способе хранения конкретной ссылки на любую проверку орфографии на основе на усмотрение разработчика во время выполнения.

Итак, как мы видели во введении DI, он предполагает, что класс должен быть введен с его зависимостями. Таким образом, ответственность за внедрение всех зависимостей в вызываемый класс/код должна лежать на вызывающем коде. Поэтому мы можем реструктурировать наш код как

interface ISpellChecker
{

    Arraylist<typos> CheckSpelling(string Text);

}

Class EnglishSpellChecker : ISpellChecker

{

    public override Arraylist<typos> CheckSpelling(string Text)

    {

        //All Magic goes here.

    }

}



Class FrenchSpellChecker : ISpellChecker

{

    public override Arraylist<typos> CheckSpelling(string Text)

    {

        //All Magic goes here.

    }

}

в нашем примере класс TextEditor должен получить конкретный экземпляр типа ISpellChecker.

теперь, зависимость можно впрыснуть внутри Конструктор, публичное свойство или метод.

давайте попробуем изменить наш класс с помощью конструктора DI. Измененный класс TextEditor будет выглядеть примерно так:

Class TextEditor

{

    ISpellChecker objSpellChecker;

    string Text;



    public void TextEditor(ISpellChecker objSC)

    {

        objSpellChecker = objSC;

    }



    public ArrayList <typos> CheckSpellings()

    {

        return objSpellChecker.CheckSpelling();

    }

}

чтобы вызывающий код при создании текстового редактора мог ввести соответствующий тип проверки орфографии в экземпляр TextEditor.

вы можете прочитать полную статью здесь