Warum sollte ich keine unveränderlichen POJOs anstelle von JavaBeans verwenden?

Ich habe jetzt einige Java-Anwendungen implementiert, bisher nur Desktop-Anwendungen. Ich bevorzuge die Verwendung unveränderlicher Objekte zum Weitergeben der Daten in der Anwendung, anstatt Objekte mit Mutatoren (Setter und Getter ) zu verwenden, die auch als JavaBeans bezeichnet werden.

Aber in der Java-Welt scheint es viel üblicher zu sein, JavaBeans zu verwenden, und ich kann nicht verstehen, warum ich sie stattdessen verwenden sollte. Persönlich sieht der Code besser aus, wenn er nur unveränderliche Objekte behandelt, anstatt den Status ständig zu ändern.

Unveränderliche Objekte werden auch in Punkt 15 empfohlen : Veränderbarkeit minimieren , Effektives Java 2ed .

Wenn ich ein Objekt Personals JavaBean implementiert habe, würde es so aussehen:

public class Person {
    private String name;
    private Place birthPlace;

    public Person() {}

    public setName(String name) {
        this.name = name;
    }

    public setBirthPlace(Place birthPlace) {
        this.birthPlace = birthPlace;
    }

    public String getName() {
        return name;
    }

    public Place getBirthPlace() {
        return birthPlace;
    }
}

Und das gleiche Personimplementiert als unveränderliches Objekt:

public class Person {
    private final String name;
    private final Place birthPlace;

    public Person(String name, Place birthPlace) {
        this.name = name;
        this.birthPlace = birthPlace;
    }

    public String getName() {
        return name;
    }

    public Place getBirthPlace() {
        return birthPlace;
    }
}

Oder näher an einem structin C:

public class Person {
    public final String name;
    public final Place birthPlace;

    public Person(String name, Place birthPlace) {
        this.name = name;
        this.birthPlace = birthPlace;
    }
}

Ich könnte auch Getter im unveränderlichen Objekt haben, um die Implementierungsdetails zu verbergen. Aber da ich es nur als benutze struct, überspringe ich lieber die "Getter" und halte es einfach.

Ich verstehe einfach nicht, warum es besser ist, JavaBeans zu verwenden, oder ob ich mit meinen unveränderlichen POJOs weitermachen kann und sollte?

Viele der Java-Bibliotheken scheinen JavaBeans besser zu unterstützen, aber vielleicht wird mehr Unterstützung für unveränderliche POJOs mit der Zeit immer beliebter?

Bevorzugen Sie JavaBeans Wann

• Sie müssen mit Umgebungen interagieren, die sie erwarten
• Sie haben viele Eigenschaften, für die es unpraktisch wäre, alle Initialisierungen bei der Instanziierung durchzuführen
• Sie haben einen Zustand, der aus irgendeinem Grund teuer oder unmöglich zu kopieren ist, aber eine Mutation erfordert
• Sie denken, dass Sie irgendwann ändern müssen, wie auf Eigenschaften zugegriffen wird (z. B. Übergang von gespeicherten zu berechneten Werten, Zugriffsberechtigung usw.)
• Sie möchten Codierungsstandards einhalten, die gedankenlos darauf bestehen, dass die Verwendung von JavaBeans "objektorientierter" ist

Bevorzugen Sie unveränderliche POJOs, wenn

• Sie haben eine kleine Anzahl einfacher Eigenschaften
• Sie müssen nicht mit Umgebungen interagieren, die JavaBean-Konventionen voraussetzen
• Es ist einfach (oder zumindest möglich), den Status beim Klonen Ihres Objekts zu kopieren
• Sie haben nie vor, das Objekt zu klonen
• Sie sind sich ziemlich sicher, dass Sie den Zugriff auf Eigenschaften nie wie oben beschrieben ändern müssen
• Es macht Ihnen nichts aus, zuzuhören, wie Ihr Code nicht ausreichend "objektorientiert" ist.

Ich war überrascht, dass das Wort Thread in dieser Diskussion nirgendwo auftauchte.

Einer der Hauptvorteile unveränderlicher Klassen besteht darin, dass sie von Natur aus threadsicherer sind, da kein veränderlicher, gemeinsam genutzter Status vorliegt.

Dies erleichtert nicht nur die Codierung, sondern bietet Ihnen auch zwei Leistungsvorteile als Nebeneffekt:

• Weniger Synchronisationsbedarf.

• Mehr Spielraum für die Verwendung endgültiger Variablen, was spätere Compileroptimierungen erleichtern kann.

Ich versuche wirklich, mich eher unveränderlichen Objekten als JavaBean-Stilklassen zuzuwenden. Das Freilegen der Eingeweide von Objekten über Getter und Setter sollte wahrscheinlich nicht die Standardauswahl sein.

Nun, es hängt davon ab, was Sie versuchen zu tun. Wenn Sie mit einer dauerhaften Ebene arbeiten und eine Zeile aus der Datenbank in ein POJO abrufen und eine Eigenschaft ändern und zurückspeichern möchten, ist die Verwendung des JavaBean-Stils besser, insbesondere wenn Sie über viele Eigenschaften verfügen.

Bedenken Sie, dass Ihre Person viele Bereiche hat, wie Vor-, Mittel-, Nachname, Geburtsdatum, Familienmitglieder, Ausbildung, Job, Gehalt usw.

Und diese Person ist zufällig eine Frau, die gerade geheiratet hat und akzeptiert hat, dass ihr Nachname geändert wird, und Sie müssen die Datenbank aktualisieren.

Wenn Sie unveränderliches POJO verwenden, rufen Sie ein Personenobjekt ab, das sie darstellt, und erstellen ein neues Personenobjekt, an das Sie alle Eigenschaften, die Sie nicht geändert haben, sowie den neuen Nachnamen übergeben und speichern.

Wenn es sich um eine Java-Bean handelt, können Sie einfach setLastName () ausführen und speichern.

Es ist "Mutabilität minimieren" und nicht "Veränderbare Objekte niemals verwenden". Einige Situationen funktionieren besser mit veränderlichen Objekten. Es ist wirklich Ihre Aufgabe, zu entscheiden, ob ein veränderbares Objekt besser zu Ihrem Programm passt oder nicht. Sie sollten nicht immer sagen, dass unveränderliche Objekte verwendet werden müssen, sondern sehen, wie viele Klassen Sie unveränderlich machen können, bevor Sie anfangen, sich selbst zu verletzen.

Zusammenfassend denke ich, dass:

• Unveränderlichkeit erleichtert die Korrektheit (Strukturen können als Referenz übergeben werden und Sie wissen, dass nichts von einem fehlerhaften / böswilligen Client zerstört wird) und die Einfachheit des Codes
• Mutabilität erleichtert die Homogenität : Spring und andere Frameworks erstellen ein Objekt ohne Argumente, legen Objekteigenschaften fest und voi là . Erleichtern Sie außerdem die Verwendung von Schnittstellen, indem Sie dieselbe Klasse zum Angeben von Daten und Speichern von Änderungen verwenden (Sie benötigen keine get(id): Clientund save(MutableClient)als MutableClient einige Nachkommen von Client.

Wenn es einen Zwischenpunkt gäbe (erstellen, Eigenschaften festlegen, unveränderlich machen), würden Frameworks möglicherweise eher einen unveränderlichen Ansatz fördern.

Wie auch immer, ich schlage vor, in unveränderlichen Objekten als "Nur-Lese-Java-Bohnen" zu denken und zu betonen, dass alles in Ordnung ist, wenn Sie ein guter Junge sind und diese gefährliche setProperty-Methode nicht berühren.

Ab Java 7 können Sie unveränderliche Bohnen haben, das Beste aus beiden Welten. Verwenden Sie die Annotation @ConstructorProperties für Ihren Konstruktor.

public class Person {
    private final String name;
    private final Place birthPlace;

    @ConstructorProperties({"name", "birthPlace"})
    public Person(String name, Place birthPlace) {
        this.name = name;
        this.birthPlace = birthPlace;
    }

    public String getName() {
        return name;
    }

    public Place getBirthPlace() {
        return birthPlace;
    }
}

Ich glaube nicht, dass unveränderliche Objekte so beliebt werden, um ehrlich zu sein.

Ich sehe die Vorteile, aber Frameworks wie Hibernate und Spring sind derzeit (und das aus gutem Grund) sehr im Trend und funktionieren am besten mit Bohnen.

Ich denke also nicht, dass Unveränderlichkeit schlecht ist, aber es würde Ihre Integrationsoptionen mit aktuellen Frameworks sicherlich einschränken.

BEARBEITEN Die Kommentare fordern mich auf, meine Antwort ein wenig zu klären.

Es gibt mit Sicherheit Problembereiche, in denen Unveränderlichkeit sehr nützlich ist und tatsächlich genutzt wird. Aber ich denke, der aktuelle Standard scheint veränderlich zu sein, da dies meistens erwartet wird und nur dann unveränderlich ist, wenn dies einen klaren Vorteil hat.

Und obwohl es in Spring tatsächlich möglich ist, Konstruktoren mit Argumenten zu verwenden, scheint es als eine Möglichkeit gedacht zu sein, Legacy- und / oder Code von Drittanbietern mit Ihrem wunderschönen brandneuen Spring-Code zu verwenden. Zumindest habe ich das aus der Dokumentation aufgegriffen.

Unveränderlich in Bezug auf die Programmierung in Java: Etwas, das einmal erstellt wurde, sollte niemals einen erwarteten oder unerwarteten Statuswechsel haben!

Diese Technik ist nützlich bei der defensiven Programmierung, bei der eine andere Entität keine Zustandsänderung hervorrufen kann.

Beispiele, bei denen Sie keine Änderung erwarten: Externe Systeme (Single- oder Multi-Threaded), die von Ihrer Ebene referenziert werden und auf das Objekt einwirken und es wissentlich oder unwissentlich ändern. Jetzt kann es sich um ein POJO oder eine Sammlung oder eine Objektreferenz handeln, und Sie erwarten keine Änderung daran oder möchten die Daten schützen. Sie würden das Objekt definitiv als Verteidigungstechnik unveränderlich machen

Beispiele, bei denen Sie Änderungen erwarten: Sie brauchen wirklich keine Unveränderlichkeit, da dies die richtigen Programmierverfahren behindert.