facade
为复杂的系统提供统一的、简化的接口
معلومات المصدر
- المستودع
- microwind/ai-skills
- آخر نشاط في المصدر
- ٣١ مارس ٢٠٢٦ في ٠١:٢٧
- لغة SKILL.md المكتشفة
- الصينية
- النجوم
- ٨٣
- التفرعات
- ٢٤
خيارات التثبيت
يُحدَّد Prompt الذي يراجع المصدر أولًا بشكل افتراضي. يمكنك التبديل إلى أمر مباشر أو تنزيل نسخة محلية.
مراجعة ملفات المصدر
اقرأ SKILL.md وأي ملفات مرافقة يعرضها SkillsMP قبل أن تقرر التثبيت.
مستكشف الملفات
4 ملفاتعرض SKILL.md
SKILL.md
تعليمات المصدر · معاينة للقراءة فقط- name
- Facade
- description
- 为复杂的系统提供统一的、简化的接口
- license
- MIT
# 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");
عرض على GitHubملف SKILL.md هذا كبير جدا، لذلك يعرض SkillsMP القسم الاول فقط هنا. عرض على GitHub
