Construire de grands objets immuables sans utiliser de constructeurs ayant de longues listes de paramètres

J'ai de gros objets (plus de 3 champs) qui peuvent et doivent être immuables. Chaque fois que je rencontre ce cas, j'ai tendance à créer des abominations de constructeur avec de longues listes de paramètres.

Cela ne semble pas correct, il est difficile à utiliser et la lisibilité en souffre.

C'est encore pire si les champs sont une sorte de type de collection comme des listes. Un simple addSibling(S s)faciliterait tellement la création d'objet mais rendrait l'objet mutable.

Qu'est-ce que vous utilisez dans de tels cas?

Je suis sur Scala et Java, mais je pense que le problème est indépendant du langage tant que le langage est orienté objet.

Des solutions auxquelles je peux penser:

1. "Abominations de constructeur avec de longues listes de paramètres"
2. Le modèle du constructeur

Eh bien, vous voulez à la fois un objet plus facile à lire et immuable une fois créé?

Je pense qu'une interface fluide CORRECTEMENT FAITE vous aiderait.

Cela ressemblerait à ceci (exemple purement inventé):

final Foo immutable = FooFactory.create()
    .whereRangeConstraintsAre(100,300)
    .withColor(Color.BLUE)
    .withArea(234)
    .withInterspacing(12)
    .build();

J'ai écrit «CORRECTEMENT FAIT» en gras parce que la plupart des programmeurs Java se trompent d'interface couramment et polluent leur objet avec la méthode nécessaire pour construire l'objet, ce qui est bien sûr complètement faux.

L'astuce est que seule la méthode build () crée réellement un Foo (donc vous Foo peut être immuable).

FooFactory.create () , whereXXX (..) et withXXX (..) créent tous «autre chose».

Ce quelque chose d'autre peut être une FooFactory, voici une façon de le faire ...

Votre FooFactory ressemblerait à ceci:

// Notice the private FooFactory constructor
private FooFactory() {
}

public static FooFactory create() {
    return new FooFactory();
}

public FooFactory withColor( final Color col ) {
    this.color = color;
    return this;
}

public Foo build() {
    return new FooImpl( color, and, all, the, other, parameters, go, here );
}

Dans Scala 2.8, vous pouvez utiliser des paramètres nommés et par défaut ainsi que la copyméthode sur une classe de cas. Voici un exemple de code:

case class Person(name: String, age: Int, children: List[Person] = List()) {
  def addChild(p: Person) = copy(children = p :: this.children)
}

val parent = Person(name = "Bob", age = 55)
  .addChild(Person("Lisa", 23))
  .addChild(Person("Peter", 16))

Eh bien, considérez ceci sur Scala 2.8:

case class Person(name: String, 
                  married: Boolean = false, 
                  espouse: Option[String] = None, 
                  children: Set[String] = Set.empty) {
  def marriedTo(whom: String) = this.copy(married = true, espouse = Some(whom))
  def addChild(whom: String) = this.copy(children = children + whom)
}

scala> Person("Joseph").marriedTo("Mary").addChild("Jesus")
res1: Person = Person(Joseph,true,Some(Mary),Set(Jesus))

Cela a son lot de problèmes, bien sûr. Par exemple, essayez de faire espouseet Option[Person], puis de marier deux personnes. Je ne peux pas penser à un moyen de résoudre cela sans recourir à un private varet / ou un privateconstructeur plus une usine.

Voici quelques autres options:

Option 1

Rendez l'implémentation elle-même mutable, mais séparez les interfaces auxquelles elle expose mutable et immuable. Ceci est tiré de la conception de la bibliothèque Swing.

public interface Foo {
  X getX();
  Y getY();
}

public interface MutableFoo extends Foo {
  void setX(X x);
  void setY(Y y);
}

public class FooImpl implements MutableFoo {...}

public SomeClassThatUsesFoo {
  public Foo makeFoo(...) {
    MutableFoo ret = new MutableFoo...
    ret.setX(...);
    ret.setY(...);
    return ret; // As Foo, not MutableFoo
  }
}

Option 2

Si votre application contient un ensemble important mais prédéfini d'objets immuables (par exemple, des objets de configuration), vous pouvez envisager d'utiliser le framework Spring .

Il est utile de se rappeler qu'il existe différents types d'immuabilité . Pour votre cas, je pense que l'immuabilité "popsicle" fonctionnera très bien:

Immuabilité popsicle: c'est ce que j'appelle fantasque un léger affaiblissement de l'immuabilité à écriture unique On pourrait imaginer un objet ou un champ qui est resté modifiable pendant un petit moment lors de son initialisation, puis s'est «figé» à jamais. Ce type d'immuabilité est particulièrement utile pour les objets immuables qui se référencent circulairement les uns les autres, ou les objets immuables qui ont été sérialisés sur le disque et lors de la désérialisation doivent être «fluides» jusqu'à ce que tout le processus de désérialisation soit terminé, auquel point tous les objets peuvent être congelé.

Donc, vous initialisez votre objet, puis définissez un indicateur de "gel" d'une sorte indiquant qu'il n'est plus accessible en écriture. De préférence, vous cacheriez la mutation derrière une fonction afin que la fonction soit toujours pure pour les clients consommant votre API.

Vous pouvez également faire en sorte que les objets immuables exposent des méthodes qui ressemblent à des mutateurs (comme addSibling) mais les laisser renvoyer une nouvelle instance. C'est ce que font les collections immuables Scala.

L'inconvénient est que vous pouvez créer plus d'instances que nécessaire. Il n'est également applicable que lorsqu'il existe des configurations intermédiaires valides (comme certains nœuds sans frères, ce qui est correct dans la plupart des cas) à moins que vous ne souhaitiez pas gérer des objets partiellement construits.

Par exemple, une arête de graphe qui n'a pas encore de destination n'est pas encore une arête de graphe valide.

Considérez quatre possibilités:

new Immutable(one, fish, two, fish, red, fish, blue, fish); /*1 */

params = new ImmutableParameters(); /*2 */
params.setType("fowl");
new Immutable(params);

factory = new ImmutableFactory(); /*3 */
factory.setType("fish");
factory.getInstance();

Immutable boringImmutable = new Immutable(); /* 4 */
Immutable lessBoring = boringImmutable.setType("vegetable");

Pour moi, chacun des 2, 3 et 4 est adapté à une situation de différence. Le premier est difficile à aimer, pour les raisons citées par l'OP, et est généralement le symptôme d'un design qui a subi un certain fluage et a besoin d'être refactorisé.

Ce que j'énumère comme (2) est bon quand il n'y a pas d'état derrière «l'usine», alors que (3) est la conception de choix quand il y a un état. Je me retrouve à utiliser (2) plutôt que (3) lorsque je ne veux pas m'inquiéter des threads et de la synchronisation, et je n'ai pas à m'inquiéter d'amortir une configuration coûteuse sur la production de nombreux objets. (3), en revanche, est appelé quand un vrai travail entre dans la construction de l'usine (mise en place depuis un SPI, lecture des fichiers de configuration, etc.).

Enfin, la réponse de quelqu'un d'autre a mentionné l'option (4), où vous avez beaucoup de petits objets immuables et le modèle préférable est d'obtenir des nouveaux à partir d'anciens.

Notez que je ne suis pas membre du `` fan club de modèles '' - bien sûr, certaines choses valent la peine d'être imitées, mais il me semble qu'ils prennent une vie inutile une fois que les gens leur donnent des noms et des chapeaux amusants.

Une autre option potentielle consiste à refactoriser pour avoir moins de champs configurables. Si des groupes de champs ne fonctionnent (principalement) qu'entre eux, rassemblez-les dans leur propre petit objet immuable. Les constructeurs / générateurs de ce "petit" objet devraient être plus faciles à gérer, tout comme le constructeur / constructeur de ce "gros" objet.

J'utilise C #, et ce sont mes approches. Considérer:

class Foo
{
    // private fields only to be written inside a constructor
    private readonly int i;
    private readonly string s;
    private readonly Bar b;

    // public getter properties
    public int I { get { return i; } }
    // etc.
}

Option 1. Constructeur avec paramètres optionnels

public Foo(int i = 0, string s = "bla", Bar b = null)
{
    this.i = i;
    this.s = s;
    this.b = b;
}

Utilisé comme par exemple new Foo(5, b: new Bar(whatever)). Pas pour les versions Java ou C # antérieures à 4.0. mais cela vaut la peine d'être montré, car c'est un exemple de la façon dont toutes les solutions ne sont pas indépendantes du langage.

Option 2. Constructeur prenant un seul objet paramètre

public Foo(FooParameters parameters)
{
    this.i = parameters.I;
    // etc.
}

class FooParameters
{
    // public properties with automatically generated private backing fields
    public int I { get; set; }
    public string S { get; set; }
    public Bar B { get; set; }

    // All properties are public, so we don't need a full constructor.
    // For convenience, you could include some commonly used initialization
    // patterns as additional constructors.
    public FooParameters() { }
}

Exemple d'utilisation:

FooParameters fp = new FooParameters();
fp.I = 5;
fp.S = "bla";
fp.B = new Bar();
Foo f = new Foo(fp);`

C # à partir de 3.0 rend cela plus élégant avec la syntaxe d'initialisation d'objet (sémantiquement équivalente à l'exemple précédent):

FooParameters fp = new FooParameters { I = 5, S = "bla", B = new Bar() };
Foo f = new Foo(fp);

Option 3:
Reconcevez votre classe pour ne pas avoir besoin d'un si grand nombre de paramètres. Vous pouvez diviser ses responsabilités en plusieurs classes. Ou transmettez les paramètres non pas au constructeur mais uniquement à des méthodes spécifiques, à la demande. Pas toujours viable, mais quand c'est le cas, ça vaut le coup.