В чем разница между Builder и Facade?

Разница между Builder и Facade паттернами

Это два разных паттерна проектирования с совершенно разными целями. Часто их путают, но они решают разные проблемы.

Builder паттерн

Цель: Пошагово конструировать сложный объект, разделяя логику создания от представления.

// Класс с множеством параметров
public class User {
    private String firstName;
    private String lastName;
    private String email;
    private int age;
    private String phone;
    private String address;
    private String city;
    private String country;
    private boolean premium;
    private boolean verified;
    
    // Конструктор с Builder
    private User(UserBuilder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.email = builder.email;
        this.age = builder.age;
        this.phone = builder.phone;
        this.address = builder.address;
        this.city = builder.city;
        this.country = builder.country;
        this.premium = builder.premium;
        this.verified = builder.verified;
    }
    
    // Getter методы
    public String getFirstName() { return firstName; }
    public String getLastName() { return lastName; }
    // ... остальные
}

// Builder класс
public class UserBuilder {
    public String firstName;
    public String lastName;
    public String email;
    public int age;
    public String phone;
    public String address;
    public String city;
    public String country;
    public boolean premium = false;
    public boolean verified = false;
    
    // Методы для установки значений (возвращают builder для chaining)
    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 premium(boolean premium) {
        this.premium = premium;
        return this;
    }
    
    // Финальный метод для создания User
    public User build() {
        // Можно добавить валидацию
        if (firstName == null || firstName.isEmpty()) {
            throw new IllegalArgumentException("First name is required");
        }
        if (email == null || !email.contains("@")) {
            throw new IllegalArgumentException("Valid email is required");
        }
        return new User(this);
    }
}

// Использование
User user = new UserBuilder()
    .firstName("John")
    .lastName("Doe")
    .email("john@example.com")
    .age(30)
    .phone("+1234567890")
    .city("New York")
    .premium(true)
    .build();  // Вернёт готовый объект

// vs неудобный конструктор
// User user = new User("John", "Doe", "john@example.com", 30, 
//                       "+1234567890", null, "New York", null, true, false);

Характеристики Builder:

✓ Конструирует сложные объекты пошагово ✓ Делает код читаемым (понятно какое поле что устанавливает) ✓ Поддерживает частичную инициализацию (не обязательны все поля) ✓ Валидация на этапе build() ✓ Позволяет создавать immutable объекты ✓ Можно использовать несколько раз

❌ Требует больше кода (отдельный класс Builder) ❌ Медленнее конструктора (дополнительные объекты)

Facade паттерн

Цель: Скрыть сложность подсистемы за простым интерфейсом.

// Сложная подсистема с множеством классов

// Класс 1: управление аккаунтом
public class AccountService {
    public void validateAccount(User user) {
        System.out.println("Validating account...");
    }
}

// Класс 2: управление платежом
public class PaymentService {
    public void processPayment(User user, BigDecimal amount) {
        System.out.println("Processing payment of " + amount);
    }
}

// Класс 3: отправка уведомления
public class NotificationService {
    public void sendEmail(User user, String message) {
        System.out.println("Sending email to " + user.getEmail());
    }
}

// Класс 4: логирование
public class LoggingService {
    public void log(String action) {
        System.out.println("[LOG] " + action);
    }
}

// Без Facade (сложно):
public void registerUser(User user) {
    // Нужно вручную вызывать множество сервисов
    AccountService accountService = new AccountService();
    PaymentService paymentService = new PaymentService();
    NotificationService notificationService = new NotificationService();
    LoggingService loggingService = new LoggingService();
    
    accountService.validateAccount(user);
    paymentService.processPayment(user, new BigDecimal("99.99"));
    notificationService.sendEmail(user, "Welcome!");
    loggingService.log("User " + user.getName() + " registered");
}

// С Facade (просто):
public class UserRegistrationFacade {
    private AccountService accountService;
    private PaymentService paymentService;
    private NotificationService notificationService;
    private LoggingService loggingService;
    
    public UserRegistrationFacade() {
        this.accountService = new AccountService();
        this.paymentService = new PaymentService();
        this.notificationService = new NotificationService();
        this.loggingService = new LoggingService();
    }
    
    // Один метод скрывает всю сложность
    public void registerUser(User user, BigDecimal registrationFee) {
        loggingService.log("Starting registration for " + user.getName());
        
        accountService.validateAccount(user);
        paymentService.processPayment(user, registrationFee);
        notificationService.sendEmail(user, "Welcome to our service!");
        
        loggingService.log("User " + user.getName() + " successfully registered");
    }
}

// Использование
UserRegistrationFacade facade = new UserRegistrationFacade();
User user = new User("John", "john@example.com");
facade.registerUser(user, new BigDecimal("99.99"));  // Просто и понятно!

Характеристики Facade:

✓ Упрощает интерфейс сложной подсистемы ✓ Скрывает детали реализации ✓ Разделяет клиент от подсистемы ✓ Легче менять реализацию подсистемы ✓ Один метод вместо множества вызовов

❌ Может скрывать слишком много (неосознанные побочные эффекты) ❌ Может стать "God Object" (слишком много обязанностей)

Сравнительная таблица

Практические примеры

Пример 1: Builder для создания запроса

public class HttpRequestBuilder {
    private String url;
    private String method = "GET";
    private Map<String, String> headers = new HashMap<>();
    private String body;
    private int timeout = 30000;
    
    public HttpRequestBuilder url(String url) {
        this.url = url;
        return this;
    }
    
    public HttpRequestBuilder post() {
        this.method = "POST";
        return this;
    }
    
    public HttpRequestBuilder header(String key, String value) {
        headers.put(key, value);
        return this;
    }
    
    public HttpRequestBuilder body(String body) {
        this.body = body;
        return this;
    }
    
    public HttpRequestBuilder timeout(int timeout) {
        this.timeout = timeout;
        return this;
    }
    
    public HttpRequest build() {
        return new HttpRequest(url, method, headers, body, timeout);
    }
}

// Использование
HttpRequest request = new HttpRequestBuilder()
    .url("https://api.example.com/users")
    .post()
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer token123")
    .body('{"name": "John"}')
    .timeout(5000)
    .build();

Пример 2: Facade для работы с БД

public class UserDatabaseFacade {
    private UserRepository userRepository;
    private UserValidator validator;
    private UserMapper mapper;
    private AuditLogger auditLogger;
    
    public UserDTO createUser(CreateUserRequest request) {
        // Facade скрывает всю сложность
        validator.validate(request);  // Валидация
        User user = mapper.toDomain(request);  // Маппирование
        User saved = userRepository.save(user);  // Сохранение
        auditLogger.log("User created", saved.getId());  // Логирование
        return mapper.toDTO(saved);  // Преобразование в DTO
    }
}

// Клиент просто вызывает один метод
UserDatabaseFacade facade = new UserDatabaseFacade(...);
UserDTO newUser = facade.createUser(request);

Когда использовать каждый

Builder:

• Класс имеет более 5 параметров
• Много параметров опциональны
• Нужна гибкость в создании
• Нужны разные комбинации параметров
• Нужна валидация перед созданием

User user = new UserBuilder()
    .firstName("John")
    .email("john@example.com")
    .build();  // Не указали age, address и т.д.

Facade:

• Нужно скрыть сложную подсистему
• Много взаимозависимых операций
• Нужен простой интерфейс для клиентов
• Внутренняя реализация может меняться
• Несколько шагов нужно выполнить вместе

facade.processOrder(order);  // Вместо 10+ отдельных вызовов

Вывод

Builder — это паттерн создания объектов, решает проблему конструирования сложных объектов с множеством параметров.

Facade — это структурный паттерн, решает проблему упрощения интерфейса сложной подсистемы.

Они НЕ конкурируют между собой — они решают разные проблемы и часто используются вместе:

// Используем Builder для создания User
User user = new UserBuilder()
    .firstName("John")
    .email("john@example.com")
    .build();

// Используем Facade для обработки заказа
OrderFacade facade = new OrderFacade(...);
OrderResult result = facade.processOrder(user, items);