facade

name	Facade
description	为复杂的系统提供统一的、简化的接口
license	MIT

Facade Pattern (外观模式)

核心概念

Facade 是一种结构型设计模式，为复杂的子系统提供简化的、统一的接口。

核心作用

• 🎭 隐藏复杂性 - 客户端只见简单接口
• 📦 封装子系统 - 内部具体如何实现客户端不关心
• 🔪 物理分离 - 客户端与内部实现解耦
• 🎯 简化使用 - 降低学习成本

何时使用

1. 复杂子系统需要简化 - 多个类协作变成一个接口
2. 客户端与子系统解耦 - 内部改动不影响客户端
3. 按层分离关切 - 如MVC中的Controller作为Facade
4. 第三方库包装 - 统一API、处理版本差异
5. 渐进式重构 - 旧系统前面加Facade

实现方式

方法1: 单一Facade

// 复杂子系统的各个类
public class AuthService { /* 认证逻辑 */ }
public class Database { /* 数据库访问 */ }
public class EmailService { /* 邮件发送 */ }

// Facade - 简化接口
public class UserRegistrationFacade {
    private AuthService auth;
    private Database db;
    private EmailService email;
    
    public UserRegistrationFacade() {
        this.auth = new AuthService();
        this.db = new Database();
        this.email = new EmailService();
    }
    
    // 统一接口
    public void register(String username, String pwd, String mail) {
        // 内部协调3个服务
        auth.validatePassword(pwd);
        db.insertUser(username, pwd);
        email.send(mail, "Welcome!");
    }
}

// 使用
UserRegistrationFacade facade = new UserRegistrationFacade();
facade.register("user", "pwd123", "[e-mail]");

方法2: 多层Facade

// 顶层Facade
public class ApplicationFacade {
    private AuthenticationFacade authFacade;
    private DataProcessingFacade dataFacade;
    
    public void processUserData(String userId) {
        authFacade.authenticate(userId);
        dataFacade.process(userId);
    }
}

// 中层Facade
public class AuthenticationFacade {
    // 管理多个认证相关的类
}

public class DataProcessingFacade {
    // 管理多个数据处理的类
}

方法3: 外观工厂

public class FacadeFactory {
    private static Map<String, Facade> facades = new HashMap<>();
    
    static {
        facades.put("auth", new AuthenticationFacade());
        facades.put("data", new DataProcessingFacade());
    }
    
    public static Facade getFacade(String name) {
        return facades.get(name);
    }
}

// 使用
Facade auth = FacadeFactory.getFacade("auth");

方法4: 动态Facade

public class DynamicFacade {
    private Map<String, Operation> operations = new HashMap<>();
    
    public void register(String operationName, Operation op) {
        operations.put(operationName, op);
    }
    
    public void execute(String operationName, Object... args) {
        Operation op = operations.get(operationName);
        if (op != null) {
            op.execute(args);
        }
    }
}

使用场景

设计原则与最佳实践

核心设计原则

原则1: 最小暴露

// ❌ 过度暴露
public class OrderFacade {
    public OrderService orderService;      // 不应该暴露
    public PaymentService paymentService;
    public ShippingService shippingService;
}

// ✅ 最小暴露
public class OrderFacade {
    private OrderService orderService;
    private PaymentService paymentService;
    private ShippingService shippingService;
    
    public OrderResult placeOrder(Order order) {
        // 只暴露必要的public方法
    }
}

原则2: 单一职责

// ❌ 职责混乱
public class SuperFacade {
    // 包含了所有系统的所有操作！
    public void registerUser() { }
    public void processPayment() { }
    public void sendEmail() { }
    public void generateReport() { }
    public void backupDatabase() { }
}

// ✅ 职责清晰
public class UserRegistrationFacade { }     // 只管注册
public class PaymentFacade { }              // 只管支付
public class NotificationFacade { }         // 只管通知

原则3: 易用性优先

// ❌ 使用复杂
List<Step> steps = new ArrayList<>();
steps.add(authService.validate(creds));
steps.add(dbService.loadUser(userId));
steps.add(emailService.prepare(template));
// 还要客户端合并结果...

// ✅ 易用性好
UserProfile profile = userFacade.registerUser(email, password);
// 一行代码完成复杂流程

---

4种深度实现方法

方法1: 简单Facade（单一服务聚合）

// 复杂子系统
public class CryptoService {
    public String encrypt(String data) { }
    public String decrypt(String data) { }
}

public class ValidationService {
    public boolean isValidEmail(String email) { }
    public boolean isStrongPassword(String pwd) { }
}

public class PersistenceService {
    public void saveUser(User user) { }
    public User loadUser(String id) { }
}

// Facade - 简化接口
public class UserManagementFacade {
    private CryptoService crypto;
    private ValidationService validation;
    private PersistenceService persistence;
    
    public UserManagementFacade() {
        this.crypto = new CryptoService();
        this.validation = new ValidationService();
        this.persistence = new PersistenceService();
    }
    
    
       {
        
         (!validation.isValidEmail(email)) {
             ;
        }
         (!validation.isStrongPassword(password)) {
             ;
        }
        
        
           crypto.encrypt(password);
        
        
            (email, encryptedPwd);
        persistence.saveUser(user);
        
         ;
    }
    
    
     User   Exception {
           persistence.loadUser(email);
         (user == ) {
              ();
        }
        
           crypto.encrypt(password);
         (!encryptedInput.equals(user.getPassword())) {
              ();
        }
        
         user;
    }
}


    ();
 (facade.registerUser(, )) {
    System.out.println();
}

方法2: 分层Facade（PipeLine风格）

// 第1层：基础Facade（处理单个域）
public class AuthenticationFacade {
    private CredentialValidator validator;
    private CryptoService crypto;
    private AuditLog log;
    
    public AuthToken authenticate(String username, String password) {
        validator.validate(username, password);
        
        User user = findUser(username);
        if (!crypto.verify(password, user.hashedPassword)) {
            throw new AuthException("认证失败");
        }
        
        log.record("认证成功: " + username);
        return new AuthToken(user);
    }
}

// 第2层：中层Facade（协调多个基础Facade）
public class OrderProcessingFacade {
    private AuthenticationFacade authFacade;
    private PaymentFacade paymentFacade;
    private InventoryFacade inventoryFacade;
    private ShippingFacade shippingFacade;
    
    public OrderResult placeOrder(AuthToken token, OrderRequest req) {
        // 1. 认证
        authFacade.validate(token);
        
        // 2. 检查库存
        InventoryCheck check = inventoryFacade.checkAvailability(req.items);
        if (!check.available) {
            throw new OutOfStockException();
        }
        
        
           paymentFacade.processPayment(
            req.paymentInfo, 
            req.amount
        );
        
        
           createOrder(req, payment);
        
        
        shippingFacade.scheduleShipment(order);
        
        
          (order, payment);
    }
}


   {
     AuthenticationFacade authFacade;
     OrderProcessingFacade orderFacade;
    
     OrderResponse  {
         {
               authFacade.authenticate(
                req.username, 
                req.password
            );
               orderFacade.placeOrder(token, req);
              (result);
        }  (Exception e) {
              (e);
        }
    }
}

方法3: 策略Facade（模式选择）

// 策略接口
public interface OrderStrategy {
    OrderResult process(OrderRequest req);
}

// 不同策略实现
public class StandardOrderStrategy implements OrderStrategy {
    public OrderResult process(OrderRequest req) {
        // 标准流程
        return standardProcess(req);
    }
}

public class ExpressOrderStrategy implements OrderStrategy {
    public OrderResult process(OrderRequest req) {
        // 快速流程：跳过某些检查
        return expressProcess(req);
    }
}

public class B2BOrderStrategy implements OrderStrategy {
    public OrderResult process(OrderRequest req) {
        // B2B流程：特殊审批
        return b2bProcess(req);
    }
}

// Facade选择合适策略
public class AdaptiveOrderFacade {
    private Map<String, OrderStrategy> strategies = new HashMap<>();
    
    public AdaptiveOrderFacade() {
        strategies.put("standard",  ());
        strategies.put(,  ());
        strategies.put(,  ());
    }
    
     OrderResult  {
        
           determineStrategy(req);
           strategies.get(strategyType);
        
         strategy.process(req);
    }
    
     String  {
         (req.isB2B())  ;
         (req.isExpress())  ;
         ;
    }
}

方法4: 链式Facade（Fluent API风格）

public class FluentOrderFacade {
    private Order order;
    private PaymentResult paymentResult;
    
    public FluentOrderFacade createOrder(OrderRequest req) {
        this.order = new Order(req);
        return this;
    }
    
    public FluentOrderFacade validateOrder() {
        if (!order.isValid()) {
            throw new ValidationException("订单无效");
        }
        return this;
    }
    
    public FluentOrderFacade processPayment(PaymentInfo info) {
        PaymentFacade paymentFacade = new PaymentFacade();
        this.paymentResult = paymentFacade.process(order, info);
        return this;
    }
    
    public FluentOrderFacade checkInventory() {
        InventoryFacade inventoryFacade = new InventoryFacade();
        inventoryFacade.reserve(order.getItems());
        return this;
    }
    
    public FluentOrderFacade scheduleShipment() {
            ();
        shippingFacade.schedule(order);
         ;
    }
    
     OrderResult  {
          (order, paymentResult);
    }
}


    ()
    .createOrder(req)
    .validateOrder()
    .processPayment(paymentInfo)
    .checkInventory()
    .scheduleShipment()
    .complete();

---

使用场景详解

场景1: MVC框架中的Controller

// Model - 数据模型
public class User {
    private String username;
    private String email;
    private Role role;
}

// Service层 - 复杂业务逻辑
public class UserService {
    public boolean validateUsername(String username) { }
    public User findByEmail(String email) { }
    public void saveUser(User user) { }
    public void sendWelcomeEmail(User user) { }
}

public class AuthenticationService {
    public AuthToken login(String username, String password) { }
    public void logout(AuthToken token) { }
}

// Controller - Facade角色
@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private AuthenticationService authService;
    
    // Facade方法1：注册
    @PostMapping("/register")
    public ResponseEntity<User>  {
         {
            
            userService.validateUsername(req.getUsername());
            
            
                (req.getUsername(), req.getEmail());
            userService.saveUser(user);
            
            
            userService.sendWelcomeEmail(user);
            
             ResponseEntity.ok(user);
        }  (Exception e) {
             ResponseEntity.status().build();
        }
    }
    
    
    
     ResponseEntity<LoginResponse>  {
         {
               authService.login(
                req.getUsername(), 
                req.getPassword()
            );
             ResponseEntity.ok( (token));
        }  (Exception e) {
             ResponseEntity.status().build();
        }
    }
}

场景2: ORM框架（Hibernate）

// 复杂的ORM底层操作
public class SessionFactory {
    public Session openSession() { }
}

public class Session {
    public void beginTransaction() { }
    public void save(Object entity) { }
    public void flush() { }
}

public class Transaction {
    public void commit() { }
    public void rollback() { }
}

// Facade - Repository模式
public interface UserRepository {
    void save(User user);
    User findById(Long id);
    List<User> findAll();
    void delete(User user);
}

@Repository
public class HibernateUserRepository implements UserRepository {
    
    
     EntityManager em;  
    
    
    
       {
        
        em.persist(user);
    }
    
    
     User  {
        
         em.find(User.class, id);
    }
    
    
     List<User>  {
        
           em.createQuery();
         query.getResultList();
    }
    
    
    
       {
        em.remove(em.merge(user));
    }
}


   applicationContext.getBean(UserRepository.class);
    (, );
repo.save(user);  

场景3: 第三方库包装

// 复杂的第三方支付库API
import com.alipay.api.*;
import com.alipay.api.request.*;
import com.alipay.api.response.*;
import com.wechat.pay.api.*;

// Facade - 统一支付接口
public class UnifiedPaymentFacade {
    private AlipayClient alipayClient;
    private WechatPayClient wechatClient;
    
    public PaymentResult pay(PaymentRequest req) {
        PaymentMethod method = req.getPaymentMethod();
        
        switch (method) {
            case ALIPAY:
                return processAlipay(req);
            case WECHAT:
                return processWechat(req);
            case CARD:
                return processCard(req);
            default:
                throw new UnsupportedPaymentMethod();
        }
    }
    
    private PaymentResult processAlipay(PaymentRequest req) {
        try {
            // 包装复杂的Alipay API
            AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
            request.setReturnUrl(req.getReturnUrl());
            request.setNotifyUrl(req.getNotifyUrl());
            
            // 构建业务参数
            AlipayTradePagePayModel model = new ();
            model.setOutTradeNo(req.getOrderId());
            model.setTotalAmount(req.getAmount().toString());
            model.setSubject(req.getProductName());
            request.setBizModel(model);
            
            
               
                alipayClient.pageExecute(request);
            
            
              (
                response.isSuccess() ?  : ,
                response.getTradeNo()
            );
        }  (Exception e) {
              (e);
        }
    }
    
     PaymentResult  {
        
    }
    
     PaymentResult  {
        
    }
}


    ();
    ()
    .setOrderId()
    .setAmount( ())
    .setPaymentMethod(PaymentMethod.ALIPAY);

   facade.pay(req);
 (result.isSuccessful()) {
    System.out.println( + result.getTransactionId());
}

场景4: 数据库连接管理

// 复杂的数据源管理
public class DataSourceManager {
    private Map<String, DataSource> dataSources = new HashMap<>();
    private ConnectionPool connectionPool;
    
    public Connection getConnection(String dbName) { }
    public void releaseConnection(Connection conn) { }
    public void closePool() { }
}

// Facade - 简化数据库操作
public class DatabaseAccessFacade {
    private DataSourceManager dsManager;
    private TransactionManager transactionManager;
    private QueryBuilder queryBuilder;
    
    public List<Map<String, Object>> query(String sql, Object... params) {
        Connection conn = null;
        try {
            conn = dsManager.getConnection("default");
            
            PreparedStatement stmt = conn.prepareStatement(sql);
            for (int i = 0; i < params.length; i++) {
                stmt.setObject(i + 1, params[i]);
            }
            
            ResultSet rs = stmt.executeQuery();
            List<Map<String, Object>> results =  <>();
            
             (rs.next()) {
                Map<String, Object> row =  <>();
                 (   ; i <= rs.getMetaData().getColumnCount(); i++) {
                    row.put(
                        rs.getMetaData().getColumnName(i),
                        rs.getObject(i)
                    );
                }
                results.add(row);
            }
            
             results;
        }  {
             (conn != ) {
                dsManager.releaseConnection(conn);
            }
        }
    }
    
       {
           ;
         {
            conn = dsManager.getConnection();
            transactionManager.begin();
            
               conn.prepareStatement(sql);
             (   ; i < params.length; i++) {
                stmt.setObject(i + , params[i]);
            }
            
               stmt.executeUpdate();
            transactionManager.commit();
            
             affected;
        }  (Exception e) {
            transactionManager.rollback();
              (e);
        }  {
             (conn != ) {
                dsManager.releaseConnection(conn);
            }
        }
    }
}


    ();
List<Map<String, Object>> results = facade.query(
    ,
    
);

场景5: 文件处理系统

// 复杂的文件处理库
public class PDFProcessor { }
public class ImageProcessor { }
public class DocumentProcessor { }
public class ZipProcessor { }
public class FileValidator { }
public class FileEncryption { }

// Facade - 统一文件处理
public class FileProcessingFacade {
    private PDFProcessor pdfProcessor;
    private ImageProcessor imageProcessor;
    private FileEncryption encryption;
    private FileValidator validator;
    
    public ProcessResult processFile(File file, ProcessOptions options) {
        // 1. 验证
        if (!validator.isValid(file)) {
            throw new InvalidFileException();
        }
        
        // 2. 确定类型
        FileType type = determineType(file);
        
        // 3. 处理
        Object processed = null;
        switch (type) {
            case PDF:
                processed = pdfProcessor.process(file);
                break;
             IMAGE:
                processed = imageProcessor.process(file);
                ;
            :
                processed = documentProcessor.process(file);
        }
        
        
         (options.shouldEncrypt()) {
            processed = encryption.encrypt(processed);
        }
        
          (processed);
    }
}

---

4个常见问题与深度解决

问题1: Facade vs Adapter的区别？

症状: 混淆Facade和Adapter的使用场景

对比分析:

特性	Facade	Adapter
目的	简化复杂系统	适配不兼容接口
场景	复杂系统 → 客户端	不兼容的类 ↔ 中间件
设计时机	系统设计阶段	集成遗留系统时
介入点	整个子系统前面	两个具体类之间

决策流程:

需要简化使用复杂系统? → Facade
需要适配不兼容的接口? → Adapter

示例对比:

// Facade: 简化Library API
public class LibraryFacade {
    private BookService bookService;
    private LoanService loanService;
    
    public Book borrowBook(String title) {
        // 简化借书流程
    }
}

// Adapter: 适配旧Logger到新Logger
public class OldLoggerAdapter implements NewLogger {
    private OldLogger oldLogger;
    
    @Override
    public void log(String message) {
        oldLogger.logMessage(message);  // 适配
    }
}

问题2: Facade成了"God Object"怎么办？

症状: Facade越来越大，包含了所有操作

预防与修复:

// ❌ God Object
public class ApplicationFacade {
    // 包含了100+个public方法！
    public void registerUser() { }
    public void processPayment() { }
    public void sendEmail() { }
    public void generateReport() { }
    public void backupDatabase() { }
    // 还有很多...
}

// ✅ 拆分成多个小Facade
public interface UserServiceAPI {
    void registerUser();
}

public interface PaymentAPI {
    void processPayment();
}

public interface NotificationAPI {
    void sendEmail();
}

// 只在顶层聚合
public class ApplicationAggregator {
    private UserServicesAPI userAPI;
    private PaymentAPI paymentAPI;
    private NotificationAPI notificationAPI;
}

拆分策略:

1. 按业务域拆分 (Domain-driven)
2. 按操作类型拆分 (Read/Write/Delete)
3. 按访问频率拆分 (Common/Rare)
4. 按数据流拆分 (Input/Process/Output)

问题3: Facade中的错误处理

症状: 不清楚如何在Facade中处理异常

最佳实践:

public class RobustFacade {
    public OrderResult placeOrder(OrderRequest req) {
        try {
            // 1. 验证
            validateOrder(req);
            
            // 2. 处理支付
            processPayment(req);
            
            // 3. 生成订单
            Order order = createOrder(req);
            
            return new OrderResult(true, order);
            
        } catch (ValidationException e) {
            // 预期的业务异常 → 返回给客户端
            return new OrderResult(false, "订单验证失败: " + e.getMessage());
            
        } catch (PaymentException e) {
            // 支付异常 → 回滚
            rollbackOrder(req);
            return new OrderResult(false, "支付失败");
            
        } catch (Exception e) {
            // 未预期的异常 → 记录并降级
            logger.error("订单处理异常", e);
            return new OrderResult(false, "系统错误，请稍后重试");
        }
    }
    
    private void validateOrder(OrderRequest req) throws ValidationException {
        if (req.getItems().isEmpty()) {
              ();
        }
    }
    
        PaymentException {
         (req.getAmount().compareTo(BigDecimal.ZERO) <= ) {
              ();
        }
    }
    
       {
        
    }
}

问题4: 如何测试Facade？

症状: Facade中有太多依赖，测试困难

解决方案 - 使用Mock:

@RunWith(MockitoRunner.class)
public class OrderFacadeTest {
    
    @Mock
    private PaymentService paymentService;
    
    @Mock
    private InventoryService inventoryService;
    
    private OrderFacade facade;
    
    @Before
    public void setup() {
        facade = new OrderFacade(paymentService, inventoryService);
    }
    
    @Test
    public void testSuccessfulOrder() {
        // Arrange
        OrderRequest req = new OrderRequest();
        when(inventoryService.checkAvailability(req.getItems()))
            .thenReturn(new InventoryCheck(true));
        when(paymentService.process(req.getAmount()))
            .thenReturn(new PaymentResult("SUCCESS"));
        
        // Act
        OrderResult result = facade.placeOrder(req);
        
        // Assert
        assertTrue(result.isSuccessful());
        verify(paymentService).process(req.getAmount());
        verify(inventoryService).reserve(req.getItems());
    }
    
    @Test
    public void testPaymentFailure() {
        
        (paymentService.process(any(BigDecimal.class)))
            .thenThrow( ());
        
        
        assertThrows(PaymentException.class, () -> 
            facade.placeOrder( ())
        );
    }
}

---

最佳实践

1. ✅ Facade应该很傻 - 仅做协调，不做复杂业务逻辑
2. ✅ 按业务域分离 - 不要让一个Facade做所有事
3. ✅ 隐藏实现细节 - 不要暴露内部对象
4. ✅ 文档清晰 - 说明每个方法做了什么
5. ✅ 保持简单 - 如果Facade变复杂，考虑拆分

何时避免使用

• ❌ 子系统本身已经很简单 - 直接使用更清晰
• ❌ 不同客户端需要不同接口 - 用Adapter
• ❌ 会变成所有人都用的"万能类" - 这是设计问题信号
• ❌ 只是做传递，没有真正简化 - 这是中间人