Java结构型模式之门面模式详解

什么是门面模式？

门面模式是一种结构型设计模式，它提供了一个简化系统子系统的接口，可以将复杂的子系统封装起来，使得客户端可以更方便地使用。

为什么需要使用门面模式？

在复杂的软件系统中，有时我们需要通过多个子系统协作来完成某个功能，而这些子系统之间的联系往往比较复杂。如果我们直接调用子系统中的方法，那么代码将会变得非常复杂，维护和修改也很困难，因此我们需要使用门面模式对这些复杂的子系统进行封装。

门面模式的结构

门面模式通常包括以下几个角色：
- Facade：门面类，提供了一个简化的接口给客户端使用，可以直接调用多个子系统中的方法来完成某个功能。
- Subsystem：子系统，由多个类或模块组成，它们之间的联系比较复杂，客户端无法直接调用。
- Client：客户端，使用Facade类提供的简化接口来完成某个功能。

门面模式的UML类图如下所示：

      +---------------------+
      |       Facade        |
      +---------------------+
      | + Operation()       |
      | - method1()         |
      | - method2()         |
      | - method3()         |
      +---------------------+
                  /\
                 /  \
                /    \
               /      \
+--------------+  +--------------+
|  Subsystem 1 |  |  Subsystem 2 |
+--------------+  +--------------+
| + method1()  |  | + method1()  |
| + method2()  |  | + method2()  |
| + method3()  |  | + method3()  |
+--------------+  +--------------+

门面模式的实现

下面我们通过一个示例来演示门面模式的实现。假设我们有一个医院管理系统，它包括患者管理、挂号管理、医生管理等多个子系统，它们之间的联系比较复杂。我们可以使用门面模式对这些子系统进行封装，提供一个简化的接口给患者使用。

// Facade：门面类
class HospitalManagementSystem {
    private final PatientManagement patientManagement;
    private final RegisterManagement registerManagement;
    private final DoctorManagement doctorManagement;

    // 构造函数中初始化子系统
    public HospitalManagementSystem() {
        patientManagement = new PatientManagement();
        registerManagement = new RegisterManagement();
        doctorManagement = new DoctorManagement();
    }

    // 提供一个简化接口
    public void register(String patientName, String doctorName) {
        Patient patient = patientManagement.getPatient(patientName);
        Doctor doctor = doctorManagement.getDoctor(doctorName);
        registerManagement.register(patient, doctor);
    }
}

// Subsystem：子系统之一
class PatientManagement {
    // 根据患者姓名获取患者对象
    public Patient getPatient(String patientName) {
        // 省略实现
        return new Patient();
    }
}

// Subsystem：子系统之二
class RegisterManagement {
    // 挂号
    public void register(Patient patient, Doctor doctor) {
        // 省略实现
    }
}

// Subsystem：子系统之三
class DoctorManagement {
    // 根据医生姓名获取医生对象
    public Doctor getDoctor(String doctorName) {
        // 省略实现
        return new Doctor();
    }
}

// Client：客户端
public class Client {
    public static void main(String[] args) {
        HospitalManagementSystem system = new HospitalManagementSystem();
        system.register("张三", "李四");
    }
}

上面的代码中，HospitalManagementSystem类是门面类，它包括三个子系统：PatientManagement、RegisterManagement、DoctorManagement。Client类使用门面类提供的简化接口来进行挂号操作。

另一个示例

下面我们再来一个示例，假设我们有一个邮件处理系统，它包括邮件发送、接收、读取等多个子系统，我们可以使用门面模式来封装这些子系统，提供一个简化的接口给客户端使用。

// Facade：门面类
class MailSystem {
    private final MailSender mailSender;
    private final MailReceiver mailReceiver;
    private final MailReader mailReader;

    // 构造函数中初始化子系统
    public MailSystem() {
        mailSender = new MailSender();
        mailReceiver = new MailReceiver();
        mailReader = new MailReader();
    }

    // 提供一个简化接口
    public void sendMail(String from, String to, String subject, String body) {
        mailSender.sendMail(new Mail(from, to, subject, body));
    }

    public List<Mail> readMails(String user, String password) {
        List<Mail> mails = new ArrayList<>();
        List<String> mailIds = mailReceiver.getMailIds(user, password);
        for (String mailId : mailIds) {
            Mail mail = mailReader.readMail(mailId);
            mails.add(mail);
        }
        return mails;
    }
}

// Subsystem：子系统之一
class MailSender {
    // 发送邮件
    public void sendMail(Mail mail) {
        // 省略实现
    }
}

// Subsystem：子系统之二
class MailReceiver {
    // 获取邮件ID列表
    public List<String> getMailIds(String user, String password) {
        // 省略实现
        return new ArrayList<>();
    }
}

// Subsystem：子系统之三
class MailReader {
    // 根据邮件ID读取邮件
    public Mail readMail(String mailId) {
        // 省略实现
        return new Mail();
    }
}

// Mail类
class Mail {
    private final String from;
    private final String to;
    private final String subject;
    private final String body;

    public Mail(String from, String to, String subject, String body) {
        this.from = from;
        this.to = to;
        this.subject = subject;
        this.body = body;
    }

    // 省略getter方法
}

// Client：客户端
public class Client {
    public static void main(String[] args) {
        MailSystem system = new MailSystem();
        system.sendMail("[e-mail]", "[e-mail]", "Hello", "World");
        List<Mail> mails = system.readMails("[e-mail]", "password");
        for (Mail mail : mails) {
            // 处理邮件
        }
    }
}

上面的代码中，MailSystem类是门面类，它包括三个子系统：MailSender、MailReceiver、MailReader。Client类使用门面类提供的简化接口来进行发送和读取邮件操作。

总结

门面模式可以将复杂的子系统封装起来，提供一个简化的接口给客户端使用。它可以使得客户端更方便地使用系统，同时也可以将系统的复杂性隐藏起来，方便后续的维护和升级。