facade

# Facade Pattern (外观模式) ## 核心概念 **Facade** 是一种**结构型设计模式**，为复杂的子系统提供简化的、统一的接口。 ### 核心作用 - 🎭 **隐藏复杂性** - 客户端只见简单接口 - 📦 **封装子系统** - 内部具体如何实现客户端不关心 - 🔪 **物理分离** - 客户端与内部实现解耦 - 🎯 **简化使用** - 降低学习成本 ## 何时使用 1. **复杂子系统需要简化** - 多个类协作变成一个接口 2. **客户端与子系统解耦** - 内部改动不影响客户端 3. **按层分离关切** - 如MVC中的Controller作为Facade 4. **第三方库包装** - 统一API、处理版本差异 5. **渐进式重构** - 旧系统前面加Facade ## 实现方式 ### 方法1: 单一Facade ```java // 复杂子系统的各个类 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", "user@mail.com"); ``` ### 方法2: 多层Facade ```java // 顶层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: 外观工厂 ```java 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 ```java 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: 最小暴露** ```java // ❌ 过度暴露 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: 单一职责** ```java // ❌ 职责混乱 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: 易用性优先** ```java // ❌ 使用复杂 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（单一服务聚合） ```java // 复杂子系统 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(); } // 简化的用户注册流程 public boolean registerUser(String email, String password) { // 1. 验证 if (!validation.isValidEmail(email)) { return false; } if (!validation.isStrongPassword(password)) { return false; } // 2. 加密 String encryptedPwd = crypto.encrypt(password); // 3. 保存 User user = new User(email, encryptedPwd); persistence.saveUser(user); return true; } // 简化的用户登录流程 public User login(String email, String password) throws Exception { User user = persistence.loadUser(email); if (user == null) { throw new AuthException("用户不存在"); } String encryptedInput = crypto.encrypt(password); if (!encryptedInput.equals(user.getPassword())) { throw new AuthException("密码错误"); } return user; } } // 使用 UserManagementFacade facade = new UserManagementFacade(); if (facade.registerUser("user@example.com", "P@ssw0rd!")) { System.out.println("注册成功"); } ``` ### 方法2: 分层Facade（PipeLine风格） ```java // 第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(); } // 3. 处理支付 Payment payment = paymentFacade.processPayment( req.paymentInfo, req.amount ); // 4. 生成订单 Order order = createOrder(req, payment); // 5. 安排发货 shippingFacade.scheduleShipment(order); // 6. 返回结果 return new OrderResult(order, payment); } } // 第3层：应用Facade（暴露给外部API） public class ApplicationFacade { private AuthenticationFacade authFacade; private OrderProcessingFacade orderFacade; public OrderResponse handleOrderAPI(OrderRequest req) { try { AuthToken token = authFacade.authenticate( req.username, req.password ); OrderResult result = orderFacade.placeOrder(token, req); return new OrderResponse(result); } catch (Exception e) { return new OrderResponse(e); } } } ``` ### 方法3: 策略Facade（模式选择） ```java // 策略接口 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", new StandardOrderStrategy()); strategies.put("express", new ExpressOrderStrategy()); strategies.put("b2b", new B2BOrderStrategy()); } public OrderResult placeOrder(OrderRequest req) { // 根据订单类型选择策略 String strategyType = determineStrategy(req); OrderStrategy strategy = strategies.get(strategyType); return strategy.process(req); } private String determineStrategy(OrderRequest req) { if (req.isB2B()) return "b2b"; if (req.isExpress()) return "express"; return "standard"; } } ``` ### 方法4: 链式Facade（Fluent API风格） ```java 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 shippingFacade = new ShippingFacade(); shippingFacade.schedule(order); return this; } public OrderResult complete() { return new OrderResult(order, paymentResult); } } // 使用 - 链式调用 OrderResult result = new FluentOrderFacade() .createOrder(req) .validateOrder() .processPayment(paymentInfo) .checkInventory() .scheduleShipment() .complete(); ``` --- ## 使用场景详解 ### 场景1: MVC框架中的Controller ```java // 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> register(@RequestBody RegisterRequest req) { try { // 验证 userService.validateUsername(req.getUsername()); // 创建用户 User user = new User(req.getUsername(), req.getEmail()); userService.saveUser(user); // 发送欢迎邮件 userService.sendWelcomeEmail(user); return ResponseEntity.ok(user); } catch (Exception e) { return ResponseEntity.status(400).build(); } } // Facade方法2：登录 @PostMapping("/login") public ResponseEntity<LoginResponse> login(@RequestBody LoginRequest req) { try { AuthToken token = authService.login( req.getUsername(), req.getPassword() ); return ResponseEntity.ok(new LoginResponse(token)); } catch (Exception e) { return ResponseEntity.status(401).build(); } } } ``` ### 场景2: ORM框架（Hibernate） ```java // 复杂的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 { @PersistenceContext private EntityManager em; // Spring管理的Session @Override @Transactional public void save(User user) { // Facade隐藏了复杂的Transaction、flush操作 em.persist(user); } @Override public User findById(Long id) { // 隐藏Query、ResultSet等复杂操作 return em.find(User.class, id); } @Override public List<User> findAll() { // 隐藏JPQL、Criteria等查询复杂性 Query query = em.createQuery("FROM User"); return query.getResultList(); } @Override @Transactional public void delete(User user) { em.remove(em.merge(user)); } } // 使用 - 客户端无需知道Session、Transaction细节 UserRepository repo = applicationContext.getBean(UserRepository.class); User user = new User("John", "john@example.com");