Supposons que 1001 clients construisent directement leurs dépendances plutôt que d'accepter les injections. La refactorisation du 1001 n'est pas une option selon notre patron. En fait, nous ne sommes même pas autorisés à accéder à leur source, uniquement aux fichiers de classe.
Ce que nous sommes censés faire, c'est «moderniser» le système que ces 1001 clients traversent. Nous pouvons refactoriser tout ce que nous aimons. Les dépendances font partie de ce système. Et certaines de ces dépendances que nous sommes censés changer pour avoir une nouvelle implémentation.
Ce que nous aimerions faire, c'est avoir la possibilité de configurer différentes implémentations de dépendances pour satisfaire cette multitude de clients. Malheureusement, DI ne semble pas être une option car les clients n'acceptent pas les injections de constructeurs ou de poseurs.
Les options:
1) Refactoriser la mise en œuvre du service que les clients utilisent pour qu'il fasse ce dont les clients ont besoin maintenant. Bang, nous avons terminé. Pas flexible. Pas complexe.
2) Refactorisez l'implémentation afin qu'elle délègue son travail à une autre dépendance qu'elle acquiert via une usine. Nous pouvons maintenant contrôler quelle implémentation ils utilisent tous en refactorisant l'usine.
3) Refactorisez l'implémentation afin qu'elle délègue son travail à une autre dépendance qu'elle acquiert via un localisateur de services. Maintenant, nous pouvons contrôler quelle implémentation ils utilisent tous en configurant le localisateur de service qui pourrait simplement être une hashmap
chaîne de caractères vers des objets avec un petit casting en cours.
4) Quelque chose auquel je n'ai même pas encore pensé.
L'objectif:
Minimisez les dommages causés à la conception en faisant glisser l'ancien code client mal conçu vers l'avenir sans ajouter de complexité inutile.
Les clients ne doivent pas connaître ou contrôler l'implémentation de leurs dépendances mais ils insistent pour les construire avec new
. Nous ne pouvons pas contrôler le new
mais nous contrôlons la classe qu'ils construisent.
Ma question:
Qu'est-ce que j'ai omis de considérer?
avez-vous vraiment besoin d'une possibilité de configuration entre différentes implémentations? Dans quel but?
Agilité. Beaucoup d'inconnues. La direction souhaite un potentiel de changement. Ne perdez votre dépendance vis-à-vis du monde extérieur. Test également.
avez-vous besoin d'une mécanique d'exécution ou simplement d'une mécanique de compilation pour basculer entre différentes implémentations? Pourquoi?
La mécanique du temps de compilation est probablement suffisante. Sauf pour les tests.
De quelle granularité avez-vous besoin pour basculer entre les implémentations? Tout à la fois? Par module (contenant chacun un groupe de classes)? Par classe?
Sur les 1001, un seul est exécuté à travers le système à la fois. Changer ce que tous les clients utilisent en même temps est très bien. Le contrôle individuel des dépendances est cependant probablement important.
qui doit contrôler l'interrupteur? Uniquement votre / votre équipe de développeurs? Un administrateur? Chaque client seul? Ou les développeurs de maintenance pour le code du client? Alors, comment la mécanique doit-elle être facile / robuste / infaillible?
Dev pour les tests. Administrateur lorsque les dépendances matérielles externes changent. Il doit être facile à tester et à configurer.
Notre objectif est de montrer que le système peut être refait rapidement et modernisé.
cas d'utilisation réel du commutateur d'implémentation?
Premièrement, certaines données seront fournies par le logiciel jusqu'à ce que la solution matérielle soit prête.