🔨 Builder Design Pattern

public final class HttpRequest {
    // All fields are final — immutable after construction
    private final String url;
    private final String method;
    private final Map<String, String> headers;
    private final String body;
    private final int timeoutMs;
    private final int maxRetries;
    private final boolean followRedirects;

    // Private constructor — only Builder can create instances
    private HttpRequest(Builder builder) {
        this.url = builder.url;
        this.method = builder.method;
        this.headers = Collections.unmodifiableMap(new HashMap<>(builder.headers));
        this.body = builder.body;
        this.timeoutMs = builder.timeoutMs;
        this.maxRetries = builder.maxRetries;
        this.followRedirects = builder.followRedirects;
    }

    // Getters only — no setters
    public String getUrl() { return url; }
    public String getMethod() { return method; }
    public Map<String, String> getHeaders() { return headers; }
    public String getBody() { return body; }
    public int getTimeoutMs() { return timeoutMs; }
    public int getMaxRetries() { return maxRetries; }
    public boolean isFollowRedirects() { return followRedirects; }

    // Static factory to start building
    public static Builder builder(String url) {
        return new Builder(url);
    }

    // ========== The Builder ==========
    public static class Builder {
        // Required parameters
        private final String url;

        // Optional parameters with defaults
        private String method = "GET";
        private Map<String, String> headers = new HashMap<>();
        private String body = null;
        private int timeoutMs = 30_000;
        private int maxRetries = 0;
        private boolean followRedirects = true;

        private Builder(String url) {
            this.url = Objects.requireNonNull(url, "URL cannot be null");
        }

        public Builder method(String method) {
            this.method = method;
            return this;
        }

        public Builder header(String key, String value) {
            this.headers.put(key, value);
            return this;
        }

        public Builder body(String body) {
            this.body = body;
            return this;
        }

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

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

        public Builder followRedirects(boolean followRedirects) {
            this.followRedirects = followRedirects;
            return this;
        }

        // Validation happens at build time
        public HttpRequest build() {
            if (body != null && method.equals("GET")) {
                throw new IllegalStateException("GET requests cannot have a body");
            }
            if (timeoutMs <= 0) {
                throw new IllegalStateException("Timeout must be positive");
            }
            return new HttpRequest(this);
        }
    }
}

// ========== Usage ==========
HttpRequest request = HttpRequest.builder("https://api.example.com/users")
    .method("POST")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer token123")
    .body("{\"name\": \"John\"}")
    .timeoutMs(5000)
    .maxRetries(3)
    .build();

// Product
public class House {
    private String foundation;
    private String structure;
    private String roof;
    private boolean hasGarage;
    private boolean hasSwimmingPool;
    private boolean hasGarden;

    // Setters used by builder (package-private)
    void setFoundation(String f) { this.foundation = f; }
    void setStructure(String s) { this.structure = s; }
    void setRoof(String r) { this.roof = r; }
    void setHasGarage(boolean g) { this.hasGarage = g; }
    void setHasSwimmingPool(boolean p) { this.hasSwimmingPool = p; }
    void setHasGarden(boolean g) { this.hasGarden = g; }

    @Override
    public String toString() {
        return "House{foundation=" + foundation + ", structure=" + structure +
               ", roof=" + roof + ", garage=" + hasGarage +
               ", pool=" + hasSwimmingPool + ", garden=" + hasGarden + "}";
    }
}

// Builder Interface
public interface HouseBuilder {
    HouseBuilder buildFoundation();
    HouseBuilder buildStructure();
    HouseBuilder buildRoof();
    HouseBuilder addGarage();
    HouseBuilder addSwimmingPool();
    HouseBuilder addGarden();
    House getResult();
}

// Concrete Builder
public class LuxuryHouseBuilder implements HouseBuilder {
    private House house = new House();

    @Override
    public HouseBuilder buildFoundation() {
        house.setFoundation("Reinforced Concrete");
        return this;
    }

    @Override
    public HouseBuilder buildStructure() {
        house.setStructure("Steel Frame with Glass");
        return this;
    }

    @Override
    public HouseBuilder buildRoof() {
        house.setRoof("Solar Panel Roof");
        return this;
    }

    @Override
    public HouseBuilder addGarage() {
        house.setHasGarage(true);
        return this;
    }

    @Override
    public HouseBuilder addSwimmingPool() {
        house.setHasSwimmingPool(true);
        return this;
    }

    @Override
    public HouseBuilder addGarden() {
        house.setHasGarden(true);
        return this;
    }

    @Override
    public House getResult() { return house; }
}

// Director — knows HOW to build specific configurations
public class HouseDirector {

    public House constructLuxuryHouse(HouseBuilder builder) {
        return builder.buildFoundation()
                      .buildStructure()
                      .buildRoof()
                      .addGarage()
                      .addSwimmingPool()
                      .addGarden()
                      .getResult();
    }

    public House constructSimpleHouse(HouseBuilder builder) {
        return builder.buildFoundation()
                      .buildStructure()
                      .buildRoof()
                      .getResult();
    }
}

import lombok.Builder;
import lombok.Getter;
import lombok.Singular;

@Getter
@Builder
public class HttpRequest {
    private final String url;

    @Builder.Default
    private final String method = "GET";

    @Singular  // Generates addHeader() method
    private final Map<String, String> headers;

    private final String body;

    @Builder.Default
    private final int timeoutMs = 30_000;

    @Builder.Default
    private final int maxRetries = 0;

    @Builder.Default
    private final boolean followRedirects = true;
}

// Usage — identical fluent API, zero boilerplate
HttpRequest request = HttpRequest.builder()
    .url("https://api.example.com")
    .method("POST")
    .header("Content-Type", "application/json")
    .body("{\"key\": \"value\"}")
    .timeoutMs(5000)
    .build();