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

injection de dépendance (DI) signifie découpler les objets qui sont dépendants les uns des autres. Dire d'Un objet dépend de l'Objet B si l'idée est de dissocier ces objets les uns des autres. Nous n'avons pas besoin de coder l'objet en utilisant un nouveau mot-clé plutôt que de partager des dépendances avec des objets à l'exécution malgré le temps de compilation. Si nous parlons de

Comment l'Injection de Dépendance travaux au Printemps:

nous n'avons pas besoin de code dur l'objet en utilisant un nouveau mot-clé plutôt que de définir la dépendance bean dans le fichier de configuration. Le printemps conteneur sera responsable de l'accrochage.

Inversion de la commande (IOC)

la COI est un concept général qui peut s'exprimer de différentes façons et L'Injection de dépendance est un exemple concret de la COI.

deux types D'Injection de dépendance:

1. Constructeur D'Injection
2. Injection Par Mutateur

1. Injection de dépendance basée sur le constructeur:

di basée sur le constructeur est accomplie quand le conteneur invoque un constructeur de classe avec un certain nombre d'arguments, chacun représentant une dépendance à l'autre classe.

public class Triangle {

private String type;

public String getType(){
    return type;
 }

public Triangle(String type){   //constructor injection
    this.type=type;
 }
}
<bean id=triangle" class ="com.test.dependencyInjection.Triangle">
        <constructor-arg value="20"/>
  </bean>

2. Injection de dépendance à base de Setter:

DI basé sur Setter est accompli par le conteneur appelant les méthodes de setter sur vos haricots après avoir invoqué un constructeur no-argument ou no-argument méthode usine statique pour instancier votre haricot.

public class Triangle{

 private String type;

 public String getType(){
    return type;
  }
 public void setType(String type){          //setter injection
    this.type = type;
  }
 }

<!-- setter injection -->
 <bean id="triangle" class="com.test.dependencyInjection.Triangle">
        <property name="type" value="equivialteral"/>

NOTE: C'est une bonne règle empirique d'utiliser des arguments de constructeur pour les dépendances obligatoires et des setters pour les dépendances optionnelles. Notez que le si nous utilisons l'annotation basée sur @Required annotation sur un setter peut être utilisé pour faire des setters comme des dépendances requises.

la meilleure analogie à laquelle je puisse penser est le chirurgien et son(ses) assistant (s) dans une salle d'opération, où le chirurgien est la Personne principale et son assistant qui fournit les différents composants chirurgicaux quand il en a besoin afin que le chirurgien puisse se concentrer sur la seule chose qu'il fait le mieux (chirurgie). Sans l'assistant, le chirurgien doit récupérer les composants lui-même à chaque fois qu'il en a besoin.

DI En bref, est une technique pour supprimer une responsabilité supplémentaire commune (charge) sur les composants à récupérer les composants dépendants, en offrant à elle.

DI vous rapproche du principe de Responsabilité Unique (RS), comme le surgeon who can concentrate on surgery .

quand utiliser DI: je recommande D'utiliser DI dans presque tous les projets de production (petits / grands), en particulier dans les environnements d'affaires en constante évolution:)

pourquoi: parce que vous voulez que votre code soit facilement testable, mockable etc afin que vous puissiez tester rapidement vos modifications et les pousser vers le marché. En outre, pourquoi ne le feriez-vous pas lorsque vous Il ya beaucoup d'outils/cadres gratuits géniaux pour vous soutenir dans votre voyage à une base de codes où vous avez plus de contrôle.

toutes les réponses ci-dessus sont bonnes, mon but est d'expliquer le concept d'une manière simple afin que quiconque sans connaissance de programmation peut également comprendre le concept

L'injection de dépendance est l'un des modèles qui nous aident à créer des systèmes complexes d'une manière plus simple.

nous pouvons voir une grande variété d'application de ce modèle dans notre vie quotidienne. Certains des exemples sont Magnétophone, VCD, lecteur de CD etc.

l'image ci-dessus est celle d'un magnétophone portatif, datant du milieu du XXe siècle. Source .

le but premier d'un magnétophone est d'enregistrer ou de lire le son.Lors de la conception d'un système, il faut une bobine pour enregistrer ou lire le son ou la musique. nous pouvons placer la bobine à l'intérieur de la machine, ou bien nous pouvons fournir un crochet pour la bobine où elle peut être placée.si nous optons pour le deuxième qui place un crochet pour la bobine, nous obtenons un avantage supplémentaire de jouer n'importe quelle musique en changeant la bobine. et aussi la réduction de la fonction jouant n'importe quoi dans la bobine.

les principaux avantages que nous avons obtenus en utilisant l'injection de dépendance.

• une Forte cohésion et le couplage lâche.
• de l'externalisation de la dépendance et de la recherche que sur la responsabilité.
• faire des choses comme des composants et de se combiner pour former un grand système avec des capacités élevées.
• il aide à développer des composants de haute qualité puisqu'ils sont développés indépendamment ils sont correctement testés.
• il est utile de remplacer le composant par un autre en cas de défaillance de l'un d'eux.

de nos jours, ce concept constitue la base de cadres bien connus dans le monde de la programmation. L'angle du ressort etc sont les cadres logiciels bien connus construits sur le dessus de ce concept

injection de dépendances est un modèle utilisé pour créer des instances d'objets sur lesquels d'autres objets se fient sans savoir au moment de la compilation quelle classe sera utilisée pour fournir cette fonctionnalité ou simplement la façon d'injecter des propriétés à un objet est appelé injection de dépendances.

exemple d'injection de dépendance

nous sommes code d'écriture comme ceci

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 injection de dépendance, l'injecteur de dépendance décollera l'instanciation pour nous

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

vous pouvez aussi lire

différence entre L'Inversion du contrôle et L'Injection de dépendance

cela signifie que les objets ne doivent avoir qu'autant de dépendances que nécessaire pour faire leur travail et que les dépendances doivent être peu nombreuses. De plus, les dépendances d'un objet devraient être basées sur des interfaces et non sur des objets "concrets", dans la mesure du possible. (Un objet concret est un objet créé avec le mot-clé new.) L'accouplement lâche favorise une plus grande réutilisabilité, une maintenabilité plus facile, et vous permet de fournir facilement des objets "simulés" à la place de services coûteux.

le "Injection de dépendance "(DI) est également connu sous le nom de" Inversion de contrôle " (IoC), peut être utilisé comme une technique pour encourager ce couplage lâche.

il y a deux approches principales à la mise en œuvre de L'ai:

1. injection du constructeur
2. injection par Mutateur

Constructeur d'injection

c'est la technique de passer des dépendances d'objets à son constructeur.

noter que le constructeur accepte une interface et non un objet concret. Notez également qu'une exception est lancée si le paramètre orderDao est null. Cela souligne l'importance de recevoir une dépendance valide. L'Injection par le constructeur est, à mon avis, le mécanisme préféré pour donner à un objet ses dépendances. Il est clair pour le développeur lors de l'invocation de l'objet quelles dépendances doivent être données à l'objet "Person" pour une exécution correcte.

Setter Injection

mais considérez l'exemple suivant... supposez que vous ayez une classe avec dix méthodes qui n'ont pas de dépendances, mais vous ajoutez une nouvelle méthode qui a une dépendance sur IDAO. Vous pouvez changer le constructeur pour utiliser L'Injection du constructeur, mais cela peut vous forcer à changer tous les appels du constructeur partout. Alternativement, vous pouvez simplement ajouter un nouveau constructeur qui prend la dépendance, mais alors comment un développeur facilement savoir quand utiliser l'un constructeur sur l'autre. Enfin, si la dépendance est très coûteuse à créer, pourquoi devrait-elle être créée et transmise au constructeur alors qu'elle ne peut être utilisée que rarement? "Setter Injection" est une autre technique DI qui peut être utilisée dans des situations comme celle-ci.

Setter Injection ne force pas les dépendances à passer au constructeur. Au lieu de cela, les dépendances sont définies sur les propriétés publiques exposées par l'objet dans le besoin. Comme indiqué précédemment, les principaux facteurs de motivation pour ce faire comprennent:

1. le Soutien de l'injection de dépendance, sans avoir à modifier le constructeur de l'héritage de classe.
2. permettant de créer des ressources ou des services coûteux aussi tard que possible et uniquement en cas de besoin.

Voici l'exemple du code ci-dessus:

public class Person {
    public Person() {}

    public IDAO Address {
        set { addressdao = value; }
        get {
            if (addressdao == null)
              throw new MemberAccessException("addressdao" +
                             " has not been initialized");
            return addressdao;
        }
    }

    public Address GetAddress() {
       // ... code that uses the addressdao object
       // to fetch address details from the datasource ...
    }

    // Should not be called directly;
    // use the public property instead
    private IDAO addressdao;

je pense que puisque tout le monde a écrit Pour DI, laissez-moi poser quelques questions..

1. lorsque vous avez une configuration de DI où toutes les implémentations réelles(pas les interfaces) qui vont être injectées dans une classe (pour E. g services à un contrôleur) pourquoi n'est-ce pas une sorte de codage dur?
2. Que faire si je veux changer l'objet à l'exécution? Par exemple, ma configuration dit déjà quand j'instancie MyController, injecter pour FileLogger comme ILogger. Mais je voudrais peut-être injecter DatabaseLogger.
3. chaque fois que je veux changer les objets dont mon AClass a besoin, je dois maintenant regarder en deux endroits - la classe elle-même et le fichier de configuration. Comment rendre la vie plus facile?
4. si la propriété D'AClass n'est pas injectée, est-il plus difficile de s'en débarrasser?
5. pour revenir à la première question. Si Utiliser new object () est mauvais, pourquoi injecter l'implémentation et non l'interface? Je pense que beaucoup d'entre vous disent que nous injectons en fait l'interface mais la configuration vous fait spécifier l'implémentation de cette interface ..pas au moment de l'exécution .. il est codé en dur lors de la compilation.

C'est basé sur la réponse @Adam n posté.

pourquoi PersonService n'a-t-il plus à se soucier du service des membres de groupe? Vous venez de mentionner que GroupMembership a plusieurs choses(objets/propriétés) dont il dépend. Si GMService était requis dans PService, vous l'auriez comme propriété. Vous pouvez vous moquer de ça, que vous l'ayez injecté ou non. La seule fois où je voudrais qu'il soit injecté, C'est si GMService avait des classes d'enfants plus spécifiques, ce que vous ne sauriez pas avant l'exécution. Alors vous devriez injecter la sous-classe. Ou si vous vouliez utiliser ça comme un simple ou un prototype. Pour être honnête, le fichier de configuration a tout en dur jusqu'à quelle sous-classe pour un type (interface) il va injecter au cours de la compilation.

MODIFIER

Un gentil commentaire par Jose Maria Arranz sur DI

DI augmente la cohésion en éliminant tout besoin de déterminer la direction de la dépendance et d'écrire n'importe quel code de colle.

faux. La direction des dépendances est sous forme XML ou sous forme d'annotations, vos dépendances sont écrites sous forme de code XML et annotation. XML et les annotations sont du code source.

DI réduit l'accouplement en rendant tous vos composants modulaires (c'est-à-dire remplaçables) et ont des interfaces bien définies entre eux.

faux. Vous n'avez pas besoin d'un cadre DI pour construire un code modulaire basé sur des interfaces.

à propos de remplaçable: avec un très simple .archive des propriétés et classe.forName vous pouvez définir quelles classes peuvent changer. Si TOUTE la classe de votre code peut être modifié, Java n'est pas pour vous, utilisez un langage de script. Soit dit en passant: les annotations ne peuvent pas être modifiées sans recompiler.

à mon avis, il n'y a qu'une seule raison pour les cadres DI: La réduction de la plaque de chaudière. Avec un système d'usine bien fait, vous pouvez faire la même chose, plus contrôlée et plus prévisible que votre cadre DI préféré, cadres DI promettent la réduction du code (XML et annotations sont aussi du code source). Le problème est que cette réduction de la plaque de chaudière est juste réel dans des cas très très très simples (une instance-par classe et similaire), parfois dans le monde réel choisir l'objet de service approprié n'est pas aussi facile que de mapper une classe à un objet singleton.

Dependency Injection means a way (actually any-way ) for one part of code (E. g une classe) pour avoir accès aux dépendances (autres parties du code, E. g d'autres classes, cela dépend de) d'une manière modulaire sans qu'ils soient codés en dur (de sorte qu'ils puissent changer OU être modifiés librement, ou même être chargés à un autre moment, selon les besoins)

(et le ps , oui, c'est devenu trop hype 25$ nom pour une plutôt simple, concept) , mon .25 cents

je sais qu'il y a déjà beaucoup de réponses, mais j'ai trouvé cela très utile: http://tutorials.jenkov.com/dependency-injection/index.html

Pas De Dépendance:

public class MyDao {

  protected DataSource dataSource =
    new DataSourceImpl("driver", "url", "user", "password");

  //data access methods...
  public Person readPerson(int primaryKey) {...}

}

dépendance:

public class MyDao {

  protected DataSource dataSource = null;

  public MyDao(String driver, String url, String user, String
 password){
    this.dataSource = new DataSourceImpl(driver, url, user, password);
  }

  //data access methods...
  public Person readPerson(int primaryKey)
  {...}

}

remarquez comment l'instanciation DataSourceImpl est déplacée dans un constructeur. Le constructeur prend quatre paramètres qui sont les quatre valeurs requises par la DataSourceImpl . Bien que le MyDao la classe dépend encore de ces quatre valeurs, elle ne satisfait plus ces dépendances elle-même. Ils sont fournis par n'importe quelle classe créant une instance MyDao .

les réponses populaires sont inutiles, car elles définissent l'injection de dépendance d'une manière qui n'est pas utile. Convenons que par "dépendance" nous entendons un autre objet préexistant dont notre objet X a besoin. Mais nous ne disons pas que nous faisons "injection de dépendance" quand nous disons

$foo = Foo->new($bar);

nous appelons cela passer des paramètres dans le constructeur. Nous avons fais régulièrement depuis que les constructeurs ont été inventés.

" dépendance l'injection" est considérée comme un type d ' "inversion de contrôle", ce qui signifie qu'une certaine logique est retirée de l'interlocuteur. Ce n'est pas le cas lorsque l'appelant passe en paramètres, donc si C'était DI, DI n'impliquerait pas une inversion de contrôle.

DI signifie qu'il y a un niveau intermédiaire entre l'appelant et le constructeur qui gère les dépendances. Un Makefile est un exemple simple d'injection de dépendances. Le "demandeur" est la personne tapant "make bar" sur la ligne de commande, et le "constructeur" est le compilateur. Le Makefile spécifie que la barre dépend de foo, et il fait un

gcc -c foo.cpp; gcc -c bar.cpp

avant de faire un

gcc foo.o bar.o -o bar

la personne tapant" make bar " n'a pas besoin de savoir que bar dépend de foo. La dépendance a été injectée entre "make bar" et gcc.

le but principal du niveau intermédiaire n'est pas seulement de passer dans les dépendances au constructeur, mais d'énumérer toutes les dépendances dans juste un endroit , et de les cacher du codeur (ne pas les faire fournir par le codeur).

habituellement, le niveau intermédiaire fournit des usines pour les objets construits, qui doivent fournir un rôle que chaque type d'objet demandé doit satisfaire. C'est parce qu'en ayant un niveau intermédiaire qui cache les détails de la construction, vous avez déjà encouru la pénalité d'abstraction imposée par les usines, donc vous pourriez aussi bien utiliser les usines.

L'injection de dépendance est une solution possible à ce que l'on pourrait généralement appeler l'exigence de l ' "obstruction de dépendance". L'obscurcissement de la dépendance est une méthode qui consiste à retirer la nature "évidente" du processus consistant à fournir une dépendance à une classe qui en a besoin et, par conséquent, à obscurcir, d'une manière ou d'une autre, la fourniture de ladite dépendance à ladite classe. Ce n'est pas nécessairement une mauvaise chose. En fait, en obscurcissant la façon dont une dépendance est fournie à une classe, alors quelque chose en dehors de la classe est responsable de créer la dépendance qui signifie, dans divers scénarios, une implémentation différente de la dépendance peut être fournie à la classe sans apporter de changements à la classe. C'est idéal pour passer d'un mode de production à un mode d'essai (par ex., en utilisant une dépendance de service "simulée").

malheureusement, la mauvaise partie est que certaines personnes ont supposé que vous avez besoin d'un cadre spécialisé pour faire l'obscurcissement de la dépendance et que vous êtes en quelque sorte "moindre" programmeur si vous choisissez de ne pas utiliser un cadre particulier pour le faire. Un autre mythe, extrêmement troublant, que beaucoup croient, est que l'injection de dépendance est le seul moyen de parvenir à l'obscurcissement de la dépendance. Ceci est manifestement et historiquement et évidemment faux à 100%, mais vous aurez du mal à convaincre certaines personnes qu'il y a des alternatives à l'injection de dépendance pour vos besoins d'obscurcissement de dépendance.

programmeurs ont compris la dépendance nécessité d'obfuscation depuis des années et de nombreuses solutions alternatives ont évolué avant et après l'injection de dépendance a été conçu. Il y a des motifs D'usine mais il y a aussi beaucoup d'options utilisant ThreadLocal où aucune injection à une instance particulière n'est nécessaire - la dépendance est effectivement injectée dans le thread qui a l'avantage de rendre l'objet disponible (via des méthodes de getter statiques de commodité) à n'importe quelle classe qui l'exige sans avoir à ajouter annotations aux classes qui l'exigent et mise en place complexe XML 'glue' pour y arriver. Lorsque vos dépendances sont requises pour la persistance (JPA/JDO ou autre), cela vous permet d'atteindre la "persistance tranaparente" beaucoup plus facilement et avec des classes de modèles de domaine et de modèles d'affaires composées uniquement de POJOs (c.-à-d. sans cadre spécifique/verrouillé dans les annotations).

du Livre", le Bien-fondé de Développeur Java: l'Essentiel des techniques de Java 7 et polyglotte de la programmation

DI est une forme particulière de Cio, où le processus de trouver vos dépendances est en dehors du contrôle direct de votre code en cours d'exécution.

exemple, nous avons 2 classes Client et Service . Client utilisera Service

public class Service {
    public void doSomeThingInService() {
        // ...
    }
}

Sans Injection De Dépendance

Voie 1)

public class Client {
    public void doSomeThingInClient() {
        Service service = new Service();
        service.doSomeThingInService();
    }
}

voie 2)

public class Client {
    Service service = new Service();
    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}

3)

public class Client {
    Service service;
    public Client() {
        service = new Service();
    }
    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}

1) 2) 3) Utilisation

Client client = new Client();
client.doSomeThingInService();

avantages

• Simple

désavantages

• Dur pour le test Client classe
• quand nous changeons Service constructeur, nous devons changer le code dans tout lieu créer Service objet

utiliser Injection De Dépendance

voie 1) injection du constructeur

public class Client {
    Service service;

    Client(Service service) {
        this.service = service;
    }

    // Example Client has 2 dependency 
    // Client(Service service, IDatabas database) {
    //    this.service = service;
    //    this.database = database;
    // }

    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}

utilisant

Client client = new Client(new Service());
// Client client = new Client(new Service(), new SqliteDatabase());
client.doSomeThingInClient();

voie 2) injection de Setter

public class Client {
    Service service;

    public void setService(Service service) {
        this.service = service;
    }

    public void doSomeThingInClient() {
        service.doSomeThingInService();
    }
}

utilisant

Client client = new Client();
client.setService(new Service());
client.doSomeThingInClient();

voie 3) Interface injection

Check https://en.wikipedia.org/wiki/Dependency_injection

= = =

maintenant, ce code est déjà suivi de Dependency Injection et il est plus facile pour le test Client classe.

Cependant, nous utilisons encore new Service() beaucoup de temps et il n'est pas bon quand changer Service constructeur. Pour la prévenir, nous pouvons utiliser di injecteur comme

1) Manuel Simple Injector

public class Injector {
    public static Service provideService(){
        return new Service();
    }

    public static IDatabase provideDatatBase(){
        return new SqliteDatabase();
    }
    public static ObjectA provideObjectA(){
        return new ObjectA(provideService(...));
    }
}

utilisant

Service service = Injector.provideService();

2) Utiliser bibliothèque: pour Android dagger2

avantages

• Faire des test plus facile
• lorsque vous changez le Service , vous avez seulement besoin de le changer dans la classe D'injecteur
• si vous utilisez Constructor Injection , lorsque vous regardez le constructeur de Client , vous verrez combien de dépendance Client classe

désavantages

• si vous utilisez l'utilisation Constructor Injection , l'objet Service est créé lorsque Client créé, parfois nous utilisons la fonction dans Client classe sans utilisation Service ainsi créé Service est gaspillé

injection de dépendance définition

https://en.wikipedia.org/wiki/Dependency_injection

Une dépendance est un objet qui peut être utilisé ( Service )

Une injection est le passage d'une dépendance ( Service ) à un objet dépendant ( Client ) qui l'utilisent

à partir du Livre Apress.Printemps.Persistance.avec.Hiberner.Oct.2010

Le but de l'injection de dépendance est de dissocier le travail de résoudre les composants logiciels externes de votre entreprise d'application logique.Sans injection de dépendance, les détails de comment un composant accès les services requis peuvent être embrouillés avec les code. Cela augmente non seulement le potentiel erreurs, ajoute du code gonfle, et amplifie les complexités d'entretien; il Couple les composants ensemble plus étroitement, ce qui rend difficile la modification des dépendances refactoring ou de test.

injection de dépendance (DI) est un de Design Patterns, qui utilise la caractéristique de base de OOP - la relation dans un objet avec un autre objet. Alors que l'héritage hérite d'un objet pour faire plus complexe et spécifique un autre objet, la relation ou l'association crée simplement un pointeur vers un autre objet à partir d'un objet en utilisant un attribut. La puissance de DI est en combinaison avec d'autres caractéristiques de OOP comme le sont les interfaces et le code de dissimulation. Supposons que nous ayons un client (abonné) dans le bibliothèque, qui peut emprunter un seul livre pour la simplicité.

Interface du livre:

package com.deepam.hidden;

public interface BookInterface {

public BookInterface setHeight(int height);
public BookInterface setPages(int pages);   
public int getHeight();
public int getPages();  

public String toString();
}

ensuite, nous pouvons avoir plusieurs sortes de livres; un de type est la fiction:

package com.deepam.hidden;

public class FictionBook implements BookInterface {
int height = 0; // height in cm
int pages = 0; // number of pages

/** constructor */
public FictionBook() {
    // TODO Auto-generated constructor stub
}

@Override
public FictionBook setHeight(int height) {
  this.height = height;
  return this;
}

@Override
public FictionBook setPages(int pages) {
  this.pages = pages;
  return this;      
}

@Override
public int getHeight() {
    // TODO Auto-generated method stub
    return height;
}

@Override
public int getPages() {
    // TODO Auto-generated method stub
    return pages;
}

@Override
public String toString(){
    return ("height: " + height + ", " + "pages: " + pages);
}
}

maintenant l'abonné peut avoir l'association au livre:

package com.deepam.hidden;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Subscriber {
BookInterface book;

/** constructor*/
public Subscriber() {
    // TODO Auto-generated constructor stub
}

// injection I
public void setBook(BookInterface book) {
    this.book = book;
}

// injection II
public BookInterface setBook(String bookName) {
    try {
        Class<?> cl = Class.forName(bookName);
        Constructor<?> constructor = cl.getConstructor(); // use it for parameters in constructor
        BookInterface book = (BookInterface) constructor.newInstance();
        //book = (BookInterface) Class.forName(bookName).newInstance();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
    return book;
}

public BookInterface getBook() {
  return book;
}

public static void main(String[] args) {

}

}

toutes les trois classes peuvent être cachées pour sa propre implémentation. Maintenant nous pouvons utiliser ce code pour DI:

package com.deepam.implement;

import com.deepam.hidden.Subscriber;
import com.deepam.hidden.FictionBook;

public class CallHiddenImplBook {

public CallHiddenImplBook() {
    // TODO Auto-generated constructor stub
}

public void doIt() {
    Subscriber ab = new Subscriber();

    // injection I
    FictionBook bookI = new FictionBook();
    bookI.setHeight(30); // cm
    bookI.setPages(250);
    ab.setBook(bookI); // inject
    System.out.println("injection I " + ab.getBook().toString());

    // injection II
    FictionBook bookII = ((FictionBook) ab.setBook("com.deepam.hidden.FictionBook")).setHeight(5).setPages(108); // inject and set
    System.out.println("injection II " + ab.getBook().toString());      
}

public static void main(String[] args) {
    CallHiddenImplBook kh = new CallHiddenImplBook();
    kh.doIt();
}
}

il y a beaucoup différentes façons d'utiliser l'injection de dépendance. Il est possible de le combiner avec Singleton, etc., mais encore en basic il est seulement association réalisée en créant l'attribut de type d'objet à l'intérieur d'un autre objet. L'utilité est seulement et uniquement en fonction, de ce code, nous devrions écrire encore et encore est toujours préparé et fait pour nous avant. C'est pourquoi DI si étroitement lié avec L'Inversion de contrôle (coi) qui signifie, que notre programme passe le contrôle d'un autre module courant, ce qui ne les injections de haricots à notre code. (Chaque objet, qui peut être injecté peut être signé ou est considéré comme un Haricot.) Par exemple au printemps, il est fait par la création et l'initialisation ApplicationContext conteneur, qui fait ce travail pour nous. Nous créons simplement dans notre code le contexte et invoquons l'initialisation des haricots. En ce moment, l'injection a été faite automatiquement.

en mots simples l'injection de dépendance (DI) est le moyen de supprimer les dépendances ou le couplage serré entre différents objets. L'Injection de dépendances donne un comportement cohésif à chaque objet.

DI est la mise en œuvre du directeur du CIO de printemps qui dit "ne nous appelez pas nous vous appellerons". Utiliser le programmeur d'injection de dépendances n'a pas besoin de créer d'objet en utilisant le nouveau mot-clé.

objets sont une fois chargés dans un conteneur à ressort et puis nous réutilisez-les chaque fois que nous en avons besoin en récupérant ces objets à partir du conteneur de printemps en utilisant la méthode getBean(chaîne de Beanname).

l'injection de dépendance est au cœur du concept lié au cadre de ressort.Tout en créant le cadre de n'importe quel ressort de projet peut jouer un rôle vital,et ici l'injection de dépendance viennent en pichet.

en fait,supposons qu'en java vous avez créé deux classes différentes comme classe A et Classe B, et quelle que soit la fonction disponible dans la Classe B que vous voulez utiliser dans la classe a, donc à ce moment-là l'injection de dépendance peut être utilisée. où vous pouvez créer un objet d'une classe dans autre, de la même manière vous pouvez injecter une classe entière dans une autre classe pour la rendre accessible. de cette façon, la dépendance peut être surmontée.

L'INJECTION DE DÉPENDANCE CONSISTE SIMPLEMENT À COLLER DEUX CLASSES ET EN MÊME TEMPS À LES SÉPARER.

l'Injection de Dépendance (DI) est la partie de l'Inversion de Dépendance Principe (DIP) de la pratique, qui est aussi appelé Inversion de Contrôle (IoC). Fondamentalement, vous devez faire DIP parce que vous voulez rendre votre code plus modulaire et unité testable, au lieu d'un seul système monolithique. Vous commencez donc à identifier les parties du code qui peuvent être séparées de la classe et abstraites. Maintenant, la mise en œuvre de l'abstraction doit être injectée à l'extérieur de la classe. Normalement, cela peut être fait via le constructeur. Ainsi, vous créez un constructeur qui accepte l'abstraction comme paramètre, et cela s'appelle l'injection de dépendances (via le constructeur). Pour plus d'explications sur le conteneur DIP, DI, et IoC vous pouvez lire ici

Dependency Injection est un type de mise en œuvre du" Inversion de contrôle " principe sur lequel est basée la construction de cadres.

Cadres , comme indiqué dans "Modèle de Conception" de GoF sont des classes qui implémentent les principaux flux de contrôle logique de sensibilisation au développeur de faire que, de cette façon, les Cadres de réaliser l'inversion de contrôle principe.

une façon de mettre en œuvre en tant que technique, et non en tant que hiérarchie de classe, ce principe du CIO n'est qu'une Injection de dépendance.

DI consiste principalement à déléguer la mise en correspondance des instances de classes et de type de référence à ces instances, à une "entité" externe: un objet, une classe statique, un composant, un framework, etc...

classes instances sont les " dépendances ", la liaison externe de l'appel composant avec l'instance de classe par la référence il est le " injection ".

évidemment, vous pouvez mettre en œuvre cette technique de plusieurs façons comme vous le voulez du point de vue OOP, voir par exemple injection constructeur , injection setter , injection interface .

déléguer un tiers pour effectuer la tâche de match a ref à un objet, il est très utile lorsque vous souhaitez séparer complètement un composant qui a besoin de certains services de la même mise en œuvre des services.

ainsi, lors de la conception de composants, vous pouvez vous concentrer exclusivement sur leur architecture et leur logique spécifique, en vous fiant aux interfaces pour collaborer avec d'autres objets sans vous soucier de tout type de mise en œuvre des changements d'objets/services utilisés, même si le même objet que vous utilisez sera totalement remplacé (respect évident de l'interface).

je proposerais une définition légèrement différente, courte et précise de ce Qu'est L'Injection de dépendance, en se concentrant sur le but principal, et non sur les moyens techniques (suivant le long de ici ):

L'Injection de dépendance est le processus de création de la statique, apatride graphique des objets de service, où chaque service est réglée par ses dépendance.

Les objets que nous créons dans nos applications (indépendamment du fait que nous utilisions Java, C# ou d'autres langages orientés objet) appartiennent généralement à l'une des deux catégories suivantes: les "objets de service" (modules) apatrides, statiques et globaux, et les "objets de données"stateful, dynamiques et locaux.

le graphique du module - le graphique des objets de service - est typiquement créé au démarrage de l'application. Cela peut être fait en utilisant un conteneur, comme un ressort, mais peut aussi être fait manuellement, en passant des paramètres aux constructeurs d'objets. Les deux méthodes les ont leurs avantages et inconvénients, mais un cadre n'est certainement pas nécessaire D'utiliser DI dans votre application.

une condition est que les services doivent être paramétrés par leurs dépendances. Ce que cela signifie exactement dépend du langage et de l'approche adoptée dans un système donné. Habituellement, cela prend la forme de paramètres de constructeur, mais l'utilisation de setters est également une option. Cela signifie également que les dépendances d'un service sont cachées (lors de l'invocation d'une méthode de service) aux utilisateurs de la service.

quand utiliser? Je dirais que chaque fois que l'application est assez grande pour encapsuler la logique dans des modules séparés, avec un graphe de dépendance entre les modules donne un gain de lisibilité et d'explorabilité du code.