Utilisation de la réflexion en usine

Le but de l'usine modèle est de séparer un peu de code du type à l'exécution d'un objet qu'il consomme:

//This code doesn't need to know that the factory is returning
//an object of type `com.example.parties.SurpriseParty`
AbstractParty myParty = new PartyFactory().create(...);

À l'aide de ce code, le PartyFactory est exclusivement responsable de la détermination ou de savoir exactement ce type à l'exécution doivent être utilisés.

Vous êtes renoncer à cette prestation en passant le nom pleinement qualifié de la classe dont vous avez besoin. Comment est-ce...

//This code obviously DOES know that the factory is returning
//an object of type `com.example.parties.SurpriseParty`.
//Now only the compiler doesn't know or enforce that relationship.
AbstractParty myParty = new PartyFactory().create("com.example.parties.SurpriseParty");

... tout simplement déclarer myParty comme étant de type com.example.parties.SurpriseParty? À la fin de votre code est tout aussi couplé, mais vous avez renoncé statique type de vérification. Cela signifie que vous êtes encourir moins de pas de bénéfices, tandis que l'abandon de certains des avantages de Java étant fortement typé. Si vous supprimez com.example.parties.SurpriseParty votre code sera toujours compilé, votre IDE vous donnera pas de messages d'erreur et vous ne serez pas réaliser qu'il y a une relation entre ce code et com.example.parties.SurpriseParty jusqu'à l'exécution - qui est mauvais.

À tout le moins, je vous conseille au moins de modifier ce code afin que la méthode de l'argument est un simple nom de la classe, pas un nom complet:

//I took the liberty of renaming this class and it's only method
public class MyPartyFactory{

    public Party create(String name)
    {
      //TODO: sanitize `name` - check it contains no `.` characters
      Class c = Class.forName("com.example.parties."+name);
      //I'm going to take for granted that I don't have to explain how or why `party` shouldn't be an instance variable.
      Party party = (PersonalParty)c.newInstance();
      return party;
    }
}

Suivante: est-ce une mauvaise pratique de l'utilisation Class.forName(...)? Cela dépend de ce que l'alternative est, et la relation entre ces String arguments (name) et les classes de cette usine. Si l'alternative est un grand conditionnelle:

if("SurpriseParty".equals(name) {
    return new com.example.parties.SurpriseParty();
}
else if("GoodbyeParty".equals(name)) {
    return new com.example.parties.GoodbyeParty();
}
else if("PartyOfFive".equals(name)) {
    return new com.example.parties.PartyOfFive();
}
else if(/* ... */) {
    //...
}
//etc, etc etc

... ce n'est pas évolutive. Car il est évident observables relation entre les noms de l'exécution des types de cette usine qui fabrique et la valeur de la name argument, Vous devriez envisager d'utiliser Class.forName à la place. De cette façon, votre Factory objet est protégé besoin d'un changement de code chaque fois que vous ajoutez un nouveau Party type de système.

---

Quelque chose que vous pourriez envisager est l'aide de l' AbstractFactory motif de la place. Si votre consommation de code ressemble à ceci:

AbstractParty sParty = new PartyFactory().create("SurpriseParty");
AbstractParty gbParty = new PartyFactory().create("GoodByeParty");

... où il y a un nombre limité de souvent survenant partie des types qui sont demandées, vous devriez envisager d'avoir des méthodes différentes pour ces différents types de parties:

public class PartyFactory {

    public Party getSurpriseParty() { ... }
    public Party getGoodByeParty() { ... }

}

... qui vous permettra d'exploiter Java du typage statique.

Cette solution n'est, cependant, signifie que chaque fois que vous ajoutez un nouveau type de Party vous devez modifier le réglage d'usine de l'objet, de sorte que la réflexion de la solution ou de la AbstractFactory est une meilleure solution dépend vraiment de combien de fois et combien de temps vous serez l'ajout de Party types. Un nouveau type de tous les jours? Utiliser la réflexion. Un nouveau parti, le type de chaque décennie? Utiliser un AbstractFactory.

Vous pouvez l'utiliser pour une API où vous fournir une API et XML configfile où les utilisateurs peuvent ajouter les noms de classe de leur plugin. Alors, oui, vous pouvez utiliser cette