Entwurfsmuster in Android - Builder

Entwurfsmuster sind wiederverwendbare Lösungen für die am häufigsten auftretenden Softwareprobleme. Sie können den Entwicklungsprozess beschleunigen, indem sie eine bewährte Methode zur Lösung häufiger Probleme bereitstellen.

In dieser Artikelserie möchte ich die gängigsten Entwurfsmuster anhand von Beispielen für die praktische Implementierung von Android vorstellen.

Einführung

Entwurfsmuster können in drei Abschnitte unterteilt werden:

  • Creational Design Patterns bieten Lösungen zum Erstellen von Klassen, Objekten (Singleton, Factory, Builder usw.).
  • Bei strukturellen Entwurfsmustern handelt es sich um die Anordnung von Klassen und Objekten (z. B. Verbund, Fassade, Adapter).
  • Behavioral Design Patterns bieten Möglichkeiten zur Kommunikation zwischen Objekten und Klassen (Befehl, Beobachter, Strategie usw.).

Baumeister

Das Builder-Muster vereinfacht die Objekterstellung auf sehr übersichtliche und lesbare Weise. Dies ist sehr hilfreich, wenn wir einige Modellklassen mit vielen Parametern haben. Wir können einige davon optional oder erforderlich machen und wir zwingen den Benutzer nicht, eine bestimmte Reihenfolge zu verwenden (wie im Konstruktor). Durch die Verwendung des Builder-Musters ergibt sich eine elegante Verkettung der Methoden. Die häufigste Verwendung ist in der AlertDialog.Builder () -Klasse:

neuer AlertDialog.Builder (this)
        .setTitle ("Design Patterns")
        .setMessage ("Builder ist fantastisch")
        .erstellen();

Wie können wir eine Builder-Klasse für unsere eigene Verwendung erstellen?

Baumeister in der Praxis

Nehmen wir an, wir haben eine Modellklasse für den Benutzer:

öffentlicher Benutzer {
    private String firstName;
    private String lastName;
    privates int Alter;
}

Und anstatt Objekte dieser Klasse mithilfe von Konstruktoren zu erstellen, möchten wir sie mithilfe des folgenden Builder-Musters erstellen:

neuer User.Builder ()
        .setFirstName ("Leonardo")
        .setLastName ("da Vinci")
        .setAge (67)
        .erstellen();

Wie können wir das machen? Zunächst müssen wir die Builder-Klasse in der User-Klasse erstellen, die die Methoden zum Erstellen unseres Objekts enthält. Der Schlüssel zu Verkettungsmethoden ist, dass Builder-Methoden die Builder-Klasse zurückgeben. Schau dir das Beispiel an:

statische Klasse Builder {
    private String firstName;
    private String lastName;
    privates int Alter;

    public Builder setFirstName (letzter String firstName) {
        this.firstName = firstName;
        gib das zurück;
    }

    public Builder setLastName (letzter String lastName) {
        this.lastName = lastName;
        gib das zurück;
    }

    public Builder setAge (final int age) {
        this.age = age;
        gib das zurück;
    }

    public User create () {
        neuen Benutzer zurückgeben (this);
    }
}

Für jeden Parameter gibt es einen Setter. Der Unterschied besteht darin, dass diese Methoden den Builder-Typ zurückgeben. Am Ende haben wir eine Methode, die den Konstruktor der User-Klasse verwendet und das User-Objekt zurückgibt - hier ist der Ort, an dem unser Durcheinander verborgen bleibt.

Dann müssen wir einen Konstruktor mit allen Parametern in der Modellklasse User erstellen:

öffentlicher Benutzer {
    private String firstName;
    private String lastName;
    privates int Alter;

    privater Benutzer (letzter Builder-Builder) {
        firstName = builder.firstName;
        lastName = builder.lastName;
        alter = builder.age;
    }
}

Wichtig hierbei ist, dass der User-Konstruktor privat ist, sodass von der anderen Klasse aus nicht auf ihn zugegriffen werden kann und wir Builder verwenden müssen, um ein neues Objekt zu erstellen.

Natürlich können wir einige der erforderlichen Parameter festlegen (da derzeit alle optional sind), indem wir unsere create () -Methode ändern und einige Ausnahmen auslösen, z.

public User create () {
    Benutzer user = neuer Benutzer (Vorname, Nachname, Alter);
    if (user.firstName.isEmpty ()) {
        werfen neue IllegalStateException (
           "Vorname darf nicht leer sein!");
    }
    Benutzer zurückgeben;
}

Das ist es. Auf diese Weise haben wir unsere User.Builder () -Klasse erstellt!

Baumeister - Protip

Wenn Sie geduldig genug waren, um den gesamten Blog-Beitrag durchzuarbeiten, habe ich einen Tipp für Sie bezüglich des Builder-Musters: Sie können die gesamte Builder-Klasse mit IntelliJ generieren!

Alles, was Sie tun müssen, ist, das Caret auf dem Konstruktor in Ihrer Klasse zu platzieren und im Kontextmenü Refactor -> Konstruktor durch Builder ersetzen zu wählen. Die Builder-Klasse mit allen Methoden wird automatisch generiert und ist einsatzbereit.

Sie können hier mehr darüber lesen: IntelliJ: Ersetzen Sie den Konstruktor durch den Builder

Fazit

Builder-Muster sind ein großartiger Ansatz, nicht nur für Modellklassen, sondern für jedes Objekt, das mehr als drei oder vier Parameter enthält. Mit ein wenig zusätzlicher Arbeit können wir die Lesbarkeit unseres Codes verbessern. Entwurfsmuster gelten als bewährte Methode. Daher ist es von großem Vorteil, wenn Sie einige davon kennen und Builder für den Anfang eine gute Lösung darstellt.

Bleib dran für mehr!