23种设计模式（8） Java外观模式

一、什么是外观模式？

外观模式（Facade Pattern）是一种结构型设计模式，它为子系统中的一组接口提供一个一致的接口，使得这个子系统更加容易被使用。

外观模式又称为门面模式，顾名思义，就是像房屋门面一样，将一个复杂的系统或一组类的接口封装起来，提供一个更加简单、易用的接口，使得外部用户通过这个接口就能够完成庞杂的操作。

外观模式的主要作用是简化接口，降低因为复杂度导致的程序难度和学习成本，同时也可以降低依赖性和耦合度。

二、外观模式的角色和实现

外观模式包含以下角色：

• Facade（门面角色）: 外部类，对外提供简单的调用接口，封装系统各个子系统的具体接口和实现；
• Subsystem（子系统角色）: 相对独立的子系统模块，实现子系统具体的功能。

外观模式的实现步骤：

• 创建子系统类和对应的接口；
• 创建门面类，对外提供简单的调用接口，并将调用委派给子系统类完成具体操作。

三、代码示例

1. 简单示例

假设我们要实现一个简单的计算器，可以进行加、减、乘和除等操作，我们可以使用外观模式，将不同的操作封装在不同的子系统中。

1. 首先定义一个计算器接口，包括加、减、乘、除四个方法：

public interface Calculator {
    public void add(double a, double b);
    public void subtract(double a, double b);
    public void multiply(double a, double b);
    public void divide(double a, double b);
}

1. 然后实现具体的子系统类，如加减乘除子系统：

public class AddSystem implements Calculator {
    public void add(double a, double b) {
        System.out.println(a + " + " + b + " = " + (a + b));
    }
    //...其他方法省略
}
public class SubSystem implements Calculator {
    public void subtract(double a, double b) {
        System.out.println(a + " - " + b + " = " + (a - b));
    }
    //...其他方法省略
}
public class MultiplySystem implements Calculator {
    public void multiply(double a, double b) {
        System.out.println(a + " * " + b + " = " + (a * b));
    }
    //...其他方法省略
}
public class DivideSystem implements Calculator {
    public void divide(double a, double b) {
        System.out.println(a + " / " + b + " = " + (a / b));
    }
    //...其他方法省略
}

1. 最后定义一个门面类，将具体的计算操作封装起来，对外提供简单的接口：

public class CalculatorFacade {
    private AddSystem adder;
    private SubSystem subtractor;
    private MultiplySystem multiplier;
    private DivideSystem divider;

    public CalculatorFacade() {
        this.adder = new AddSystem();
        this.subtractor = new SubSystem();
        this.multiplier = new MultiplySystem();
        this.divider = new DivideSystem();
    }

    public void add(double a, double b) {
        adder.add(a, b);
    }
    public void subtract(double a, double b) {
        subtractor.subtract(a, b);
    }
    public void multiply(double a, double b) {
        multiplier.multiply(a, b);
    }
    public void divide(double a, double b) {
        divider.divide(a, b);
    }
}

这样，我们就可以通过门面类来进行计算，避免直接操作子系统类造成的繁琐代码。

2. 网络图片下载示例

假设我们要实现一个网络图片下载的程序，可以下载不同尺寸的图片，并同时获取图片的大小和类型，我们可以使用外观模式封装下载、获取大小和获取类型等复杂的操作。

1. 首先定义三个子系统类，分别用来下载图片、获取图片大小和获取图片类型：

public class ImageDownloader {
    public void download(String url) {
        //下载图片的具体实现
    }
}

public class ImageSizeFetcher {
    public int getSize(String url) {
        //获取图片大小的具体实现
    }
}

public class ImageTypeDetector {
    public String getType(String url) {
        //获取图片类型的具体实现
    }
}

1. 然后定义一个门面类，对外提供下载、获取大小和获取类型等操作：

public class ImageFacade {
    private ImageDownloader downloader;
    private ImageSizeFetcher fetcher;
    private ImageTypeDetector detector;

    public ImageFacade() {
        downloader = new ImageDownloader();
        fetcher = new ImageSizeFetcher();
        detector = new ImageTypeDetector();
    }

    public void download(String url) {
        downloader.download(url);
    }
    public int getSize(String url) {
        return fetcher.getSize(url);
    }
    public String getType(String url) {
        return detector.getType(url);
    }
}

这样，我们就可以通过门面类来进行图片下载、大小计算和类型获取等操作，简化了操作流程并提高了代码可读性。

四、适用场景

当我们需要使用某个系统的接口，又不想暴露系统的复杂内部实现时，可以使用外观模式。

外观模式适用于以下情况：

• 当要为一个复杂子系统对外提供一个简单接口时；
• 当客户程序与抽象类的实现部分之间存在着很大的依赖性；
• 当需要将一个复杂的系统分割成多个子系统时，使用外观模式可以将子系统之间的耦合降到最小。

五、总结

外观模式是一种用来简化接口的设计模式，通过将复杂的内部实现封装起来，提供简单、易用的接口，从而降低系统和子系统之间的耦合度和依赖性。

在程序设计中，外观模式可以帮助我们把复杂的系统设计分成多个模块，使程序结构更加清晰、易于维护。因此，外观模式在实际开发中具有重要的应用价值。