Design Patterns in Android – Builder
Builder
Patronul Builder simplifică crearea de obiecte într-un mod foarte curat și ușor de citit. Este foarte util atunci când avem câteva clase model cu mulți parametri. Putem face ca unii dintre ei să fie opționali sau obligatorii și nu forțăm utilizatorul să folosească o anumită ordine (ca în constructor). Utilizând modelul Builder, obținem un lanț elegant de metode. Cea mai frecventă utilizare este în clasa AlertDialog.Builder():
new AlertDialog.Builder(this)
.setTitle("Design Patterns")
.setMessage("Builder is awesome")
.create();
Cum putem crea clasa Builder pentru propria noastră utilizare?
Builder în practică
Să presupunem că avem o clasă model pentru utilizator:
public class User {
private String firstName;
private String lastName;
private int age;
}
Și în loc să creăm obiecte din această clasă folosind constructori, dorim să le creăm folosind modelul Builder astfel:
new User.Builder()
.setFirstName("Leonardo")
.setLastName("da Vinci")
.setAge(67)
.create();
Cum putem face asta? În primul rând, trebuie să creăm clasa Builder în interiorul clasei User care va avea metodele de construire a obiectului nostru. Cheia pentru a avea metode de înlănțuire este că metodele constructorului returnează clasa Builder. Priviți exemplul:
static class Builder {
private String firstName;
private String lastName;
private int age;
public Builder setFirstName(final String firstName) {
this.firstName = firstName;
return this;
}
public Builder setLastName(final String lastName) {
this.lastName = lastName;
return this;
}
public Builder setAge(final int age) {
this.age = age;
return this;
}
public User create() {
return new User(this);
}
}
Pentru fiecare parametru avem un setter – diferența este că aceste metode returnează tipul Builder. La sfârșit avem o metodă care folosește constructorul din clasa User și returnează obiectul User – aici este locul în care dezordinea noastră este ținută ascunsă.
Atunci, trebuie să creăm constructorul cu toți parametrii din clasa model User :
public class User {
private String firstName;
private String lastName;
private int age;
private User(final Builder builder) {
firstName = builder.firstName;
lastName = builder.lastName;
age = builder.age;
}
}
Ceea ce este important aici este că constructorul User este privat, deci nu poate fi accesat din cealaltă clasă și trebuie să folosim Builder pentru a crea un nou obiect.
Desigur, putem face ca unii dintre parametri să fie obligatorii (pentru că deocamdată toți sunt opționali) modificând metoda noastră create() și aruncând unele excepții, de exemplu:
public User create() {
User user = new User(firstName, lastName, age);
if (user.firstName.isEmpty()) {
throw new IllegalStateException(
"First name can not be empty!");
}
return user;
}
Asta este. În acest fel am creat clasa noastră User.Builder()!
Builder – protip
Dacă ați avut suficientă răbdare să parcurgeți întreaga postare de pe blog, am un sfat pentru dumneavoastră în ceea ce privește modelul Builder: puteți genera întreaga clasă Builder folosind IntelliJ!
Tot ce trebuie să faceți este să plasați semnul de atenție pe constructorul din clasa dumneavoastră și să alegeți Refactor -> Replace Constructor with Builder din meniul contextual. Clasa Builder cu toate metodele va fi generată automat, gata de utilizare.
Puteți citi mai multe aici: IntelliJ: Replace Constructor with Builder
Concluzie
Patronul Constructor este o abordare excelentă, nu numai pentru clasele model, ci pentru orice obiect care are mai mult de trei sau patru parametri. Cu un pic de muncă suplimentară, putem crește lizibilitatea codului nostru. Modelele de proiectare sunt recunoscute ca fiind cele mai bune practici, așa că este un mare avantaj dacă cunoașteți câteva dintre ele, iar Builder este unul bun pentru a începe.
.