Ontwerp patronen in Android - Builder

Ontwerppatronen zijn herbruikbare oplossingen voor de meest voorkomende softwareproblemen. Ze kunnen het ontwikkelingsproces versnellen door een bewezen manier te bieden om veel voorkomende problemen op te lossen.

In deze serie artikelen wil ik de meest voorkomende ontwerppatronen met voorbeelden van Android-implementaties in de praktijk introduceren.

Invoering

Ontwerppatronen kunnen worden verdeeld in de drie secties:

  • Creationele ontwerppatronen leveren oplossingen voor het maken van klassen, objecten (Singleton, Factory, Builder, etc.)
  • Structurele ontwerppatronen gaan over de indeling van klassen en objecten (bijv. Composiet, gevel, adapter)
  • Gedragspatronen bieden ons manieren om te communiceren tussen objecten en klassen (Command, Observer, Strategie, etc.)

Bouwer

Bouwerspatroon vereenvoudigt het maken van objecten op een zeer schone en leesbare manier. Het is erg handig als we enkele modelklassen met veel parameters hebben. We kunnen sommige optioneel of verplicht maken en we dwingen de gebruiker niet om een ​​specifieke bestelling te gebruiken (zoals in de constructor). Door het Builder-patroon te gebruiken, resulteren we in de elegante reeks methoden. Het meest voorkomende gebruik is in de klasse AlertDialog.Builder ():

nieuwe AlertDialog.Builder (deze)
        .setTitle ("Ontwerppatronen")
        .setMessage ("Builder is geweldig")
        .create ();

Hoe kunnen we Builder-klasse maken voor eigen gebruik?

Bouwer in de praktijk

Laten we aannemen dat we een modelklasse voor de gebruiker hebben:

openbare klas gebruiker {
    private String voornaam;
    private String achternaam;
    privéint leeftijd;
}

En in plaats van objecten van deze klasse met constructors te maken, willen we ze met het Builder-patroon als volgt maken:

nieuwe User.Builder ()
        .setFirstName ( "Leonardo")
        .setLastName ("da Vinci")
        .setAge (67)
        .create ();

Hoe kunnen we dat doen? Ten eerste moeten we de Builder-klasse binnen de User-klasse maken die de methoden heeft om ons object te bouwen. De sleutel tot het gebruik van kettingmethoden is dat bouwermethoden de Builder-klasse retourneren. Kijk naar het voorbeeld:

statische klasse Builder {
    private String voornaam;
    private String achternaam;
    privéint leeftijd;

    public Builder setFirstName (final String firstName) {
        this.firstName = firstName;
        geef dit terug;
    }

    public Builder setLastName (final String lastName) {
        this.lastName = lastName;
        geef dit terug;
    }

    public Builder setAge (uiteindelijke int leeftijd) {
        this.age = leeftijd;
        geef dit terug;
    }

    openbare gebruiker create () {
        nieuwe gebruiker retourneren (deze);
    }
}

Voor elke parameter hebben we een setter - het verschil is dat deze methoden het Builder-type retourneren. Aan het einde hebben we een methode die de constructor uit de User-klasse gebruikt en het User-object retourneert - hier is de plek waar onze troep verborgen wordt gehouden.

Vervolgens moeten we een constructor maken met alle parameters in modelklasse User:

openbare klas gebruiker {
    private String voornaam;
    private String achternaam;
    privéint leeftijd;

    privégebruiker (laatste Builder-builder) {
        firstName = builder.firstName;
        lastName = builder.lastName;
        leeftijd = builder.age;
    }
}

Belangrijk hierbij is dat de User-constructor privé is, dus niet toegankelijk vanuit de andere klasse en dat we Builder moeten gebruiken om een ​​nieuw object te maken.

Natuurlijk kunnen we een aantal van de vereiste parameters maken (omdat ze voorlopig allemaal optioneel zijn) door onze create () -methode te wijzigen en enkele uitzonderingen te maken, bijvoorbeeld:

openbare gebruiker create () {
    Gebruiker gebruiker = nieuwe gebruiker (voornaam, achternaam, leeftijd);
    if (user.firstName.isEmpty ()) {
        gooi nieuwe IllegalStateException (
           "Voornaam mag niet leeg zijn!");
    }
    terugkerende gebruiker;
}

Dat is het. Op deze manier hebben we onze klasse User.Builder () gemaakt!

Bouwer - protip

Als je geduldig genoeg was om de hele blogpost te doorlopen, heb ik een tip voor je met betrekking tot het Builder-patroon: je kunt de hele Builder-klasse genereren met IntelliJ!

Het enige dat u hoeft te doen, is het caret op de constructor in uw klasse te plaatsen en Refactor -> Constructor vervangen door Builder te kiezen in het contextmenu. De klasse Builder met alle methoden wordt automatisch gegenereerd, klaar voor gebruik.

U kunt hier meer lezen: IntelliJ: Constructor vervangen door Builder

Gevolgtrekking

Bouwerspatroon is een geweldige benadering, niet alleen voor modelklassen, maar voor elk object dat meer dan drie of vier parameters heeft. Met een beetje extra werk kunnen we de leesbaarheid van onze code verbeteren. Ontwerppatronen worden erkend als de beste praktijk, dus het is een groot voordeel als u er een paar kent en Builder is een goede om mee te beginnen.

Blijf erbij voor meer!