Inversion de contrôle vs injection de dépendance

Selon l' article écrit par Martin Fowler , l'inversion de contrôle est le principe où le flux de contrôle d'un programme est inversé: au lieu du programmeur contrôlant le flux d'un programme, les sources externes (framework, services, autres composants) prennent le contrôle de il. C'est comme si nous branchions quelque chose à autre chose. Il a cité un exemple concernant EJB 2.0:

Par exemple, l'interface Session Bean définit ejbRemove, ejbPassivate (stocké sur le stockage secondaire) et ejbActivate (restauré à partir de l'état passif). Vous ne pouvez pas contrôler le moment où ces méthodes sont appelées, juste ce qu'elles font. Le conteneur nous appelle, nous ne l'appelons pas.

Cela conduit à la différence entre le framework et la bibliothèque:

L'inversion de contrôle est un élément clé de ce qui rend un framework différent d'une bibliothèque. Une bibliothèque est essentiellement un ensemble de fonctions que vous pouvez appeler, ces jours-ci généralement organisés en classes. Chaque appel effectue un certain travail et renvoie le contrôle au client.

Je pense que le point de vue selon lequel DI est IOC signifie que la dépendance d'un objet est inversée: au lieu de contrôler ses propres dépendances, son cycle de vie ... quelque chose d'autre le fait pour vous. Mais, comme vous me l'avez dit à la main, DI n'est pas nécessairement IOC. Nous pouvons toujours avoir DI et pas de CIO.

Cependant, dans cet article (de la pococapsule, un autre cadre IOC pour C / C ++), il suggère qu'en raison de l'IOC et de DI, les conteneurs IOC et les cadres DI sont beaucoup plus supérieurs à J2EE, car J2EE mélange le code de cadre dans les composants , ce qui ne fait donc pas de lui un simple objet Java / C ++ (POJO / POCO).

Inversion des conteneurs de contrôle autres que le modèle d'injection de dépendance (lien d'archive)

Lecture supplémentaire pour comprendre quel est le problème avec l'ancien Framework de développement basé sur les composants, ce qui conduit au deuxième article ci-dessus: Pourquoi et quoi d'inversion de contrôle (lien d'archive)

Ma question : qu'est-ce que le CIO et DI exactement? Je suis confus. Basé sur pococapsule, IOC est quelque chose de plus significatif que la simple inversion du contrôle entre les objets ou les programmeurs et les frameworks.

IoC est un terme générique qui signifie plutôt que l'application appelle les méthodes dans un cadre, le cadre appelle les implémentations fournies par l'application.

DI est une forme d'IoC, où les implémentations sont passées dans un objet via des constructeurs / setters / services lookups, dont l'objet dépendra afin de se comporter correctement.

L'IoC sans utiliser DI , par exemple, serait le modèle de modèle car l'implémentation ne peut être modifiée que par sous-classification.

Les cadres DI sont conçus pour utiliser DI et peuvent définir des interfaces (ou annotations en Java) pour faciliter le passage dans les implémentations.

Les conteneurs IoC sont des infrastructures DI qui peuvent fonctionner en dehors du langage de programmation. Dans certains, vous pouvez configurer les implémentations à utiliser dans les fichiers de métadonnées (par exemple XML) qui sont moins invasives. Avec certains, vous pouvez faire de l'IoC qui serait normalement impossible, comme injecter une implémentation aux coupes ponctuelles .

Voir aussi cet article de Martin Fowler .

En bref, l'IoC est un terme beaucoup plus large qui inclut, mais sans s'y limiter, DI

Le terme Inversion of Control (IoC) signifiait à l'origine toute sorte de style de programmation où un cadre global ou l'exécution contrôlait le flux du programme

Avant que DI ait un nom, les gens ont commencé à se référer aux cadres qui gèrent les dépendances comme inversion des conteneurs de contrôle, et bientôt, la signification de l'IoC a progressivement dérivé vers cette signification particulière: inversion du contrôle des dépendances.

L'inversion de contrôle (IoC) signifie que les objets ne créent pas d'autres objets sur lesquels ils s'appuient pour faire leur travail. Au lieu de cela, ils obtiennent les objets dont ils ont besoin d'une source externe (par exemple, un fichier de configuration xml).

L'injection de dépendance (DI) signifie que cela se fait sans l'intervention de l'objet, généralement par un composant de structure qui transmet les paramètres du constructeur et définit les propriétés.

la source

IoC ( I nVersion o f C ontrôle): - Il est un terme générique et mis en œuvre de plusieurs façons (événements, délégués , etc.).

DI ( D ependency I njection): - DI est un sous-type d'IoC et est implémenté par injection constructeur, injection setter ou injection interface .

Mais, Spring ne prend en charge que les deux types suivants:

• Setter Injection
  • L'ID basé sur Setter est réalisé en appelant des méthodes de définition sur les beans de l'utilisateur après avoir appelé un constructeur sans argument ou une méthode d'usine statique sans argument pour instancier leur bean.
• Injection de constructeur
  • La DI basée sur le constructeur est réalisée en invoquant un constructeur avec un certain nombre d'arguments, chacun représentant un collaborateur.En utilisant cela, nous pouvons valider que les beans injectés ne sont pas nuls et échouent rapidement (échouent à la compilation et non à l'exécution), donc tout en commençant l'application elle-même, nous obtenons NullPointerException: bean does not exist. L'injection de constructeur est la meilleure pratique pour injecter des dépendances.

DI est un sous-ensemble d'IoC

• L'IoC signifie que les objets ne créent pas d'autres objets sur lesquels ils s'appuient pour faire leur travail. Au lieu de cela, ils obtiennent les objets dont ils ont besoin d'un service extérieur (par exemple, un fichier xml ou un service d'application unique). 2 implémentations d'IoC, j'utilise, sont DI et ServiceLocator.
• DI signifie que le principe IoC consistant à obtenir un objet dépendant se fait sans utiliser d'objets concrets mais d'abstractions (interfaces). Cela rend tous les composants testables en chaîne, car le composant de niveau supérieur ne dépend pas du composant de niveau inférieur, uniquement à partir de l'interface. Les maquettes implémentent ces interfaces.

Voici quelques autres techniques pour atteindre l'IoC .

IOC (Inversion Of Control) : Donner le contrôle au conteneur pour obtenir une instance de l'objet s'appelle Inversion of Control, signifie qu'au lieu de créer un objet à l'aide du nouvel opérateur, laissez le conteneur faire cela pour vous.

DI (Dependency Injection) : La manière d'injecter des propriétés à un objet s'appelle Dependency Injection .

Nous avons trois types d' injection de dépendance :

1. Injection de constructeur
2. Setter / Getter Injection
3. Injection d'interface

Spring prend uniquement en charge l' injection constructeur et l' injection Setter / Getter .

Puisque toutes les réponses mettent l'accent sur la théorie, je voudrais démontrer avec un exemple de première approche:

Supposons que nous construisons une application qui contient une fonctionnalité pour envoyer des messages de confirmation SMS une fois la commande expédiée. Nous aurons deux classes, l'une est responsable de l'envoi du SMS (SMSService), et l'autre responsable de la capture des entrées utilisateur (UIHandler), notre code ressemblera à ci-dessous:

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!");
    }
}

L'implémentation ci-dessus n'est pas fausse, mais il y a quelques problèmes:
-) Supposons que dans l'environnement de développement, vous souhaitiez enregistrer les SMS envoyés dans un fichier texte au lieu d'utiliser la passerelle SMS, pour y parvenir; nous finirons par changer l'implémentation concrète de (SMSService) par une autre implémentation, nous perdons de la flexibilité et nous sommes obligés de réécrire le code dans ce cas.
-) Nous finirons par mélanger les responsabilités des classes, notre (UIHandler) ne devrait jamais connaître l'implémentation concrète de (SMSService), cela devrait être fait en dehors des classes en utilisant "Interfaces". Lorsque cela est implémenté, il nous donnera la possibilité de changer le comportement du système en échangeant le (SMSService) utilisé avec un autre service fictif qui implémente la même interface, ce service enregistrera les SMS dans un fichier texte au lieu de les envoyer à mobileNumber.

Pour résoudre les problèmes ci-dessus, nous utilisons des interfaces qui seront mises en œuvre par notre (SMSService) et le nouveau (MockSMSService), fondamentalement la nouvelle interface (ISMSService) exposera les mêmes comportements des deux services que le code ci-dessous:

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

Ensuite, nous allons changer notre implémentation (SMSService) pour implémenter l'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);
    }
}

Nous allons maintenant pouvoir créer un nouveau service de maquette (MockSMSService) avec une implémentation totalement différente en utilisant la même 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);
    }
}

À ce stade, nous pouvons changer le code dans (UIHandler) pour utiliser l'implémentation concrète du service (MockSMSService) facilement comme ci-dessous:

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

Nous avons obtenu beaucoup de flexibilité et mis en œuvre la séparation des problèmes dans notre code, mais nous devons toujours modifier la base de code pour basculer entre les deux services SMS. Nous devons donc implémenter l' injection de dépendance .

Pour y parvenir, nous devons implémenter une modification de notre constructeur de classe (UIHandler) pour passer la dépendance à travers elle, ce faisant, le code qui utilise le (UIHandler) peut déterminer quelle implémentation concrète de (ISMSService) utiliser:

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!");
    }
}

Maintenant, le formulaire d'interface utilisateur qui parlera avec la classe (UIHandler) est responsable de passer quelle implémentation de l'interface (ISMSService) utiliser. Cela signifie que nous avons inversé le contrôle, le (UIHandler) n'est plus responsable de décider quelle implémentation utiliser, le code appelant le fait. Nous avons mis en œuvre le principe d' inversion de contrôle dont DI est un type.

Le code du formulaire d'interface utilisateur sera le suivant:

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

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

        Console.ReadLine();
    }
}

Mais la documentation du printemps indique qu'ils sont identiques.

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

Dans la première ligne, " IoC est également connu sous le nom d'injection de dépendance (DI) ".

IoC - Inversion de contrôle est un terme générique, indépendant du langage, il ne s'agit en fait pas de créer les objets mais de décrire dans quel objet de mode est créé.

DI - L'injection de dépendances est un terme concret, dans lequel nous fournissons des dépendances de l'objet au moment de l'exécution en utilisant différentes techniques d'injection, à savoir. Setter Injection, Constructor Injection ou par Interface Injection.

L'inversion du contrôle est un paradigme de conception dans le but de donner plus de contrôle aux composants ciblés de votre application, ceux qui font le travail.
L'injection de dépendances est un modèle utilisé pour créer des instances d'objets sur lesquels d'autres objets s'appuient sans savoir au moment de la compilation quelle classe sera utilisée pour fournir cette fonctionnalité.

Il existe plusieurs techniques de base pour implémenter l'inversion de contrôle. Ceux-ci sont:

• Utilisation d'un modèle d'usine
  
• Utilisation d'un modèle de localisateur de service
  
• En utilisant une injection de dépendance de n'importe quel type ci-dessous:
  
  1). Une injection constructeur
  2). Une injection de setter
  3). Une injection d'interface

DI et IOC sont deux modèles de conception qui se concentrent principalement sur la fourniture d' un couplage lâche entre les composants , ou simplement sur la façon dont nous découplons les relations de dépendance conventionnelles entre les objets afin que les objets ne soient pas serrés les uns par rapport aux autres.

Avec les exemples suivants, j'essaie d'expliquer ces deux concepts.

Auparavant, nous écrivons du code comme celui-ci

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();
}

Avec l'injection de dépendance, l'injecteur de dépendance se charge de l'instanciation des objets

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();
}

Le processus ci-dessus consistant à donner le contrôle à un autre (par exemple le conteneur) pour l'instanciation et l'injection peut être appelé inversion de contrôle et le processus dans lequel le conteneur IOC injecte la dépendance pour nous peut être appelé injection de dépendance.

IOC est le principe où le flux de contrôle d'un programme est inversé: au lieu que le programmeur contrôle le flux d'un programme , le programme contrôle le flux en réduisant les frais généraux du programmeur et le processus utilisé par le programme pour injecter la dépendance est appelé DI

Les deux concepts fonctionnent ensemble, ce qui nous permet d'écrire du code beaucoup plus flexible, réutilisable et encapsulé, ce qui en fait des concepts importants dans la conception de solutions orientées objet.

Recommande également de lire.

Qu'est-ce que l'injection de dépendance?

Vous pouvez également consulter une de mes réponses similaires ici

Différence entre l'inversion du contrôle et l'injection de dépendance

Inversion of Control est un principe de conception générique de l'architecture logicielle qui aide à créer des cadres logiciels modulaires réutilisables et faciles à entretenir.

Il s'agit d'un principe de conception dans lequel le flux de contrôle est «reçu» de la bibliothèque générique écrite ou du code réutilisable.

Pour mieux le comprendre, voyons comment nous codions dans nos premiers jours de codage. Dans les langages procéduraux / traditionnels, la logique métier contrôle généralement le flux de l'application et "appelle" le code / les fonctions génériques ou réutilisables. Par exemple, dans une application console simple, mon flux de contrôle est contrôlé par les instructions de mon programme, qui peuvent inclure les appels à certaines fonctions générales réutilisables.

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

En revanche, avec l'IoC, les Frameworks sont le code réutilisable qui "appelle" la logique métier.

Par exemple, dans un système basé sur Windows, un cadre sera déjà disponible pour créer des éléments d'interface utilisateur comme des boutons, des menus, des fenêtres et des boîtes de dialogue. Lorsque j'écris la logique métier de mon application, ce sont les événements du framework qui appellent mon code logique métier (lorsqu'un événement est déclenché) et NON l'inverse.

Bien que le code du framework ne connaisse pas ma logique métier, il saura toujours comment appeler mon code. Ceci est réalisé en utilisant des événements / délégués, des rappels, etc. Ici, le contrôle du flux est "inversé".

Ainsi, au lieu de dépendre du flux de contrôle sur des objets liés statiquement, le flux dépend du graphique d'objet global et des relations entre les différents objets.

L'injection de dépendance est un modèle de conception qui met en œuvre le principe IoC pour résoudre les dépendances des objets.

En termes plus simples, lorsque vous essayez d'écrire du code, vous créerez et utiliserez différentes classes. Une classe (classe A) peut utiliser d'autres classes (classe B et / ou D). Ainsi, les classes B et D sont des dépendances de la classe A.

Une analogie simple sera une voiture de classe. Une voiture peut dépendre d'autres classes comme le moteur, les pneus et plus encore.

L'injection de dépendance suggère qu'au lieu que les classes dépendantes (Class Car ici) créent ses dépendances (moteur de classe et classe Tire), la classe devrait être injectée avec l'instance concrète de la dépendance.

Permet de comprendre avec un exemple plus pratique. Considérez que vous écrivez votre propre TextEditor. Entre autres choses, vous pouvez avoir un correcteur orthographique qui fournit à l'utilisateur la possibilité de vérifier les fautes de frappe dans son texte. Une implémentation simple d'un tel code peut être:

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;

    }

}

À première vue, tout semble rose. L'utilisateur écrira du texte. Le développeur capturera le texte et appellera la fonction CheckSpellings et trouvera une liste de fautes de frappe qu'il montrera à l'utilisateur.

Tout semble bien fonctionner jusqu'à un beau jour où un utilisateur commence à écrire le français dans l'éditeur.

Pour prendre en charge plus de langues, nous devons avoir plus de vérificateurs orthographiques. Probablement français, allemand, espagnol, etc.

Ici, nous avons créé un code étroitement couplé avec SpellChecker "anglais" étant étroitement couplé à notre classe TextEditor, ce qui signifie que notre classe TextEditor dépend de EnglishSpellChecker ou en d'autres termes, EnglishSpellCheker est la dépendance de TextEditor. Nous devons supprimer cette dépendance. De plus, notre éditeur de texte a besoin d'un moyen de conserver la référence concrète de tout correcteur orthographique en fonction de la discrétion du développeur au moment de l'exécution.

Ainsi, comme nous l'avons vu dans l'introduction de DI, cela suggère que la classe devrait être injectée avec ses dépendances. Ainsi, il devrait être de la responsabilité du code appelant d'injecter toutes les dépendances dans la classe / le code appelé. Nous pouvons donc restructurer notre code comme

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.

    }

}

Dans notre exemple, la classe TextEditor doit recevoir l'instance concrète de type ISpellChecker.

Maintenant, la dépendance peut être injectée dans le constructeur, une propriété publique ou une méthode.

Essayons de changer notre classe en utilisant le constructeur DI. La classe TextEditor modifiée ressemblera à quelque chose comme:

Class TextEditor

{

    ISpellChecker objSpellChecker;

    string Text;



    public void TextEditor(ISpellChecker objSC)

    {

        objSpellChecker = objSC;

    }



    public ArrayList <typos> CheckSpellings()

    {

        return objSpellChecker.CheckSpelling();

    }

}

Pour que le code appelant, lors de la création de l'éditeur de texte, puisse injecter le type SpellChecker approprié à l'instance de TextEditor.

Vous pouvez lire l'article complet ici

IOC (Inversion Of Control): Donner le contrôle au conteneur pour obtenir l'instance de l'objet s'appelle Inversion of Control. Cela signifie qu'au lieu de créer un objet à l'aide d'un nouvel opérateur , laissez le conteneur faire cela pour vous.

DI (Dependency Injection): Le passage des paramètres (propriétés) requis de XML à un objet (dans POJO CLASS) est appelé injection de dépendance.

IOC indique qu'une classe externe gère les classes d'une application et que les classes externes signifient qu'un conteneur gère la dépendance entre les classes d'application. Le concept de base d' IOC est que le programmeur n'a pas besoin de créer vos objets mais décrit comment ils doivent être créés.

Les tâches principales effectuées par le conteneur IoC sont les suivantes: instancier la classe d'application. pour configurer l'objet. pour assembler les dépendances entre les objets.

DI est le processus de fourniture des dépendances d'un objet au moment de l'exécution en utilisant l'injection de setter ou l'injection de constructeur.

IOC (Inversion of Control) est essentiellement un concept de modèle de conception consistant à supprimer les dépendances et à les découpler pour rendre le flux non linéaire et à laisser le conteneur / ou une autre entité gérer l'approvisionnement des dépendances. Il suit en fait le directeur d'Hollywood «Ne nous appelez pas, nous vous appellerons» Donc, résumant les différences.

Inversion de contrôle: - C'est un terme générique pour découpler les dépendances et déléguer leur provisioning, et cela peut être implémenté de plusieurs manières (événements, délégués, etc.).

Injection de dépendance: - DI est un sous-type d'IOC et est implémenté par injection constructeur, injection setter ou injection méthode.

L'article suivant décrit cela très bien.

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

Je pense que l'idée peut être clairement démontrée sans entrer dans les mauvaises herbes orientées objet, qui semblent brouiller l'idée.

// 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)
}

Si vous inclinez la tête et plissez les yeux, vous verrez que DI est une implémentation particulière de l'IoC avec des préoccupations spécifiques. Au lieu d'injecter des modèles et des comportements dans un cadre d'application ou une opération d'ordre supérieur, vous injectez des variables dans une fonction ou un objet.

Commençons par D de SOLID et regardons DI et IoC du livre de Scott Millett "Professional ASP.NET Design Patterns":

Principe d'inversion de dépendance (DIP)

Le DIP consiste à isoler vos classes des implémentations concrètes et à les faire dépendre de classes ou d'interfaces abstraites. Il promeut le mantra du codage vers une interface plutôt qu'une implémentation, ce qui augmente la flexibilité au sein d'un système en vous assurant que vous n'êtes pas étroitement couplé à une implémentation.

Injection de dépendance (DI) et inversion de contrôle (IoC)

Le principe DI et le principe IoC sont étroitement liés au DIP. DI est l'acte de fournir une classe de bas niveau ou dépendante via un constructeur, une méthode ou une propriété. Utilisées conjointement avec DI, ces classes dépendantes peuvent être inversées en interfaces ou en classes abstraites, ce qui conduira à des systèmes à couplage lâche qui sont hautement testables et faciles à changer.

Dans l' IoC , le flux de contrôle d'un système est inversé par rapport à la programmation procédurale. Un exemple de ceci est un conteneur IoC , dont le but est d'injecter des services dans le code client sans que le code client spécifie l'implémentation concrète. Dans ce cas, le contrôle qui est inversé est l'acte du client obtenant le service.

Millett, C (2010). Modèles de conception ASP.NET professionnels. Éditions Wiley. 7-8.

// ICO, DI, 10 ans en arrière, c'était comme ça:

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 ();
    }
}

Maintenant, avec le printemps 3,4 ou le dernier son similaire ci-dessous

public class  AuditDAOImpl implements Audit{

    //dependency

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

}

Globalement, le contrôle est inversé de l'ancien concept de code couplé aux cadres comme Spring qui rend l'objet disponible. C'est donc l'IOC pour autant que je sache et l'injection de dépendances comme vous le savez lorsque nous injectons l'objet dépendant dans un autre objet à l'aide du constructeur ou des setters. Injecter signifie essentiellement le passer comme argument. Au printemps, nous avons une configuration basée sur XML et annotation où nous définissons l'objet bean et passons l'objet dépendant avec le style d'injection Constructeur ou setter.

J'ai trouvé le meilleur exemple sur Dzone.com qui est vraiment utile pour comprendre la vraie différence entre IOC et DI

"L'IoC, c'est quand quelqu'un d'autre crée des objets pour vous." Ainsi, au lieu d'écrire un "nouveau" mot clé (par exemple, MyCode c = new MyCode ()) dans votre code, l'objet est créé par quelqu'un d'autre. Ce «quelqu'un d'autre» est normalement appelé conteneur IoC. Cela signifie que nous passons la rrsponsibility (contrôle) au conteneur pour obtenir l'instance de l'objet est appelé Inversion of Control., Signifie qu'au lieu de créer un objet à l'aide d'un nouvel opérateur, laissez le conteneur faire cela pour vous.

   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.

Lire l'article complet sur le CIO et lire l'article complet DI

1) DI est Child-> obj dépend de parent-obj. Le verbe dépend est important. 2) IOC est Child-> obj effectuer sous une plate-forme. où la plate-forme pourrait être l'école, le collège, la classe de danse. Ici, effectuer est une activité avec des implications différentes sous n'importe quel fournisseur de plate-forme.

exemple pratique: `

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

"

-UN B

Quant à cette question, je dirais que le wiki a déjà fourni des explications détaillées et faciles à comprendre. Je ne citerai ici que les plus importants.

Implémentation d'IoC

En programmation orientée objet, il existe plusieurs techniques de base pour implémenter l'inversion de contrôle. Ceux-ci sont:

1. Utilisation d'un modèle de localisateur de service Utilisation de l'injection de dépendances, par exemple injection de constructeur injection de paramètres injection Setter injection interface;
2. Utilisation d'une recherche contextualisée;
3. Utilisation d'un modèle de conception de méthode de modèle;
4. Utilisation d'un modèle de conception de stratégie

Quant à l' injection de dépendance

l'injection de dépendances est une technique par laquelle un objet (ou une méthode statique) fournit les dépendances d'un autre objet. Une dépendance est un objet qui peut être utilisé (un service). Une injection est le passage d'une dépendance à un objet dépendant (un client) qui l'utiliserait.

Le concept IoC a été initialement entendu pendant l'ère de la programmation procédurale. Par conséquent, dans un contexte historique, l'IoC a parlé d'inversion de la propriété du contrôle- flux c'est-à-dire à qui appartient la responsabilité d'invoquer les fonctions dans l'ordre souhaité - que ce soit les fonctions elles-mêmes ou devez-vous les inverser vers une entité externe.

Cependant, une fois que la POO a émergé, les gens ont commencé à parler de l'IoC dans le contexte de POO où les applications sont également concernées par la création d'objets et leurs relations, en dehors du flux de contrôle. De telles applications voulaient inverser la propriété de la création d'objets (plutôt que du flux de contrôle) et nécessitaient un conteneur responsable de la création d'objets, du cycle de vie des objets et de l'injection des dépendances des objets d'application, éliminant ainsi les objets d'application de la création d'autres objets concrets.

En ce sens, DI n'est pas la même chose que Io C , car il ne s'agit pas de contrôle-flux, mais c'est une sorte d'Io * , c'est-à-dire d'inversion de propriété de la création d'objet.

Qu'est-ce qui ne va pas dans ma façon d'expliquer DI et IoC?

IoC aka Inversion of Control se réfère au contrôle de création d'instances effectué par le conteneur Spring. Le contrôle de création et de construction d'objets est pris en charge par le conteneur. Le conteneur crée les objets et les injecte dans notre application.