Gestion des constructeurs avec de nombreux paramètres dans Java 1.4

Question

Dans certains de nos projets, il y a une hiérarchie de classes qui ajoute plus de paramètres qu'il va en bas de la chaîne. Au fond, certaines classes peuvent avoir jusqu'à 30 paramètres, dont 28 sont transmis dans le super constructeur.

Je vais vous reconnaissez que l'utilisation automatisée de la DI au travers de quelque chose comme Guice serait bien, mais à cause de certaines raisons techniques, ces projets sont soumis à des contraintes de Java 1.4.

Une convention de l'organisation de la arguments par ordre alphabétique, par type de ne pas travailler parce que si un type est refait (le Cercle vous avez été en passant par l'argument 2 est maintenant une Forme), il peut soudainement être hors de vue.

Cette question est peut-être spécifique et lourde avec des "Si c'est votre problème, vous le faites mal au niveau de la conception de" les critiques, mais je suis juste à la recherche de tout les points de vue.

Answer 1

Le Générateur de Modèle de Conception pourrait aider. Considérons l'exemple suivant

public class StudentBuilder
{
    private String _name;
    private int _age = 14;      // this has a default
    private String _motto = ""; // most students don't have one

    public StudentBuilder() { }

    public Student buildStudent()
    {
        return new Student(_name, _age, _motto);
    }

    public StudentBuilder name(String _name)
    {
        this._name = _name;
        return this;
    }

    public StudentBuilder age(int _age)
    {
        this._age = _age;
        return this;
    }

    public StudentBuilder motto(String _motto)
    {
        this._motto = _motto;
        return this;
    }
}

Ceci nous permet d'écrire un code comme

Student s1 = new StudentBuilder().name("Eli").buildStudent();
Student s2 = new StudentBuilder()
                 .name("Spicoli")
                 .age(16)
                 .motto("Aloha, Mr Hand")
                 .buildStudent();

Si nous avons laissé un champ obligatoire (sans doute le nom est requis) alors nous pouvons avoir l'Étudiant constructeur lèvera une exception lorsqu'un paramètre est null. Et il nous permet par défaut d'option et/ou des arguments sans avoir besoin de garder une trace de tout type d'argument, étant donné que toute commande de ces appels fonctionnera tout aussi bien.

Answer 2

Pouvez-vous encapsuler des paramètres liés dans un objet?

par exemple, si les paramètres sont comme

MyClass(String house, String street, String town, String postcode, String country, int foo, double bar) {
  super(String house, String street, String town, String postcode, String country);
  this.foo = foo;
  this.bar = bar;
 

alors vous pourriez plutôt avoir:

MyClass(Address homeAddress, int foo, double bar) {
  super(homeAddress);
  this.foo = foo;
  this.bar = bar;
}
 

Answer 3

Ce que vous voulez probablement faire est d'avoir une classe Builder. Ensuite, vous feriez quelque chose comme ça:

 MyObject obj = new MyObjectBuilder().setXxx(myXxx)
                                    .setYyy(myYyy)
                                    .setZzz(myZzz)
                                    // ... etc.
                                    .build();
 

Voir page 8 et suivantes de cette présentation de Josh Bloch (PDF), ou de cet article sur Effective Java

Answer 4

Comme vous êtes limité à Java 1.4, si vous voulez DI, alors Spring serait une option très décente. DI n'est utile que dans les endroits où les paramètres du constructeur sont des services ou quelque chose qui ne varie pas pendant l'exécution.

Si vous avez tous ces différents constructeurs parce que vous voulez des options variables sur la façon de construire un objet, vous devriez sérieusement envisager d'utiliser le modèle Builder.

Answer 5

La meilleure solution est de ne pas avoir trop de paramètres dans le constructeur. Seuls les paramètres de vraiment nécessaire dans le constructeur, sont des paramètres qui sont nécessaires pour initialiser correctement l'objet. Vous pouvez avoir des constructeurs avec plusieurs paramètres, mais aussi d'avoir un constructeur avec un minimum de paramètres. Le supplément de constructeurs d'appel ce simple constructeur et après que les organismes de normalisation pour définir les autres paramètres. De cette façon, vous pouvez éviter de la chaîne de problème avec de plus en plus params, mais aussi avoir une certaine commodité des constructeurs.