Inversão de Controle vs Injeção de Dependência

De acordo com o artigo escrito por Martin Fowler , inversão de controle é o princípio em que o fluxo de controle de um programa é invertido: em vez de o programador controlar o fluxo de um programa, as fontes externas (estrutura, serviços, outros componentes) assumem o controle de isto. É como se conectássemos algo a outra coisa. Ele mencionou um exemplo sobre o EJB 2.0:

Por exemplo, a interface Session Bean define ejbRemove, ejbPassivate (armazenado no armazenamento secundário) e ejbActivate (restaurado do estado passivo). Você não consegue controlar quando esses métodos são chamados, exatamente o que eles fazem. O contêiner nos chama, não chamamos.

Isso leva à diferença entre estrutura e biblioteca:

Inversão de controle é uma parte essencial do que diferencia uma estrutura de uma biblioteca. Uma biblioteca é essencialmente um conjunto de funções que você pode chamar, atualmente organizado em classes. Cada chamada realiza algum trabalho e retorna o controle ao cliente.

Eu acho que, do ponto de vista de que DI é COI, significa que a dependência de um objeto é invertida: em vez de controlar suas próprias dependências, ciclo de vida ... outra coisa faz isso por você. Mas, como você me contou sobre o DI pelas mãos, ele não é necessariamente COI. Ainda podemos ter DI e nenhum COI.

No entanto, neste documento (da pococápsula, outra estrutura do IOC para C / C ++), sugere que, devido ao IOC e DI, os contêineres do IOC e as estruturas DI sejam muito mais superiores ao J2EE, pois o J2EE combina o código da estrutura nos componentes , portanto, não o torna Objeto Java / C ++ Antigo Simples (POJO / POCO).

Inversão de contêineres de controle que não sejam o padrão de injeção de dependência (link Archive)

Leitura adicional para entender qual é o problema da Estrutura de Desenvolvimento Baseada em Componentes antiga, que leva ao segundo artigo acima: Por que e o que é Inversão de Controle (link Archive)

Minha pergunta : O que exatamente são COI e DI? Estou confuso. Com base na pococápsula, o COI é algo mais significativo do que apenas a inversão do controle entre objetos ou programadores e estruturas.

IoC é um termo genérico que significa que, em vez de o aplicativo chamar os métodos em uma estrutura, a estrutura chama implementações fornecidas pelo aplicativo.

A DI é uma forma de IoC, na qual as implementações são passadas para um objeto por meio de construtores / setters / pesquisas de serviço, das quais o objeto 'dependerá' para se comportar corretamente.

IoC sem usar DI , por exemplo, seria o padrão de modelo, porque a implementação só pode ser alterada através da subclassificação.

As estruturas de DI são projetadas para usar o DI e podem definir interfaces (ou anotações em Java) para facilitar a passagem nas implementações.

IoC Containers são estruturas DI que podem funcionar fora da linguagem de programação. Em alguns casos, você pode configurar quais implementações usar nos arquivos de metadados (por exemplo, XML) que são menos invasivas. Com alguns, você pode fazer IoC que normalmente seria impossível, como injetar uma implementação em pointcuts .

Veja também este artigo de Martin Fowler .

Em resumo, IoC é um termo muito mais amplo que inclui, mas não está limitado a, DI

O termo Inversion of Control (IoC) originalmente significava qualquer tipo de estilo de programação em que uma estrutura geral ou tempo de execução controlava o fluxo do programa

Antes que a DI tivesse um nome, as pessoas começaram a se referir a estruturas que gerenciam dependências como inversão de contêineres de controle e, em breve, o significado da IoC gradualmente se deslocou para esse significado específico: Inversão do controle sobre dependências.

Inversão de controle (IoC) significa que os objetos não criam outros objetos nos quais eles confiam para realizar seu trabalho. Em vez disso, eles obtêm os objetos de que precisam de uma fonte externa (por exemplo, um arquivo de configuração xml).

Injeção de Dependência (DI) significa que isso é feito sem a intervenção do objeto, geralmente por um componente da estrutura que passa parâmetros do construtor e define propriedades.

fonte

IoC ( I nVersão o f C ontrole): - É um termo genérico e implementado de várias maneiras (eventos, delegados, etc.).

DI ( D ependency eu njection): - DI é um sub-tipo de COI e é implementado por injecção construtor, injecção incubadora ou injecção de interface .

Mas, o Spring suporta apenas os dois tipos a seguir:

• Injeção de Setter
  • O DI baseado em setter é realizado chamando métodos setter nos beans do usuário após chamar um construtor sem argumento ou método de fábrica estático sem argumento para instanciar seu bean.
• Injeção de Construtor
  • O DI baseado em construtor é realizado invocando um construtor com vários argumentos, cada um representando um colaborador.Usando isso, podemos validar que os beans injetados não são nulos e falham rapidamente (falha no tempo de compilação e não no tempo de execução), portanto ao iniciar o aplicativo, obtemos NullPointerException: bean does not exist. Injeção de construtor é uma prática recomendada para injetar dependências.

DI é um subconjunto de IoC

• IoC significa que os objetos não criam outros objetos nos quais eles confiam para fazer seu trabalho. Em vez disso, eles obtêm os objetos necessários em um serviço externo (por exemplo, arquivo xml ou serviço de aplicativo único). 2 implementações de IoC, eu uso, são DI e ServiceLocator.
• DI significa que o princípio da IoC de obter objetos dependentes é feito sem o uso de objetos concretos, mas abstrações (interfaces). Isso torna todos os componentes testáveis ​​em cadeia, porque o componente de nível superior não depende do componente de nível inferior, apenas da interface. Mocks implementam essas interfaces.

Aqui estão algumas outras técnicas para alcançar a IoC .

Como todas as respostas enfatizam a teoria, eu gostaria de demonstrar com uma primeira abordagem exemplar:

Suponha que estamos construindo um aplicativo que contém um recurso para enviar mensagens de confirmação por SMS assim que o pedido for enviado. Teremos duas classes, uma é responsável pelo envio do SMS (SMSService) e outra responsável pela captura de entradas do usuário (UIHandler); nosso código será como abaixo:

public class SMSService
{
    public void SendSMS(string mobileNumber, string body)
    {
        SendSMSUsingGateway(mobileNumber, body);
    }

    private void SendSMSUsingGateway(string mobileNumber, string body)
    {
        /*implementation for sending SMS using gateway*/
    }
}

public class UIHandler
{
    public void SendConfirmationMsg(string mobileNumber)
    {
        SMSService _SMSService = new SMSService();
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

A implementação acima não está errada, mas há alguns problemas:
-) Suponha que no ambiente de desenvolvimento, você queira salvar os SMSs enviados para um arquivo de texto em vez de usar o gateway do SMS, para conseguir isso; acabaremos alterando a implementação concreta do (SMSService) com outra implementação, estamos perdendo flexibilidade e forçados a reescrever o código nesse caso.
-) Acabaremos misturando responsabilidades de classes, nosso (UIHandler) nunca deve saber sobre a implementação concreta de (SMSService), isso deve ser feito fora das classes usando "Interfaces". Quando isso é implementado, nos permite alterar o comportamento do sistema trocando o (SMSService) usado por outro serviço simulado que implementa a mesma interface, esse serviço salvará os SMSs em um arquivo de texto em vez de enviá-los para o mobileNumber.

Para corrigir os problemas acima, usamos as Interfaces que serão implementadas pelo nosso (SMSService) e pelo novo (MockSMSService), basicamente a nova Interface (ISMSService) expõe os mesmos comportamentos de ambos os serviços que o código abaixo:

public interface ISMSService
{
    void SendSMS(string phoneNumber, string body);
}

Em seguida, alteraremos nossa implementação (SMSService) para implementar a interface (ISMSService):

public class SMSService : ISMSService
{
    public void SendSMS(string mobileNumber, string body)
    {
        SendSMSUsingGateway(mobileNumber, body);
    }

    private void SendSMSUsingGateway(string mobileNumber, string body)
    {
        /*implementation for sending SMS using gateway*/
        Console.WriteLine("Sending SMS using gateway to mobile: 
        {0}. SMS body: {1}", mobileNumber, body);
    }
}

Agora seremos capazes de criar um novo serviço de simulação (MockSMSService) com implementação totalmente diferente usando a mesma interface:

public class MockSMSService :ISMSService
{
    public void SendSMS(string phoneNumber, string body)
    {
        SaveSMSToFile(phoneNumber,body);
    }

    private void SaveSMSToFile(string mobileNumber, string body)
    {
        /*implementation for saving SMS to a file*/
        Console.WriteLine("Mocking SMS using file to mobile: 
        {0}. SMS body: {1}", mobileNumber, body);
    }
}

Neste ponto, podemos alterar o código em (UIHandler) para usar a implementação concreta do serviço (MockSMSService) facilmente como abaixo:

public class UIHandler
{
    public void SendConfirmationMsg(string mobileNumber)
    {
        ISMSService _SMSService = new MockSMSService();
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

Conseguimos muita flexibilidade e implementamos uma separação de preocupações em nosso código, mas ainda precisamos fazer uma alteração na base de código para alternar entre os dois Serviços SMS. Portanto, precisamos implementar a injeção de dependência .

Para conseguir isso, precisamos implementar uma alteração em nosso construtor de classe (UIHandler) para passar a dependência através dele, fazendo isso, o código que usa (UIHandler) pode determinar qual implementação concreta de (ISMSService) usar:

public class UIHandler
{
    private readonly ISMSService _SMSService;

    public UIHandler(ISMSService SMSService)
    {
        _SMSService = SMSService;
    }

    public void SendConfirmationMsg(string mobileNumber)
    {
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

Agora, o formulário da interface do usuário que falará com a classe (UIHandler) é responsável por transmitir qual implementação da interface (ISMSService) consumir. Isso significa que invertemos o controle, o (UIHandler) não é mais responsável por decidir qual implementação usar, o código de chamada o faz. Nós implementamos o princípio da Inversão de Controle , que DI é um tipo dele.

O código do formulário da interface do usuário será o seguinte:

class Program
{
    static void Main(string[] args)
    {
        ISMSService _SMSService = new MockSMSService(); // dependency

        UIHandler _UIHandler = new UIHandler(_SMSService);
        _UIHandler.SendConfirmationMsg("96279544480");

        Console.ReadLine();
    }
}

IOC (Inversion Of Control) : dar controle ao contêiner para obter uma instância do objeto é chamado Inversion of Control, significa que, em vez de você criar um objeto usando o novo operador, deixe o contêiner fazer isso por você.

DI (Injeção de Dependência) : A maneira de injetar propriedades em um objeto é chamada Injeção de Dependência .

Temos três tipos de injeção de dependência :

1. Injeção de Construtor
2. Injeção de Setter / Getter
3. Injeção de interface

O Spring suporta apenas Injeção de Construtor e Injeção de Setter / Getter .

Mas a documentação da primavera diz que são iguais.

http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-introduction

Na primeira linha " IoC também é conhecido como injeção de dependência (DI) ".

IoC - Inversão de controle é um termo genérico, independente da linguagem, na verdade não é criar os objetos, mas descrever em qual objeto de moda está sendo criado.

DI - Injeção de Dependência é um termo concreto, no qual fornecemos dependências do objeto em tempo de execução usando diferentes técnicas de injeção viz. Injeção de Setter, Injeção de Construtor ou Injeção de Interface.

Inversão de controle é um paradigma de design com o objetivo de dar mais controle aos componentes de destino do seu aplicativo, os que estão executando o trabalho.
Injeção de dependência é um padrão usado para criar instâncias de objetos nos quais outros objetos confiam sem saber em tempo de compilação qual classe será usada para fornecer essa funcionalidade.

Existem várias técnicas básicas para implementar a inversão de controle. Esses são:

• Usando um padrão de fábrica
  
• Usando um padrão de localizador de serviço
  
• Usando uma injeção de dependência de qualquer um dos tipos abaixo:
  
  1). Uma injeção de construtor
  2). Uma injeção de incubadora
  3). Uma injeção de interface

DI e COI são dois padrões de projeto que se concentram principalmente em fornecer acoplamentos frouxos entre componentes , ou simplesmente uma maneira pela qual dissociamos os relacionamentos de dependência convencionais entre os objetos, para que os objetos não fiquem firmes entre si.

Com os exemplos a seguir, estou tentando explicar esses dois conceitos.

Anteriormente, estamos escrevendo código como este

Public MyClass{
 DependentClass dependentObject
 /*
  At somewhere in our code we need to instantiate 
  the object with new operator  inorder to use it or perform some method.
  */ 
  dependentObject= new DependentClass();
  dependentObject.someMethod();
}

Com a injeção de dependência, o injetor de dependência cuidará da instanciação de objetos

Public MyClass{
 /* Dependency injector will instantiate object*/
 DependentClass dependentObject

 /*
  At somewhere in our code we perform some method. 
  The process of  instantiation will be handled by the dependency injector
 */ 

  dependentObject.someMethod();
}

O processo acima, de dar o controle a outro (por exemplo, o contêiner) para a instanciação e injeção, pode ser denominado Inversão de Controle e o processo no qual o contêiner do IOC injeta a dependência para nós pode ser denominado como injeção de dependência.

O COI é o princípio em que o fluxo de controle de um programa é invertido: em vez de o programador controlar o fluxo de um programa , o programa controla o fluxo reduzindo a sobrecarga para o programador. E o processo usado pelo programa para injetar dependência é denominado como DI

Os dois conceitos trabalham juntos, fornecendo uma maneira de escrever códigos muito mais flexíveis, reutilizáveis ​​e encapsulados, que os tornam conceitos importantes no design de soluções orientadas a objetos.

Também recomendo ler.

O que é injeção de dependência?

Você também pode verificar uma das minhas respostas semelhantes aqui

Diferença entre Inversão de Controle e Injeção de Dependência

Inversão de controle é um princípio genérico de design da arquitetura de software que auxilia na criação de estruturas de software modulares e reutilizáveis, fáceis de manter.

É um princípio de design no qual o fluxo de controle é "recebido" da biblioteca escrita genérica ou do código reutilizável.

Para entender melhor, vamos ver como costumávamos codificar em nossos dias anteriores de codificação. Em linguagens processuais / tradicionais, a lógica comercial geralmente controla o fluxo do aplicativo e "chama" o código / funções genéricas ou reutilizáveis. Por exemplo, em um aplicativo simples de console, meu fluxo de controle é controlado pelas instruções do meu programa, que podem incluir as chamadas para algumas funções reutilizáveis ​​gerais.

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

Em contraste, com a IoC, os Frameworks são o código reutilizável que "chama" a lógica de negócios.

Por exemplo, em um sistema baseado em janelas, uma estrutura já estará disponível para criar elementos da interface do usuário, como botões, menus, janelas e caixas de diálogo. Quando eu escrevo a lógica comercial do meu aplicativo, seriam os eventos da estrutura que chamarão o código da lógica comercial (quando um evento for disparado) e NÃO o contrário.

Embora o código da estrutura não esteja ciente da minha lógica de negócios, ele ainda saberá como chamar meu código. Isso é alcançado usando eventos / delegados, retornos de chamada etc. Aqui, o controle de fluxo é "invertido".

Portanto, em vez de depender do fluxo de controle em objetos vinculados estaticamente, o fluxo depende do gráfico geral dos objetos e das relações entre diferentes objetos.

Injeção de Dependência é um padrão de design que implementa o princípio de IoC para resolver dependências de objetos.

Em palavras mais simples, quando você estiver tentando escrever código, estará criando e usando diferentes classes. Uma classe (classe A) pode usar outras classes (classe B e / ou D). Portanto, as classes B e D são dependências da classe A.

Uma analogia simples será um carro de classe. Um carro pode depender de outras classes, como motor, pneus e muito mais.

A injeção de dependência sugere que, em vez de as classes dependentes (carro da classe aqui) criarem suas dependências (mecanismo de classe e classe pneu), a classe deve ser injetada com a instância concreta da dependência.

Vamos entender com um exemplo mais prático. Considere que você está escrevendo seu próprio TextEditor. Entre outras coisas, você pode ter um corretor ortográfico que fornece ao usuário a facilidade de verificar os erros de digitação em seu texto. Uma implementação simples desse código pode ser:

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;

    }

}

À primeira vista, tudo parece rosado. O usuário escreverá algum texto. O desenvolvedor irá capturar o texto e chamar a função CheckSpellings e encontrará uma lista de erros de digitação que ele mostrará ao usuário.

Tudo parece funcionar muito bem até um belo dia em que um usuário começa a escrever francês no Editor.

Para fornecer suporte para mais idiomas, precisamos ter mais SpellCheckers. Provavelmente francês, alemão, espanhol etc.

Aqui, criamos um código fortemente associado ao SpellChecker "inglês", fortemente associado à nossa classe TextEditor, o que significa que nossa classe TextEditor depende do EnglishSpellChecker ou, por outras palavras, EnglishSpellCheker é a dependência do TextEditor. Precisamos remover essa dependência. Além disso, nosso Editor de texto precisa de uma maneira de manter a referência concreta de qualquer corretor ortográfico com base na discrição do desenvolvedor em tempo de execução.

Portanto, como vimos na introdução do DI, isso sugere que a classe deve ser injetada com suas dependências. Portanto, deve ser responsabilidade do código de chamada injetar todas as dependências na classe / código chamado. Para que possamos reestruturar nosso código como

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.

    }

}

No nosso exemplo, a classe TextEditor deve receber a instância concreta do tipo ISpellChecker.

Agora, a dependência pode ser injetada no Construtor, em uma Propriedade Pública ou em um método.

Vamos tentar mudar nossa classe usando o Constructor DI. A classe TextEditor alterada será semelhante a:

Class TextEditor

{

    ISpellChecker objSpellChecker;

    string Text;



    public void TextEditor(ISpellChecker objSC)

    {

        objSpellChecker = objSC;

    }



    public ArrayList <typos> CheckSpellings()

    {

        return objSpellChecker.CheckSpelling();

    }

}

Para que o código de chamada, ao criar o editor de texto, possa injetar o Tipo SpellChecker apropriado na instância do Editor de Texto.

Você pode ler o artigo completo aqui

IOC (Inversion Of Control): Dar controle ao contêiner para obter a instância do objeto é chamado Inversion of Control. Isso significa que, em vez de você criar um objeto usando o novo operador , deixe o contêiner fazer isso por você.

DI (Injeção de Dependência): Passar os parâmetros (propriedades) necessários do XML para um objeto (na CLASSE POJO) é chamado de injeção de Dependência.

O COI indica que uma classe externa gerenciando as classes de um aplicativo e classes externas significa que um contêiner gerencia a dependência entre a classe do aplicativo. O conceito básico do COI é que o programador não precisa criar seus objetos, mas descreve como eles devem ser criados.

As principais tarefas executadas pelo contêiner de IoC são: instanciar a classe do aplicativo. para configurar o objeto. para montar as dependências entre os objetos.

DI é o processo de fornecer as dependências de um objeto em tempo de execução usando injeção de setter ou injeção de construtor.

IOC (Inversion of Control) é basicamente o conceito de padrão de projeto de remoção de dependências e desacoplamento para tornar o fluxo não linear, e permite que o contêiner / ou outra entidade gerencie o provisionamento de dependências. Na verdade, segue o diretor de Hollywood "Não ligue para nós, nós ligaremos para você". Então, resumindo as diferenças.

Inversão de controle: - É um termo genérico para dissociar as dependências e delegar seu provisionamento, e isso pode ser implementado de várias maneiras (eventos, delegados etc.).

Injeção de dependência: - DI é um subtipo de COI e é implementado por injeção de construtor, injeção de setter ou injeção de método.

O artigo a seguir descreve isso muito bem.

https://www.codeproject.com/Articles/592372/Dependency-Injection-DI-vs-Inversion-of-Control-IO

Eu acho que a idéia pode ser demonstrada claramente sem entrar em ervas daninhas orientadas a objetos, que parecem atrapalhar a idéia.

// dependency injection
function doSomething(dependency) {
    // do something with your dependency
}

// in contrast to creating your dependencies yourself
function doSomething() {
    dependency = getDependencySomehow()
}

// inversion of control
application = makeApp(authenticate, handleRequest, sendResponse)
application.run(getRequest())

// in contrast to direct control or a "library" style
application = makeApp()
request = application.getRequest()

if (application.authenticate(request.creds)) {
    response = application.handleRequest(request)
    application.sendResponse(response)
}

Se você inclinar a cabeça e apertar os olhos, verá que o DI é uma implementação específica da IoC com preocupações específicas. Em vez de injetar modelos e comportamentos em uma estrutura de aplicativo ou operação de ordem superior, você está injetando variáveis ​​em uma função ou objeto.

Vamos começar com D do SOLID e ver DI e IoC do livro de Scott Millett "Professional ASP.NET Design Patterns":

Princípio da inversão de dependência (DIP)

O DIP visa isolar suas classes de implementações concretas e tê-las depender de classes ou interfaces abstratas. Ele promove o mantra da codificação para uma interface, e não para uma implementação, o que aumenta a flexibilidade dentro de um sistema, garantindo que você não esteja totalmente acoplado a uma implementação.

Injeção de Dependência (DI) e Inversão de Controle (IoC)

Estreitamente vinculado ao DIP estão o princípio DI e o princípio IoC. DI é o ato de fornecer um nível baixo ou classe dependente por meio de um construtor, método ou propriedade. Usadas em conjunto com o DI, essas classes dependentes podem ser invertidas para interfaces ou classes abstratas que levarão a sistemas fracamente acoplados, altamente testáveis ​​e fáceis de alterar.

Na IoC , o fluxo de controle de um sistema é invertido comparado à programação procedural. Um exemplo disso é um contêiner de IoC , cujo objetivo é injetar serviços no código do cliente sem que o código do cliente especifique a implementação concreta. O controle nesta instância que está sendo invertido é o ato do cliente que obtém o serviço.

Millett, C (2010). Padrões profissionais de design do ASP.NET. Wiley Publishing. 7-8.

// ICO, DI, 10 anos atrás, era assim:

public class  AuditDAOImpl implements Audit{

    //dependency
    AuditDAO auditDAO = null;
        //Control of the AuditDAO is with AuditDAOImpl because its creating the object
    public AuditDAOImpl () {
        this.auditDAO = new AuditDAO ();
    }
}

Agora, com a Primavera 3,4 ou mais recente, é como abaixo

public class  AuditDAOImpl implements Audit{

    //dependency

     //Now control is shifted to Spring. Container find the object and provide it. 
    @Autowired
    AuditDAO auditDAO = null;

}

Em geral, o controle é invertido do conceito antigo de código acoplado para estruturas como Spring, que disponibiliza o objeto. Portanto, isso é o COI, tanto quanto eu sei, e injeção de dependência, como você sabe quando injetamos o objeto dependente em outro objeto usando o Construtor ou os setters. Injetar basicamente significa passar isso como argumento. Na primavera, temos uma configuração baseada em XML e anotação, onde definimos o objeto bean e passamos o objeto dependente com o estilo de injeção do Constructor ou do setter.

Encontrei o melhor exemplo no Dzone.com, que é realmente útil para entender as diferenças reais entre COI e DI

"IoC é quando você tem alguém para criar objetos para você." Portanto, em vez de escrever a palavra-chave "new" (por exemplo, MyCode c = new MyCode ()) no seu código, o objeto é criado por outra pessoa. Esse 'alguém' normalmente é chamado de contêiner de IoC. Isso significa que entregamos a rrsponsibility (control) ao container para obter a instância do objeto chamada Inversion of Control., Significa que, em vez de você criar um objeto usando o novo operador, deixe o container fazer isso por você.

   DI(Dependency Injection):  Way of injecting properties to an object is 
   called 
  Dependency injection.
   We have three types of Dependency injection
    1)  Constructor Injection
    2)  Setter/Getter Injection
    3)  Interface Injection
   Spring will support only Constructor Injection and Setter/Getter Injection.

Leia o artigo completo COI e Leia o artigo completo DI

1) DI é Child-> obj depende de parent-obj. O verbo depende é importante. 2) O COI é o Child-> obj realizado sob uma plataforma. onde a plataforma poderia ser escola, faculdade, aula de dança. Aqui, execute é uma atividade com implicações diferentes em qualquer provedor de plataforma.

exemplo prático: `

//DI
child.getSchool();
//IOC
child.perform()// is a stub implemented by dance-school
child.flourish()// is a stub implemented by dance-school/school/

`

-AB

Quanto a essa pergunta, eu diria que o wiki já forneceu explicações detalhadas e de fácil compreensão. Vou apenas citar o mais significativo aqui.

Implementação de IoC

Na programação orientada a objetos, existem várias técnicas básicas para implementar a inversão de controle. Esses são:

1. Usando um padrão de localizador de serviço Usando injeção de dependência, por exemplo Injeção de construtor Injeção de parâmetro Injeção de setter Injeção de interface;
2. Usando uma pesquisa contextualizada;
3. Usando padrão de design de método de modelo;
4. Usando padrão de design estratégico

Quanto à injeção de dependência

injeção de dependência é uma técnica pela qual um objeto (ou método estático) fornece as dependências de outro objeto. Uma dependência é um objeto que pode ser usado (um serviço). Uma injeção é a passagem de uma dependência para um objeto dependente (um cliente) que a usaria.

O conceito de IoC foi inicialmente ouvido durante a era da programação processual. Portanto, de um contexto histórico, a IoC falou sobre a inversão da propriedade do controle- fluxo ou seja, quem possui a responsabilidade de invocar as funções na ordem desejada - sejam elas próprias ou se você deve invertê-lo para alguma entidade externa.

No entanto, uma vez que o OOP surgiu, as pessoas começaram a falar sobre IoC no contexto do OOP, em que os aplicativos se preocupam com a criação de objetos e seus relacionamentos também, além do fluxo de controle. Tais aplicativos queriam inverter a propriedade da criação de objetos (em vez de controlar o fluxo) e exigiam um contêiner responsável pela criação do objeto, ciclo de vida do objeto e dependências de injeção dos objetos do aplicativo, eliminando assim objetos de criação de outros objetos concretos.

Nesse sentido, DI não é o mesmo que Io C , pois não se trata de fluxo de controle, no entanto, é um tipo de Io * , ie Inversão da propriedade da criação de objeto.

O que há de errado na minha maneira de explicar DI e IoC?

IoC, conhecido como Inversão de controle, refere-se ao controle de criação de instâncias que estão sendo executadas pelo contêiner Spring. O controle para criar e construir objetos é cuidado pelo contêiner. O contêiner cria os objetos e os injeta em nosso aplicativo.