Builder-Muster (effektives Java)

In letzter Zeit hatte ich viele Möglichkeiten, das Effective Java Builder-Muster hauptsächlich in Java zu verwenden, daher schreibe ich es für meine eigene Organisation auf. Es ist nur eine einfache Zusammenfassung.

Beispiel für ein Builder-Muster

Wenn Sie beispielsweise Android entwickeln und OKHttpClient verwenden möchten,

OkHttpClient okHttpClient = new OkHttpClient(); 

Und generieren Sie eine Instanz, aber wenn Sie die Antwort auf das Protokoll hier ausgeben möchten

 OkHttpClient okHttpClient = new OkHttpClient.Builder()
            　　　　　　　　　　　　.addInterceptor(new　HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
                　　　　　　　　　　.build();

Ich werde. Hier ist ein Beispiel für das Builder-Muster.

Was machst du

Normalerweise wird die Klasse auf der Benutzerseite von new erstellt, im Fall des Builder-Musters ist dies jedoch etwas anders.

Ich werde eine statische Klasse in der Klasse vorbereiten.

public class Example {
    private int a;
    private int b;
    private int c;
    private int d;
    private int e;

    public static class ExampleBuilder {
        private int a;
        private int b;
        private int c;
        private int d;
        private int e;

    }
}

Legen Sie dann einen Wert im Feld fest und erweitern Sie eine Methode, die den Builder selbst für jedes Feld zurückgibt.

public class Example {
    private int a;
    private int b;
    private int c;
    private int d;
    private int e;

    public static class ExampleBuilder {
        private int a;
        private int b;
        private int c;
        private int d;
        private int e;

        public Builder a(int a) {
            this.a = a;
            return this;
        }

        public Builder b(int b) {
            this.b = b;
            return this;
        }
        //c,d wird weggelassen
        public Builder e(int e) {
            this.e = e;
            return this;
        }

    }
}

In der Zwischenzeit werden wir einen privaten Konstruktor für die Example-Klasse vorbereiten.

public class Example {
    private int a;
    private int b;
    private int c;
    private int d;
    private int e;

    //Builder weggelassen

    private Example(Builder builder) {
        this.a = builder.a;
        this.b = builder.b;
        this.c = builder.c;
        this.d = builder.d;
        this.e = builder.e;
    }
}

Das Argument ist der Builder, den Sie gerade erstellt haben, und wir übergeben dieses Feld an das Beispielfeld. Da es sich um eine innere Klasse handelt, können Sie direkt auf das Feld zugreifen.

Und schließlich implementieren Sie die Build-Methode in Builder.

public static class ExampleBuilder {
        private int a;
        private int b;
        private int c;
        private int d;
        private int e;

        public Builder a(int a) {
            this.a = a;
            return this;
        }

        public Builder b(int b) {
            this.b = b;
            return this;
        }
        //c,d wird weggelassen
        public Builder e(int e) {
            this.e = e;
            return this;
        }

        public Example build() {
            return new Example(this);
        }

    }

Da das Argument dies der Builder selbst ist, wird der Wert im Feld Beispiel festgelegt, wenn der Builder an einen privaten Konstruktor übergeben wird und ein Wert im Feld festgelegt wird.

Wenn Sie Beispiel verwenden möchten,

Example example = new Example.Builder.a(1).b(2).c(3).d(4).e(5).build();

Sie können ein Beispiel mit Werten erhalten, die in allen Feldern festgelegt sind. Wenn Sie das Feld nur teilweise einstellen

Example example = new Example.Builder.a(1).d(4).build();

Es ist in Ordnung, nur den erforderlichen Wert einzustellen.

Was mich glücklich macht

Ich persönlich bin der Meinung, dass der Vorteil der Builder-Methode darin besteht, dass ** die an den Konstruktor übergebenen Parameter leicht zu verstehen sind **.

Je mehr Argumente Sie an den Konstruktor übergeben, desto schwieriger ist es, sie zu erkennen.

Example example = new Example(int aaaaaa, int bbbbbbb, int ccccccc, int ddddddd, int eeeeeeee);

Wenn Sie es mit dem Builder-Muster implementieren, ist es leichter zu lesen, da klar angegeben ist, was Sie einstellen.

Wenn es sich um einen optionalen Parameter handelt, müssen Sie bei Nichtgebrauch nacheinander null übergeben. Es gibt auch eine Methode zur Herstellung mehrerer Konstruktoren, die als Teleskopkonstruktormuster bezeichnet wird, die jedoch schwer zu lesen ist. Wenn es sich um ein Builder-Muster handelt, müssen nicht verwendete Parameter nicht festgelegt werden, sodass der Benutzer sich dessen nicht bewusst sein muss.

Am Ende

Dieses Mal habe ich über das effektive Java Builder-Muster geschrieben, aber ich möchte auch viel über das GoF Builder-Muster schreiben.

Referenz

Von Joshua Brock Übersetzt von Yoshiki Shibata Effective Java 2nd Edition