Builder pattern w praktyce

Tworzenie obiektów z wieloma parametrami w Javie potrafi być prawdziwym koszmarem. Czy to nie wygląda znajomo?

User user = new User("Jan", "Kowalski", "jan@example.com", 25, "Warszawa", "12345", true, false, "premium");

Który parametr za co odpowiada? Co oznacza true i false? Builder pattern rozwiązuje ten problem, oferując eleganckie i czytelne API do konstruowania obiektów.

Dlaczego Builder pattern jest ważny

W prawdziwych projektach obiekty często mają dziesiątki parametrów. Konstruktory stają się nieczytelne, a kod trudny w utrzymaniu. Builder pattern wprowadza porządek i sprawia, że kod się samo-dokumentuje.

Czym jest Builder pattern

Builder pattern składa się z kilku elementów:

• Product – obiekt który chcemy stworzyć
• Builder – klasa odpowiedzialna za budowanie
• Director (opcjonalnie) – koordynuje proces budowania

Implementacja Builder pattern w Javie

Prosty przykład – klasa User

Zacznijmy od podstawowej implementacji Builder pattern dla klasy reprezentującej użytkownika:

public class User {
    private final String firstName;
    private final String lastName;
    private final String email;
    private final int age;
    private final String city;
    private final boolean isActive;
    private final String accountType;
    
    // Prywatny konstruktor - tylko Builder może tworzyć obiekty
    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.email = builder.email;
        this.age = builder.age;
        this.city = builder.city;
        this.isActive = builder.isActive;
        this.accountType = builder.accountType;
    }
    
    // Gettery...
    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
    public String getEmail() { return email; }
    // ... pozostałe gettery
    
    // Metoda statyczna do tworzenia Builder
    public static UserBuilder builder() {
        return new UserBuilder();
    }
}

Implementacja Builder class

public static class UserBuilder {
    private String firstName;
    private String lastName;
    private String email;
    private int age;
    private String city;
    private boolean isActive = true; // wartość domyślna
    private String accountType = "basic"; // wartość domyślna
    
    // Każda metoda zwraca 'this' dla fluent API
    public UserBuilder firstName(String firstName) {
        this.firstName = firstName;
        return this;
    }
    
    public UserBuilder lastName(String lastName) {
        this.lastName = lastName;
        return this;
    }
    
    public UserBuilder email(String email) {
        this.email = email;
        return this;
    }
    
    public UserBuilder age(int age) {
        this.age = age;
        return this;
    }
    
    public UserBuilder city(String city) {
        this.city = city;
        return this;
    }
    
    public UserBuilder active(boolean isActive) {
        this.isActive = isActive;
        return this;
    }
    
    public UserBuilder accountType(String accountType) {
        this.accountType = accountType;
        return this;
    }
    
    // Metoda build() tworzy końcowy obiekt
    public User build() {
        // Tutaj możemy dodać walidację
        if (firstName == null || lastName == null || email == null) {
            throw new IllegalStateException("Imię, nazwisko i email są wymagane");
        }
        return new User(this);
    }
}

Używanie Builder pattern

Teraz tworzenie obiektów User jest czytelne i intuicyjne:

// Czytelne tworzenie obiektu
User user = User.builder()
    .firstName("Jan")
    .lastName("Kowalski")
    .email("jan@example.com")
    .age(25)
    .city("Warszawa")
    .accountType("premium")
    .build();

// Można pominąć opcjonalne parametry
User simpleUser = User.builder()
    .firstName("Anna")
    .lastName("Nowak")
    .email("anna@example.com")
    .build(); // użyje wartości domyślnych dla age, city, isActive, accountType

Kiedy używać Builder pattern

Builder pattern nie zawsze jest najlepszym rozwiązaniem. Oto kiedy warto go zastosować:

Zaawansowane techniki

Builder z walidacją

Builder doskonale sprawdza się do walidacji danych przed utworzeniem obiektu:

public User build() {
    // Walidacja wymaganych pól
    if (firstName == null || firstName.trim().isEmpty()) {
        throw new IllegalArgumentException("Imię nie może być puste");
    }
    
    // Walidacja formatu email
    if (email == null || !email.contains("@")) {
        throw new IllegalArgumentException("Nieprawidłowy format email");
    }
    
    // Walidacja wieku
    if (age < 0 || age > 150) {
        throw new IllegalArgumentException("Nieprawidłowy wiek: " + age);
    }
    
    return new User(this);
}

Builder z metodami pomocniczymi

Możesz dodać metody, które ułatwiają ustawianie często używanych kombinacji:

public static class UserBuilder {
    // ... inne metody
    
    // Metoda pomocnicza dla konta premium
    public UserBuilder premiumAccount() {
        this.accountType = "premium";
        this.isActive = true;
        return this;
    }
    
    // Metoda pomocnicza dla pełnego imienia
    public UserBuilder fullName(String fullName) {
        String[] parts = fullName.split(" ", 2);
        this.firstName = parts[0];
        this.lastName = parts.length > 1 ? parts[1] : "";
        return this;
    }
}

// Użycie:
User premiumUser = User.builder()
    .fullName("Jan Kowalski")
    .email("jan@example.com")
    .premiumAccount()
    .build();

Builder pattern w bibliotekach

Wiele popularnych bibliotek używa Builder pattern. Oto kilka przykładów z 2017 roku:

StringBuilder (wbudowany w Javę)

String result = new StringBuilder()
    .append("Hello ")
    .append("World")
    .append("!")
    .toString();

Apache HttpClient

CloseableHttpClient client = HttpClients.custom()
    .setConnectionManager(connectionManager)
    .setDefaultRequestConfig(requestConfig)
    .setRetryHandler(retryHandler)
    .build();

Gson (biblioteka JSON)

Gson gson = new GsonBuilder()
    .setPrettyPrinting()
    .setDateFormat("yyyy-MM-dd")
    .create();

Builder vs inne wzorce

Przydatne zasoby

• StringBuilder – dokumentacja Oracle
• Gson Builder – przykłady na GitHub
• Apache HttpClient – Fluent API
• Gang of Four Design Patterns w Spring

Builder pattern to jeden z najużyteczniejszych wzorców projektowych w codziennej pracy programisty. Sprawia, że kod staje się czytelny, łatwy w utrzymaniu i bezpieczny. Kiedy następnym razem zobaczysz konstruktor z 6+ parametrami, pomyśl o Builder pattern!

Jaki wzorzec projektowy sprawiał Ci największe problemy? Podziel się w komentarzach!