Comment expliquer l'injection de dépendance à un enfant de 5 ans? [fermé]

Quelle est la bonne façon d'expliquer l' injection de dépendance ?

J'ai trouvé plusieurs tutoriels sur Google, mais aucun d'entre eux qui supposerait que le lecteur n'est qu'un débutant Java. Comment expliqueriez-vous cela à un novice?

Je vous donne une injection de dépendance pour les enfants de cinq ans.

Lorsque vous sortez du réfrigérateur par vous-même, vous pouvez causer des problèmes. Vous pourriez laisser la porte ouverte, vous pourriez obtenir quelque chose que maman ou papa ne veut pas que vous ayez. Vous cherchez peut-être même quelque chose que nous n'avons même pas ou qui a expiré.

Ce que vous devriez faire, c'est énoncer un besoin: «J'ai besoin de quelque chose à boire avec le déjeuner», puis nous nous assurerons que vous avez quelque chose lorsque vous vous asseyez pour manger.

Et ça?

Si vous avez une classe Employeeet que cet employé en a une, Address vous pouvez Employeedéfinir la classe comme suit:

class Employee {
    private Address address;

    // constructor 
    public Employee( Address newAddress ) {
        this.address = newAddress;
    }

    public Address getAddress() {
    return this.address;
    }
    public void setAddress( Address newAddress ) {
        this.address = newAddress;
    }
}

Jusqu'à présent, tout semble bien.

Ce code montre une relation HAS-A entre l'employé et son adresse, ça va.

Maintenant, cette relation HAS-A a créé une dépendance entre eux. Le problème vient du constructeur.

Chaque fois que vous souhaitez créer une Employeeinstance, vous avez besoin d'une Addressinstance:

 Address someAddress = ....
 Employee oscar = new Employee( someAddress ); 

Travailler de cette façon devient problématique, surtout lorsque vous souhaitez effectuer des tests unitaires.

Le problème principal survient lorsque vous devez tester un objet particulier, vous devez créer une instance d'un autre objet, et très probablement vous devez créer une instance d'un autre objet pour ce faire. La chaîne peut devenir ingérable.

Pour éviter cela, vous pouvez changer le constructeur comme ceci:

  public Employee(){
  }

Utilisation d'un constructeur sans argument.

Ensuite, vous pouvez définir l'adresse quand vous le souhaitez:

 Address someAddress = ....
 Employee oscar = new Employee();
 oscar.setAddress( someAddress ); 

Maintenant, cela peut être un glissement, si vous avez plusieurs attributs ou si les objets sont difficiles à créer.

Pourtant, pensez-y, disons, vous ajoutez l' Departmentattribut:

  class Employee {
      private Address address;
      private Department department;

  ....

Si vous avez 300 employés et que tous doivent avoir le même service, et en plus ce même service doit être partagé entre d'autres objets (comme la liste des départements de l'entreprise, ou les rôles de chaque département, etc.), alors vous avoir du mal avec la visibilité de l' Departmentobjet et le partager à travers tout le réseau d'objets.

En quoi consiste l' injection de dépendances pour vous aider à "injecter" ces dépendances dans votre code. La plupart des frameworks vous permettent de le faire en spécifiant dans un fichier externe, quel objet doit être injecté.

Supposons un fichier de propriétés pour un injecteur de dépendance fictif:

  #mock employee
  employee.address = MockAddress.class
  employee.department = MockDepartment.class

  #production setup 
  employee.address = RealAddress.class
  employee.department = RealDepartment.class

Vous définirez quoi injecter pour un scénario donné.

Ce que le framework Dependency Injector va faire est de définir les objets appropriés pour vous, de sorte que vous n'ayez pas à coder setAddressou setDepartment. Cela se ferait soit par réflexion, soit par génération de code ou par d'autres techniques.

Ainsi, la prochaine fois que vous aurez besoin de tester la Employeeclasse, vous pourrez injecter de la maquette Addresset des Departmentsobjets sans avoir à coder tout l'ensemble / obtenir pour tout votre test. Encore mieux, vous pouvez injecter du réel Address et des Departmentobjets dans le code de production, tout en ayant l'assurance que votre code fonctionne comme testé.

C'est à peu près tout.

Pourtant, je ne pense pas que cette explication convient à un enfant de 5 ans comme vous l'avez demandé.

J'espère que vous le trouverez toujours utile.

Lors de l'écriture d'une classe, il est naturel qu'elle utilise d'autres objets. Vous pouvez avoir une connexion à une base de données, par exemple, ou un autre service que vous utilisez. Ces autres objets (ou services) sont des dépendances. La façon la plus simple d'écrire le code est simplement de créer et d'utiliser ces autres objets. Mais cela signifie que votre objet a une relation inflexible avec ces dépendances: peu importe pourquoi vous invoquez votre objet, il utilise les mêmes dépendances.

Une technique plus puissante consiste à pouvoir créer votre objet et lui fournir les dépendances à utiliser. Vous pouvez donc créer une connexion à une base de données à utiliser, puis la remettre à votre objet. De cette façon, vous pouvez créer votre objet avec différentes dépendances à différents moments, ce qui rend votre objet plus flexible. Il s'agit de l'injection de dépendances, où vous "injectez" les dépendances dans l'objet.

BTW: Dans le style de présentation moderne qui utilise des photos flickr pour illustrer des concepts, cela pourrait être illustré par un toxicomane se tirant dessus avec de la drogue. Oh, attendez, c'est la dépendance à l'injection ... OK, désolé, mauvaise blague.

Je ne connais aucun tutoriel simplifié, mais je peux vous donner une version de près de 25 250 mots ou moins:

Avec l'injection de dépendances, un objet ne configure pas ses propres composants en fonction de choses qu'il connaît déjà, plutôt que l'objet est configuré par une logique de niveau supérieur, puis il appelle des composants dont il n'avait pas de connaissance préalable intégrée. L'idée est de faire de l'objet davantage un composant et moins une application, en déplaçant les tâches de configuration à un niveau supérieur. Cela rend l'objet plus susceptible d'être utile à l'avenir ou avec une configuration différente.

C'est mieux pour les tests, c'est mieux quand vient le temps de réviser l'application. Une implémentation typique place la configuration en XML et utilise un cadre pour charger dynamiquement les classes.

Lorsque vous recevez une nouvelle Nintendo, vous pouvez simplement utiliser les boutons et l'écran tactile pour jouer à des jeux.

Mais à l'usine Nintendo, ils doivent savoir comment en assembler un.

Lorsque les gens intelligents de l'usine sortiront une Nintendo DS, ce sera différent à l'intérieur, mais vous saurez toujours comment l'utiliser.