JAVA设计模式之门面模式

门面模式（Facade Pattern）是一种结构型设计模式，它为一组复杂的子系统提供了一个简单的接口，使得子系统更容易使用和理解。在 Java 中，门面模式通常使用一个门面类（Facade Class）来包装一个或多个复杂的子系统，使得客户端只需要和门面类交互，而不需要直接与子系统交互。

门面模式通常在以下情况下使用：

1. 将复杂的子系统进行抽象和封装：当一个系统变得复杂时，往往会由多个子系统组成。门面模式可以将这些子系统进行抽象和封装，提供一个简单的接口供客户端使用。
2. 隐藏子系统的复杂性：门面模式可以将子系统的复杂性隐藏起来，使得客户端不需要了解子系统的内部实现细节。
3. 提供一个简单的接口：门面模式可以为客户端提供一个简单的接口，使得客户端可以更容易地使用子系统。
4. 降低客户端与子系统的耦合：门面模式可以将客户端和子系统解耦，使得客户端不需要了解子系统的内部实现细节，也不需要直接和子系统交互。

在 Java 中，门面模式通常用于以下场景：

1. 对外提供 API：当一个系统需要对外提供 API 时，可以使用门面模式将 API 进行封装，使得客户端只需要使用一个简单的接口就可以调用系统的功能。
2. 与其他系统进行交互：当一个系统需要与其他系统进行交互时，可以使用门面模式将与其他系统的交互进行封装，使得系统可以更容易地与其他系统进行集成。
3. 简化复杂的操作：当一个系统需要进行复杂的操作时，可以使用门面模式将操作进行封装，使得操作可以更容易地使用和理解。
4. 对系统进行分层：当一个系统需要进行分层时，可以使用门面模式将不同层之间的接口进行封装，使得各层之间的依赖关系更加清晰，同时也更容易进行维护和修改。

例子一：

当一个系统需要与多个第三方服务进行交互时，可以使用门面模式来对这些服务进行封装，使得客户端只需要与一个门面类交互就可以完成对多个服务的调用。下面是一个简单的示例代码：

// 外部服务接口
interface ExternalService {
    void doSomething();
}

// 外部服务实现类1
class ExternalServiceImpl1 implements ExternalService {
    @Override
    public void doSomething() {
        System.out.println("ExternalServiceImpl1.doSomething");
    }
}

// 外部服务实现类2
class ExternalServiceImpl2 implements ExternalService {
    @Override
    public void doSomething() {
        System.out.println("ExternalServiceImpl2.doSomething");
    }
}

// 门面类
class Facade {
    private ExternalService service1;
    private ExternalService service2;
    
    public Facade() {
        service1 = new ExternalServiceImpl1();
        service2 = new ExternalServiceImpl2();
    }
    
    public void doSomething1() {
        service1.doSomething();
    }
    
    public void doSomething2() {
        service2.doSomething();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.doSomething1();
        facade.doSomething2();
    }
}

在这个示例中，ExternalService 是一个外部服务的接口，ExternalServiceImpl1 和 ExternalServiceImpl2 是这个接口的两个具体实现。Facade 是一个门面类，它将这两个外部服务进行封装，并提供了两个简单的方法 doSomething1 和 doSomething2。客户端只需要与 Facade 类交互，就可以完成对这两个服务的调用。

当一个系统需要访问多个不同的数据库时，可以使用门面模式来对这些数据库进行封装，使得客户端只需要与一个门面类交互就可以完成对多个数据库的访问。下面是一个简单的示例代码：

// 数据库接口
interface Database {
    void execute(String sql);
}

// MySQL数据库实现类
class MySQLDatabase implements Database {
    @Override
    public void execute(String sql) {
        System.out.println("Executing " + sql + " in MySQL database");
    }
}

// Oracle数据库实现类
class OracleDatabase implements Database {
    @Override
    public void execute(String sql) {
        System.out.println("Executing " + sql + " in Oracle database");
    }
}

// 门面类
class DatabaseFacade {
    private Database mysqlDatabase;
    private Database oracleDatabase;
    
    public DatabaseFacade() {
        mysqlDatabase = new MySQLDatabase();
        oracleDatabase = new OracleDatabase();
    }
    
    public void executeSQL(String sql, String databaseType) {
        if (databaseType.equals("MySQL")) {
            mysqlDatabase.execute(sql);
        } else if (databaseType.equals("Oracle")) {
            oracleDatabase.execute(sql);
        } else {
            throw new IllegalArgumentException("Unknown database type: " + databaseType);
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        DatabaseFacade facade = new DatabaseFacade();
        facade.executeSQL("SELECT * FROM users", "MySQL");
        facade.executeSQL("SELECT * FROM customers", "Oracle");
    }
}

Database 是一个数据库接口，MySQLDatabase 和 OracleDatabase 是这个接口的两个具体实现。DatabaseFacade 是一个门面类，它将这两个数据库进行封装，并提供了一个 executeSQL 方法，用于执行 SQL 语句。客户端只需要与 DatabaseFacade 类交互，并指定要访问的数据库类型，就可以完成对这两个数据库的访问。

以下是一些策略和指导方针：

1. 单一职责原则（SRP）：每个接口或方法应该只有一个单一的职责。这可以保持接口的简单性，并使其更易于理解和使用。
2. 抽象程度：接口的设计应该足够抽象，能够容纳多种具体的实现，这可以提高接口的通用性。但是，过度的抽象可能会使接口难以理解和使用，因此需要找到一个合适的平衡点。
3. 尽量减少接口的依赖性：接口的方法不应该有过多的参数，尽量减少对其他对象或方法的依赖。这样可以使接口更简单，更易于使用。
4. 易于使用的API：设计接口时，应考虑使用者的需求和使用场景。应提供易于使用的API，例如，提供默认参数，使用有意义的方法和变量名，以及充分的文档和示例。
5. 灵活性和扩展性：接口设计应考虑未来可能的改变和扩展。接口的方法和参数应该有足够的灵活性，可以适应新的需求和变化。
6. 封装：接口应该尽可能地隐藏其实现的细节。这可以使接口更易于使用，同时也可以防止使用者直接访问和修改内部状态。

门面模式的应用场景举例

还要强调一下，门面模式定义中的“子系统（subsystem）”也可以有多种理解方式。它既可以是一个完整的系统，也可以是更细粒度的类或者模块。关于这一点，在下面的讲解中也会有体现。

门面模式可以让子系统更加易用，实际上，它除了解决易用性问题之外，还能解决其他很多方面的问题，如分布式事物等。

源码使用

门面模式在 JDK 源码中有很多应用。以下是一些常见的使用场景：

（1）JDBC：在 Java 中使用 JDBC 连接数据库时，通常会使用 DriverManager 来获取连接。DriverManager 就是一个门面类，它将多个数据库驱动进行封装，使得客户端只需要使用一个简单的接口就可以访问不同的数据库。

（2）Spring 框架：在 Spring 框架中，ApplicationContext 就是一个门面类，它将 Spring 中的各个组件进行封装，使得客户端可以更容易地使用 Spring 中的功能。

（3）Servlet API：在 Servlet API 中，HttpServletRequest 和 HttpServletResponse 接口就是门面类，它们将底层的网络通信进行封装，使得开发者可以更容易地编写 Web 应用程序。

使用场景

在生产环境中，门面模式常常用于封装复杂的第三方 API 或系统，以提供简单、易用的接口给客户端使用。一个具体的例子是，假设系统需要与多个支付系统进行交互，而每个支付系统的接口和参数都不一样，这时候就可以使用门面模式来对这些支付系统进行封装，使得客户端只需要使用一个简单的接口就可以完成对多个支付系统的调用。

以下是一个示例代码：

// 支付系统接口
interface PaymentSystem {
    void pay(double amount);
}

// 支付宝接口实现类
class AliPay implements PaymentSystem {
    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付：" + amount + "元");
    }
}

// 微信支付接口实现类
class WeChatPay implements PaymentSystem {
    @Override
    public void pay(double amount) {
        System.out.println("微信支付：" + amount + "元");
    }
}

// 门面类
class PaymentFacade {
    private PaymentSystem aliPay;
    private PaymentSystem weChatPay;
    
    public PaymentFacade() {
        aliPay = new AliPay();
        weChatPay = new WeChatPay();
    }
    
    public void payByAliPay(double amount) {
        aliPay.pay(amount);
    }
    
    public void payByWeChatPay(double amount) {
        weChatPay.pay(amount);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        PaymentFacade paymentFacade = new PaymentFacade();
        paymentFacade.payByAliPay(100.0);
        paymentFacade.payByWeChatPay(200.0);
    }
}

在这个示例中，PaymentSystem 是支付系统的接口，AliPay 和 WeChatPay 是这个接口的两个具体实现。PaymentFacade 是一个门面类，它将这两个支付系统进行封装，并提供了两个简单的方法 payByAliPay 和 payByWeChatPay。客户端只需要与 PaymentFacade 类交互，就可以完成对这两个支付系统的调用。这种方式可以方便地支持新的支付系统的加入，同时也可以提高客户端的调用效率和代码可读性。

适配器模式和门面模式都可以将不好用的接口适配成好用的接口，他们之间又有什么区别：

1. 目标和目的：

• 适配器模式：适配器模式的目标是为了让现有接口能适配不同的类，让不兼容的接口能够一起工作。这是为了解决接口不兼容性问题，可以在没有修改源码的情况下使用现有的类。
• 门面模式：门面模式的目标是为了提供一个统一的高级接口，隐藏子系统的复杂性。这是为了简化客户端对子系统的访问和使用。

2. 应用场景：

• 适配器模式：希望将一个已经存在的类的接口转换成另一个接口以供客户程序使用，或者当希望创建一个可重用的类，这个类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作时，可以使用适配器模式。
• 门面模式：当希望为一个复杂的子系统提供一个简单的接口，或者客户程序与多个子系统之间存在大量的依赖关系时，可以使用门面模式。

3. 封装级别和复杂性：

• 适配器模式：适配器模式通常只包装一个类或对象，将一个接口转换为另一个接口。
• 门面模式：门面模式包装了一整个子系统或者一组接口，将一系列复杂操作封装成一个简单的接口。

【文章转自：防御服务器 http://www.558idc.com/aqt.html提供，感恩】