Modèle de générateur (Java effectif)

Récemment, j'ai eu beaucoup d'occasions d'utiliser le modèle Effective Java Builder principalement en Java, je vais donc l'écrire pour ma propre organisation. C'est juste un simple résumé.

Exemple de modèle de constructeur

Par exemple, si vous développez Android et que vous souhaitez utiliser OKHttpClient,

OkHttpClient okHttpClient = new OkHttpClient(); 

Et générez une instance, mais si vous souhaitez afficher la réponse dans le journal ici

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

Je vais. Voici un exemple du modèle Builder.

Qu'est-ce que tu fais

Normalement, la classe est créée par new du côté utilisateur, mais dans le cas du modèle Builder, c'est un peu différent.

Je préparerai une classe statique dans la classe.

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;

    }
}

Ensuite, définissez une valeur dans le champ et développez une méthode qui renvoie le générateur lui-même pour chaque champ.

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 est omis
        public Builder e(int e) {
            this.e = e;
            return this;
        }

    }
}

En attendant, à ce moment-là, nous préparerons un constructeur privé pour la classe Example.

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

    //Constructeur omis

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

L'argument est le générateur que vous venez de créer, et nous passerons ce champ au champ Exemple. Puisqu'il s'agit d'une classe interne, vous pouvez accéder directement au champ.

Et enfin, implémentez la méthode de construction dans 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 est omis
        public Builder e(int e) {
            this.e = e;
            return this;
        }

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

    }

Puisque l'argument est le générateur lui-même, si le générateur est passé à un constructeur privé et qu'une valeur est définie dans le champ, la valeur sera définie dans le champ Exemple.

Avec cela, lorsque vous souhaitez utiliser Exemple,

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

Vous pouvez obtenir un exemple avec des valeurs définies dans tous les champs. Si vous définissez le champ uniquement en partie

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

Vous pouvez définir uniquement la valeur requise.

Ce qui me rend heureux

Personnellement, je pense que l'avantage de la méthode Builder est que ** les paramètres passés au constructeur sont faciles à comprendre **.

Plus vous passez d'arguments au constructeur, plus il est difficile à voir.

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

Si vous l'implémentez avec le modèle Builder, il sera plus facile à lire car ce que vous définissez est clairement indiqué.

De plus, s'il s'agit d'un paramètre facultatif, vous devez passer null un par un lorsqu'il n'est pas utilisé. Il existe également une méthode de préparation de plusieurs constructeurs appelée modèle de constructeur télescopique, mais elle sera difficile à lire. S'il s'agit d'un modèle Builder, il n'est pas nécessaire de définir des paramètres inutilisés, de sorte que l'utilisateur n'a pas à en être conscient.

À la fin

Cette fois, j'ai écrit sur le modèle Effective Java Builder, mais j'aimerais également beaucoup écrire sur le modèle GoF Builder.

référence

Par Joshua Brock Traduit par Yoshiki Shibata Effective Java 2nd Edition