设计模式-门面模式

设计模式专栏

---

---

模式介绍

门面模式是一种常用的软件设计模式，也称为外观模式。它提供了一个高层次的接口，将一个子系统的外部与内部通信通过一个统一的对象进行，使得子系统更易于使用。门面模式在系统中主要起中介作用，为复杂的子系统提供一个简单的接口，从而降低了系统的耦合度，提高了系统的灵活性和安全性。

模式特点

• 门面模式的优点主要包括：

1. 减少系统的相互依赖 ：通过门面模式，外部系统只需要与门面对象交互，而不需要直接深入子系统内部，从而降低了系统的耦合度，提高了系统的可维护性和可扩展性。
2. 提高灵活性 ：无论子系统如何变化，门面模式都可以通过调整门面对象的实现来适应这些变化，而不会影响到外部系统的使用。
3. 提高安全性 ：门面模式限制了外部系统对子系统的访问权限，只允许通过门面对象的方法来访问子系统，从而保护了子系统的内部实现细节，防止不必要的访问和修改。

• 门面模式的缺点主要包括：

1. 不符合开闭原则 ：开闭原则是指软件实体应该对扩展开放，对修改封闭。而门面模式需要对原有的子系统进行封装和抽象，从而改变原有子系统的结构和行为，因此可能违反开闭原则。
2. 对维护和修改的要求较高 ：由于门面模式需要抽象原有的子系统，因此需要具备一定的系统设计和分析能力，对维护和修改的要求较高。

应用场景

1. 为复杂的子系统提供一个简单的接口：当客户只需要使用某个复杂系统的子集或者需要以一种特殊的方式与系统交互时，可以使用门面模式。
2. 需要跟踪原系统的使用情况：由于所有对系统的访问都经过门面对象，因此可以很容易地监视系统的使用情况。
3. 希望封装和隐藏原系统时：当需要对原有子系统进行封装和抽象时，可以使用门面模式。
4. 编写新类的成本小于所有人使用和维护原系统使用所需的成本时：当需要降低低水平开发人员带来的风险时，可以通过门面模式指定其只能在子系统中开发，再通过门面接口进行操作。

门面模式和代理模式的区别

门面模式和代理模式都是设计模式中的一种，它们在实现方式、目的和使用场景上存在一些区别。

1. 实现方式 ：门面模式为子系统中的一组接口提供一个一致的界面，定义了一个高层接口，简化了系统的使用。代理模式是为其他对象提供一种代理以控制对这个对象的访问，提供了对原始对象的间接访问。
2. 目的 ：门面模式主要解决易用性问题，将复杂的子系统抽象化，提供更简洁的接口供客户端使用。代理模式则更侧重于控制对对象的访问，提供了更灵活、安全和信息更丰富的访问方式。
3. 使用场景 ：门面模式主要应用在接口设计方面，例如银行柜台办理业务可以理解为门面模式的一种，客户通过银行柜台办理业务，无需了解银行内部复杂的业务逻辑处理。代理模式则适用于需要控制对象访问权限的场景，例如访问网络资源、处理安全敏感的数据等。

门面模式和代理模式都可以起到封装、简化复杂系统的作用，但在使用目的和实现方式上存在区别。根据实际需要解决的问题和场景，选择合适的设计模式可以有效地提高代码质量和系统的可维护性。

代码示例

Java实现门面模式

以下是一个简单的Java示例，展示了如何使用门面模式来封装一个复杂的子系统：

// 门面类
public class Facade {
    private SubSystem1 subSystem1;
    private SubSystem2 subSystem2;
    
    public Facade() {
        subSystem1 = new SubSystem1();
        subSystem2 = new SubSystem2();
    }
    
    // 提供简单的高层接口
    public void doSomething() {
        subSystem1.method1();
        subSystem2.method2();
    }
}

// 子系统1
public class SubSystem1 {
    public void method1() {
        // 实现细节...
    }
}

// 子系统2
public class SubSystem2 {
    public void method2() {
        // 实现细节...
    }
}

在上述示例中，我们创建了一个门面类Facade，它包含了子系统1和子系统2的实例。门面类提供了简单的高层接口doSomething()，通过调用子系统的方法实现了某些功能。客户端代码只需要与门面类交互，而不需要直接与子系统交互，简化了系统的使用。

Python实现门面模式

在Python中实现门面模式也非常直接，我们可以通过创建一个门面类来封装子系统的复杂性。下面是一个Python门面模式的简单示例：

# 子系统类1
class SubSystem1:
    def operation(self):
        print("SubSystem1 operation executed.")

# 子系统类2
class SubSystem2:
    def operation(self):
        print("SubSystem2 operation executed.")

# 门面类
class Facade:
    def __init__(self):
        self.sub_system1 = SubSystem1()
        self.sub_system2 = SubSystem2()

    def unified_operation(self):
        self.sub_system1.operation()
        self.sub_system2.operation()

# 客户端代码
if __name__ == "__main__":
    facade = Facade()
    facade.unified_operation()

在这个示例中，我们有两个子系统类SubSystem1和SubSystem2，每个子系统都有自己的操作。然后，我们创建了一个门面类Facade，它封装了子系统的实例，并提供了一个统一的操作方法unified_operation()。客户端代码只需要与门面类交互，通过调用门面类的统一操作方法即可执行子系统的操作。这样，客户端代码不需要了解子系统的具体实现细节，降低了系统的复杂性。

门面模式在spring中的应用

门面模式在Spring框架中得到了广泛应用，主要用于简化复杂系统的使用。Spring框架提供了许多门面类，例如org.springframework.web.context.support.WebApplicationContext，用于封装Web应用程序的配置和依赖注入。

在Spring中，门面模式通常与依赖注入（Dependency Injection）结合使用。通过依赖注入，Spring框架可以将所需的组件注入到门面类中，从而简化了客户端代码与底层组件之间的交互。

以下是一个简单的示例，展示了如何在Spring中使用门面模式：

1. 定义门面类：

import org.springframework.stereotype.Component;

@Component
public class UserServiceFacade {
    private final UserService userService;

    @Autowired
    public UserServiceFacade(UserService userService) {
        this.userService = userService;
    }

    public void createUser(User user) {
        userService.createUser(user);
    }
}

在上述示例中，我们定义了一个名为UserServiceFacade的门面类，它封装了UserService组件的使用。通过使用@Autowired注解，Spring框架会自动将UserService的实例注入到门面类中。

2. 在客户端代码中使用门面类：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserController {
    private final UserServiceFacade userServiceFacade;

    @Autowired
    public UserController(UserServiceFacade userServiceFacade) {
        this.userServiceFacade = userServiceFacade;
    }

    public void createUser(User user) {
        userServiceFacade.createUser(user);
    }
}

在客户端代码中，我们通过使用@Autowired注解将UserServiceFacade注入到UserController类中。然后，我们可以直接使用门面类的方法来执行所需的操作，而不需要直接与底层组件交互。这样，通过门面模式和依赖注入，我们可以简化客户端代码与底层组件之间的交互，提高代码的可维护性和可扩展性。

设计模式-外观模式

设计模式-代理模式