Warum ist es unkonventionell, Setter zu verketten?

Die Implementierung der Verkettung in Beans ist sehr praktisch: Konstruktoren, Megakonstruktoren und Fabriken müssen nicht überladen werden, und die Lesbarkeit wird erhöht. Ich kann mir keine Nachteile vorstellen, es sei denn, Sie möchten, dass Ihr Objekt unveränderlich ist. In diesem Fall würde es sowieso keine Setter haben. Gibt es einen Grund, warum dies keine OOP-Konvention ist?

public class DTO {

    private String foo;
    private String bar;

    public String getFoo() {
         return foo;
    }

    public String getBar() {
        return bar;
    }

    public DTO setFoo(String foo) {
        this.foo = foo;
        return this;
    }

    public DTO setBar(String bar) {
        this.bar = bar;
        return this;
    }

}

//...//

DTO dto = new DTO().setFoo("foo").setBar("bar");

Gibt es einen Grund, warum dies keine OOP-Konvention ist?

Meine beste Vermutung: weil es CQS verletzt

Sie haben einen Befehl (Ändern des Status des Objekts) und eine Abfrage (Zurückgeben einer Kopie des Status - in diesem Fall des Objekts selbst) in derselben Methode gemischt. Das ist nicht unbedingt ein Problem, verstößt aber gegen einige der grundlegenden Richtlinien.

In C ++ ist std :: stack :: pop () beispielsweise ein Befehl, der void zurückgibt, und std :: stack :: top () ist eine Abfrage, die einen Verweis auf das oberste Element im Stapel zurückgibt. Klassischerweise möchten Sie beide kombinieren, aber Sie können das nicht und sind ausnahmesicher. (Kein Problem in Java, da der Zuweisungsoperator in Java nicht auslöst).

Wenn DTO ein Wertetyp wäre, könnten Sie mit ein ähnliches Ziel erreichen

public DTO setFoo(String foo) {
    return new DTO(foo, this.bar);
}

public DTO setBar(String bar) {
    return new DTO(this.foo, bar);
}

Außerdem ist die Verkettung von Rückgabewerten ein gewaltiger Schmerz, wenn Sie sich mit Vererbung befassen. Siehe "Seltsamerweise wiederkehrendes Vorlagenmuster"

Schließlich gibt es das Problem, dass der Standardkonstruktor Sie mit einem Objekt belassen sollte, das sich in einem gültigen Zustand befindet. Wenn Sie müssen eine Reihe von Befehlen führen Sie das Objekt in einen gültigen Zustand wieder herzustellen, hat etwas sehr falsch gegangen.

1. Das Speichern einiger Tastenanschläge ist nicht zwingend. Es mag nett sein, aber bei OOP-Konventionen geht es mehr um Konzepte und Strukturen als um Tastenanschläge.

2. Der Rückgabewert ist bedeutungslos.

3. Der Rückgabewert ist nicht nur bedeutungslos, sondern auch irreführend, da Benutzer möglicherweise erwarten, dass der Rückgabewert eine Bedeutung hat. Sie können erwarten, dass es ein "unveränderlicher Setter" ist

   public FooHolder {
       public FooHolder withFoo(int foo) {
           /* return a modified COPY of this FooHolder instance */
       }
   }
   

   In Wirklichkeit mutiert Ihr Setter das Objekt.

4. Es funktioniert nicht gut mit Vererbung.

   public FooHolder {
       public FooHolder setFoo(int foo) {
           ...
       }
   }
   

   public BarHolder extends FooHolder {
       public FooHolder setBar(int bar) {
           ...
       }
   } 
   

   ich kann schreiben

   new BarHolder().setBar(2).setFoo(1)

   aber nicht

   new BarHolder().setFoo(1).setBar(2)

Für mich sind # 1 bis # 3 die wichtigsten. Bei gut geschriebenem Code geht es nicht um angenehm angeordneten Text. In gut geschriebenem Code geht es um die grundlegenden Konzepte, Beziehungen und Strukturen. Text spiegelt nur die wahre Bedeutung des Codes nach außen wider.

Ich denke nicht, dass dies eine OOP-Konvention ist, sie hängt mehr mit dem Sprachdesign und seinen Konventionen zusammen.

Anscheinend möchten Sie Java verwenden. Java hat eine JavaBeans- Spezifikation, die den Rückgabetyp des Setters angibt, der ungültig sein soll, dh er steht in Konflikt mit der Verkettung von Settern. Diese Spezifikation wird allgemein akzeptiert und in einer Vielzahl von Tools implementiert.

Natürlich könnte man fragen, warum nicht ein Teil der Spezifikation verkettet wird. Ich kenne die Antwort nicht, vielleicht war dieses Muster zu dieser Zeit einfach nicht bekannt / beliebt.

Wie andere Leute gesagt haben, wird dies oft als flüssige Schnittstelle bezeichnet .

Normalerweise sind Setter Call-Passing- Variablen als Antwort auf den Logikcode in einer Anwendung. Ihre DTO-Klasse ist ein Beispiel dafür. Herkömmlicher Code, wenn Setter nichts zurückgeben, ist hierfür am besten geeignet. Andere Antworten haben übrigens erklärt.

Es gibt jedoch einige Fälle, in denen eine flüssige Benutzeroberfläche eine gute Lösung sein kann, die alle gemeinsam haben.

• Konstanten werden meist an die Setter übergeben
• Die Programmlogik ändert nicht, was an die Setter übergeben wird.

Einrichten der Konfiguration, z. B. Fluent-Nhibernate

Id(x => x.Id);
Map(x => x.Name)
   .Length(16)
   .Not.Nullable();
HasMany(x => x.Staff)
   .Inverse()
   .Cascade.All();
HasManyToMany(x => x.Products)
   .Cascade.All()
   .Table("StoreProduct");

Einrichten von Testdaten in Komponententests mit speziellen TestDataBulderClasses (Object Mothers)

members = MemberBuilder.CreateList(4)
    .TheFirst(1).With(b => b.WithFirstName("Rob"))
    .TheNext(2).With(b => b.WithFirstName("Poya"))
    .TheNext(1).With(b => b.WithFirstName("Matt"))
    .BuildList(); // Note the "build" method sets everything else to
                  // senible default values so a test only need to define 
                  // what it care about, even if for example a member 
                  // MUST have MembershipId  set

Das Erstellen einer guten, fließenden Benutzeroberfläche ist jedoch sehr schwierig . Daher lohnt es sich nur, wenn Sie über viele „statische“ Einstellungen verfügen. Auch fließende Benutzeroberflächen sollten nicht mit „normalen“ Klassen gemischt werden. Daher wird häufig das Builder-Muster verwendet.

Ich denke, der Hauptgrund, warum es keine Konvention ist, einen Setter nach dem anderen zu verketten, liegt darin, dass in diesen Fällen ein Optionsobjekt oder Parameter in einem Konstruktor typischer ist. C # hat auch eine Initialisierungssyntax.

Anstatt von:

DTO dto = new DTO().setFoo("foo").setBar("bar");

Man könnte schreiben:

(in JS)

var dto = new DTO({foo: "foo", bar: "bar"});

(in C #)

DTO dto = new DTO{Foo = "foo", Bar = "bar"};

(in Java)

DTO dto = new DTO("foo", "bar");

setFoound setBarwerden dann nicht mehr zur Initialisierung benötigt und können später zur Mutation verwendet werden.

Die Verkettbarkeit ist unter bestimmten Umständen hilfreich, es ist jedoch wichtig, nicht zu versuchen, alles in eine einzelne Zeile zu packen, nur um die Anzahl der Zeilenumbrüche zu verringern.

Zum Beispiel

dto.setFoo("foo").setBar("fizz").setFizz("bar").setBuzz("buzz");

erschwert das Lesen und Verstehen des Geschehens. Neuformatierung zu:

dto.setFoo("foo")
    .setBar("fizz")
    .setFizz("bar")
    .setBuzz("buzz");

Ist viel einfacher zu verstehen und macht den "Fehler" in der ersten Version offensichtlicher. Sobald Sie den Code in dieses Format überarbeitet haben, gibt es keinen wirklichen Vorteil mehr gegenüber:

dto.setFoo("foo");
dto.setBar("bar");
dto.setFizz("fizz");
dto.setBuzz("buzz");

Diese Technik wird tatsächlich im Builder-Muster verwendet.

x = ObjectBuilder()
        .foo(5)
        .bar(6);

Im Allgemeinen wird dies jedoch vermieden, da es nicht eindeutig ist. Es ist nicht offensichtlich, ob der Rückgabewert das Objekt ist (so dass Sie andere Setter aufrufen können) oder ob das Rückgabeobjekt der Wert ist, der gerade zugewiesen wurde (auch ein gemeinsames Muster). Dementsprechend schlägt das Prinzip der geringsten Überraschung vor, dass Sie nicht versuchen sollten, anzunehmen, dass der Benutzer die eine oder andere Lösung sehen möchte, es sei denn, dies ist grundlegend für das Design des Objekts.

Dies ist eher ein Kommentar als eine Antwort, aber ich kann keinen Kommentar abgeben, also ...

Ich wollte nur erwähnen, dass mich diese Frage überrascht hat, weil ich das überhaupt nicht als ungewöhnlich betrachte . Eigentlich ist in meinem Arbeitsumfeld (Webentwickler) sehr sehr verbreitet.

Dies ist zum Beispiel die Doktrin von Symfony: generate: entity-Befehl , der standardmäßig alle automatisch generiert .setters

jQuery verkettet die meisten seiner Methoden auf ähnliche Weise.