Dépendance à l’injection de dépendance ?

StackOverflow https://stackoverflow.com/questions/42706

  •  09-06-2019
  •  | 
  •  

Question

Y a-t-il un inconvénient ?Je me sens presque dépendant maintenant.Chaque fois qu'un projet dépasse une certaine taille, vous ressentez presque une réaction allergique aux modèles standard et le recâblez immédiatement avec un framework d'injection de dépendances.

Le plus gros problème que j'ai trouvé est que cela peut prêter à confusion pour les autres développeurs qui viennent tout juste de l'apprendre.

De plus, je me sentirais beaucoup mieux si cela faisait partie du langage que j'utilisais.Cependant, pour Java au moins, il existe quelques bibliothèques très légères qui sont plutôt bonnes.

Pensées?De mauvaises expériences ?Ou simplement arrêter de s'en inquiéter ?

[MODIFIER] Objet :Description de l'injection de dépendance elle-même

Désolé d'être vague. Martin Fowler le décrit probablement BEAUCOUP mieux que je ne pourrais jamais...pas besoin de gaspiller l'effort.

Par coïncidence, cela confirme un point à ce sujet, à savoir que ce n'est pas encore largement pratiqué et qu'il peut avoir tendance à constituer un obstacle lors du travail en équipe si tout le monde n'est pas au courant.

Était-ce utile?

La solution

J'ai essayé de décrire certains des inconvénients possibles dans un article de blog ici : http://kevin-berridge.blogspot.com/2008/06/ioc-and-di-complexity.html

Autres conseils

Le problème que j'ai avec DI est le même problème que j'ai avec COM et avec tout code qui ressemble à :

i = GetServiceOrInterfaceOrObject(...)

Le problème est qu’un tel système ne peut pas être compris à partir du code.Il doit y avoir une documentation quelque part [ailleurs] qui définit quel service/interface/objet peut être demandé par le service/interface/objet X.Cette documentation doit non seulement être maintenue, mais disponible aussi facilement que la source.

À moins que le document ne soit très bien rédigé, il n'est souvent pas facile de voir les relations entre les objets.Parfois, les relations sont temporelles, ce qui les rend encore plus difficiles à découvrir.

J'aime le principe KISS et je crois fermement à l'utilisation du bon outil pour le travail.Si les avantages de DI, pour un projet donné, l'emportent sur la nécessité d'écrire du code compréhensible, utilisez-le.

De plus, je me sentirais beaucoup mieux si cela faisait partie de la langue que j'utilisais.

Pour information, il existe une injection de dépendances très simple et fonctionnelle dans le cadre du JDK 6.Si vous avez besoin d’une injection de dépendances légère et simple, utilisez-la.

En utilisant ServiceLoader class, vous pouvez demander un service (ou plusieurs implémentations du service) basé sur une classe :

 package dependecyinjection;  
 import java.util.ServiceLoader;  

 public abstract class FooService {  

     public static FooService getService() {  
         ServiceLoader<FooService> loader = ServiceLoader.load(FooService.class);  

         for (FooService service : loader) {  
             return provider;  
         }  

         throw new Exception ("No service");  
     }  

     public abstract int fooOperation();  

 }  

 package dependecyinjection;  
 public class FooImpl extends FooService {  
     @Override  
     public int fooOperation() {  
         return 2;  
     }  
 }

Comment ServiceLoader définit-il les implémentations de service renvoyées ?

Dans votre dossier de projet, créez un dossier nommé META-INF/services et créez un fichier nommé dependencyinjection.FooService.Ce fichier contient une ligne pointant vers l'implémentation du service.Dans ce cas:dependecyinjection.FooImpl

Ce n’est pas encore largement connu.

Je suis un grand fidèle en IO, mais j'ai vu des projets avec d'énormes fichiers de configuration XML que personne ne comprend.Attention donc à la programmation en XML.

À mon avis, les inconvénients majeurs sont la courbe d'apprentissage (comme vous le soulignez) et la possibilité que l'abstraction supplémentaire rende le débogage plus difficile (ce qui fait également partie de la courbe d'apprentissage).

Pour moi, DI me semble être plus approprié pour les systèmes plus grands et complexes - pour les petites applications ponctuelles, cela peut entraîner une sur-architecture de l'application, en gros, l'architecture prend plus de temps de développement à respecter qu'elle. pourra jamais compenser par la valeur qu’il offre.

Arrêtez simplement de vous en soucier.Je pense qu'avec le temps, les techniques IoC deviendront une seconde nature pour la plupart des développeurs.J'essaie d'enseigner cela aux développeurs ici au travail et j'ai du mal à faire passer le message car cela ne semble pas naturel par rapport à la façon dont nous avons toujours fait les choses.ce qui se trouvait être dans le mauvais sens.De plus, les développeurs à la fois nouveaux sur IoC et nouveaux sur un projet que je trouve ont encore plus de difficultés.Ils sont habitués à utiliser l'EDI pour suivre la trace des dépendances afin de comprendre comment le tout « s'articule ».Ces informations sont souvent écrites en XML obscur.

Pourriez-vous ajouter un lien ou deux pour expliquer ce qu'est réellement l'injection de dépendance, pour ceux d'entre nous qui jouent le jeu à la maison ?Le article wikipédia est amusant, mais pas très instructif.

Le seul inconvénient auquel je peux penser est une légère diminution des performances due à des appels virtuels constants :)

@Blorgbeard : http://www.martinfowler.com/articles/injection.html est probablement l'un des meilleurs articles sur le sujet

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top