Injection de dépendance et modèle de conception Singleton

Singletons sont comme le communisme: ils ont tous les deux un son génial sur le papier, mais exploser avec des problèmes dans la pratique.

le motif singleton met un accent disproportionné sur la facilité d'accès aux objets. Il évite complètement le contexte en exigeant que chaque consommateur utilise un objet Appdomaine-scoped, ne laissant aucune option pour varier les implémentations. Il intègre les connaissances d'infrastructure dans vos cours (l'appel à GetInstance() ) tout en ajoutant exactement zéro puissance expressive. Il diminue en fait votre pouvoir expressif, parce que vous ne pouvez pas changer l'implémentation utilisée par une classe sans la changer pour tous d'entre eux. Vous ne pouvez tout simplement pas ajouter des pièces uniques de fonctionnalité.

aussi, lorsque la classe Foo dépend de Logger.GetInstance() , Foo cache effectivement ses dépendances aux consommateurs. Cela signifie que vous ne pouvez pas pleinement comprendre Foo ou l'utiliser avec confiance à moins que vous lisez sa source et découvrez qu'elle dépend de Logger . Si vous n'avez pas la source, cela limite votre capacité à comprendre et à utiliser efficacement le code dont vous dépendez.

le modèle singleton, tel qu'il est mis en œuvre avec des propriétés/méthodes statiques, n'est guère plus qu'un piratage autour de la mise en œuvre d'une infrastructure. Il vous limite de multiples façons tout en n'offrant aucun avantage discernable sur les alternatives. Vous pouvez l'utiliser comme vous le souhaitez, mais comme il il ne devrait jamais s'agir d'une pratique recommandée.

D'autres ont très bien expliqué le problème avec les singletons en général. Je voudrais juste ajouter une remarque sur le cas spécifique de l'Enregistreur. Je suis d'accord avec vous sur le fait que ce n'est généralement pas un problème d'accéder à un Logger (ou au Logger racine, pour être précis) en tant que singleton, via une méthode statique getInstance() ou getRootLogger() . (sauf si vous voulez voir ce qui est enregistré par la classe que vous testez - mais d'après mon expérience, je ne peux pas me souvenir de tels cas où cela était nécessaire. Puis de nouveau, pour les autres, ce serait peut-être plus préoccupante).

IMO habituellement, un enregistreur simple n'est pas un souci, car il ne contient aucun état pertinent à la classe que vous testez. C'est, de l'enregistreur, l'état (et de ses éventuelles modifications) ont aucun effet sur l'état de la classe testée. Cela ne rend donc pas vos tests unitaires plus difficiles.

l'alternative serait d'injecter le logger via le constructeur, à (presque) chaque classe de votre application. Pour la cohérence des interfaces, il faut l'injecter même si la classe en question n'enregistre rien à l'heure actuelle - l'alternative serait que lorsque vous découvrez à un moment donné que maintenant vous devez Logger quelque chose de cette classe, vous avez besoin d'un logger, donc vous avez besoin d'ajouter un paramètre de constructeur pour DI, cassant tout le code client. Je n'aime pas ces deux options, et je pense que l'utilisation de DI pour la journalisation serait juste compliquer ma vie afin de se conformer à une règle théorique, sans aucun bénéfice concret.

donc ma ligne de fond est: une classe qui est utilisé (presque) universellement, mais ne contient pas l'état pertinent à votre application, peut être mis en œuvre en toute sécurité comme Singleton .

c'est surtout, mais pas entièrement à propos des tests. Les Singleton étaient populaires parce qu'il était facile de les consommer, mais il y a un certain nombre d'inconvénients à Singleton.

• difficile à tester. Ce qui veut dire comment je m'assure que l'enregistreur fasse la bonne chose.
• difficile à tester. Ce qui signifie que si je teste le code qui utilise l'enregistreur, mais ce n'est pas l'objet de mon test, je dois quand même m'assurer que mon env de test supporte l'enregistreur
• parfois vous ne voulez pas un singlton, mais plus de flexibilité

DI Vous donne la consommation facile de vos classes dépendantes - il suffit de le mettre dans le constructeur args, et le système fournit pour vous - tout en vous donnant l'essai et la flexibilité de construction.

le seul moment où vous devriez utiliser un Singleton au lieu d'une Injection de dépendance est si le Singleton représente une valeur immuable, telle que List.Vide ou similaire (en supposant des listes immuables).

Le gut check pour un Singleton doit être "aurais-je être bien si c'était une variable globale au lieu d'un Singleton?"Si ce n'est pas le cas, vous utilisez le modèle Singleton pour décrire une variable globale, et vous devriez envisager une approche différente.

vient de vérifier l'article Monostate - c'est une alternative astucieuse à Singleton, mais il a quelques propriétés de wierd:

class Mono{
    public static $db;
    public function setDb($db){
       self::$db = $db;
    }

}

class Mapper extends Mono{
    //mapping procedure
    return $Entity;

    public function save($Entity);//requires database connection to be set
}

class Entity{
public function save(){
    $Mapper = new Mapper();
    $Mapper->save($this);//has same static reference to database class     
}

$Mapper = new Mapper();
$Mapper->setDb($db);

$User = $Mapper->find(1);
$User->save();

N'est pas ce genre d'effrayant-parce que le Mapper dépend vraiment de la connexion à la base de données pour effectuer save () - mais si un autre mapper a été créé avant - il peut ignorez cette étape dans l'acquisition de ses dépendances. Bien que soigné, il est aussi un peu bordélique, n'est-ce pas?

il existe d'autres alternatives à Singleton: les modèles par procuration et MonoState.

http://www.objectmentor.com/resources/articles/SingletonAndMonostate.pdf

comment le motif par procuration peut-il être utilisé pour remplacer un singleton?