门面模式

柏油
179 阅读7分钟

门面模式

门面模式（Facade Pattern）是一种结构型设计模式，它提供了一个统一的接口，用来访问子系统中的一群接口。门面模式定义了一个高层接口，使得这一子系统更加容易使用。

门面模式的主要目的是简化客户端与复杂系统之间的交互。通过引入一个门面类，客户端可以通过这个门面类来访问系统中的各个子系统，而不需要了解子系统的复杂实现。

// 电视类
public class TV {
    public void on() {
        System.out.println("电视打开");
    }

    public void off() {
        System.out.println("电视关闭");
    }
}

// 音响类
public class SoundSystem {
    public void on() {
        System.out.println("音响打开");
    }

    public void off() {
        System.out.println("音响关闭");
    }
}

// DVD播放器类
public class DVDPlayer {
    public void on() {
        System.out.println("DVD播放器打开");
    }

    public void off() {
        System.out.println("DVD播放器关闭");
    }
}

门面类：

public class HomeTheaterFacade {
    private TV tv;
    private SoundSystem soundSystem;
    private DVDPlayer dvdPlayer;

    public HomeTheaterFacade() {
        this.tv = new TV();
        this.soundSystem = new SoundSystem();
        this.dvdPlayer = new DVDPlayer();
    }

    public void watchMovie() {
        System.out.println("准备看电影...");
        tv.on();
        soundSystem.on();
        dvdPlayer.on();
    }

    public void endMovie() {
        System.out.println("电影结束...");
        tv.off();
        soundSystem.off();
        dvdPlayer.off();
    }
}

客户端代码：

public class Client {
    public static void main(String[] args) {
        HomeTheaterFacade homeTheater = new HomeTheaterFacade();
        homeTheater.watchMovie();
        System.out.println("电影正在播放...");
        homeTheater.endMovie();
    }
}

// 输出
准备看电影...
电视打开
音响打开
DVD播放器打开
电影正在播放...
电影结束...
电视关闭
音响关闭
DVD播放器关闭

门面模式的核心思想就是通过组合和封装，将复杂的子系统接口简化为一个统一的接口，从而简化客户端的使用。门面模式的主要目的是提高系统的易用性和可维护性，而不是改变系统的功能。

门面模式的优点包括：

  1. 简化接口：通过提供一个简单的接口，隐藏子系统的复杂性，使得客户端代码更加简洁。
  2. 松散耦合：客户端与子系统之间的耦合度降低，客户端不需要了解子系统的具体实现。
  3. 更好的分层：门面模式可以帮助我们更好地分层，明确各个模块的职责。

当然，门面模式也有一些局限性：

  1. 单一职责原则：门面类可能会变得过于庞大，承担过多的职责。
  2. 性能问题：如果门面类封装了过多的子系统调用，可能会影响性能。

门面模式变体之SLF4J

SLF4J（Simple Logging Facade for Java）是一种变体的门面模式，其提供了一个统一的日志记录接口，允许开发者在不改变代码的情况下切换不同的日志记录实现（例如Logback、Log4j 等）。

SLF4J的门面模式实现

SLF4J 的核心思想是提供一个简单的、统一的日志记录接口，而具体的日志记录实现则由不同的日志框架提供。

这样，开发者只需要依赖 SLF4J 的接口，而不需要直接依赖具体的日志框架，从而实现了日志框架的可插拔性。

引入依赖：

<dependencies>
    <!-- SLF4J API -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.30</version>
    </dependency>
    <!-- Logback 实现 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
</dependencies>

如上，引入了 SLF4J API，以及实现了 SLF4J 的 Logback。

日志记录：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SLF4JExample {
    // 获取Logger实例
    private static final Logger logger = LoggerFactory.getLogger(SLF4JExample.class);

    public static void main(String[] args) {
        logger.info("这是一个信息日志");
        logger.warn("这是一个警告日志");
        logger.error("这是一个错误日志");

        try {
            int result = 10 / 0;
        } catch (Exception e) {
            logger.error("error: ", e);
        }
    }
}

SLF4J 通过门面模式提供了一个统一的日志记录接口，使得开发者可以在不改变代码的情况下切换不同的日志实现。

这种设计不仅简化了日志记录的使用，还提高了系统的灵活性和可维护性。

通过这种方式，SLF4J 成功地将日志记录的复杂性隐藏在了门面背后，提供了一个简单易用的接口。

SLF4J 与传统定义的门面模式有一些不同，但它仍然可以被视为一种门面模式的变体。

传统门面模式

传统的门面模式（Facade Pattern）通常是指通过一个简单的接口来封装复杂的子系统，从而简化客户端的使用。

门面模式的主要目的是隐藏子系统的复杂性，提供一个统一的接口。

比如上面播放电影的例子，将子系统（或 service） 的几个业务逻辑通过门面封装起来，对外提供统一的接口调用；

这样，上层系统就不必关心的业务功能，两层相互解耦，即使后续某个逻辑升级变动，我们直接修改门面类，而对上层没有改动。

SLF4J的门面模式

SLF4J 的设计目标是提供一个统一的日志记录接口，而具体的日志实现则由不同的日志框架提供。

虽然 SLF4J 并没有直接封装多个子系统的复杂性，但它通过提供一个统一的接口，简化了日志记录的使用，并且允许在不修改客户端代码的情况下切换不同的日志实现。

SLF4J与传统门面模式的对比

  1. 统一接口：SLF4J 提供了一个统一的日志记录接口，类似于传统门面模式提供的统一接口。
  2. 隐藏实现细节：SLF4J 隐藏了具体日志框架的实现细节，客户端只需要依赖 SLF4J 的接口，而不需要了解具体的日志框架。
  3. 可插拔性：SLF4J 允许在不修改客户端代码的情况下切换不同的日志实现，这一点与传统门面模式有所不同，但实现了类似的目标，即简化客户端的使用。

简言之：SLF4J 通过提供一个统一的日志记录接口，隐藏了具体日志框架的实现细节，简化了客户端的使用，并且允许在不修改客户端代码的情况下切换不同的日志实现。这种设计实现了门面模式的核心目标，即简化客户端的使用和提高系统的灵活性。

门面模式与其他模式的关系

适配器模式

适配器模式定义：适配器模式是一种结构型设计模式，它将一个类的接口转换成客户希望的另一个接口。

适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

主要特点
  1. 接口转换：适配器模式将一个类的接口转换成另一个接口，使得不兼容的类可以一起工作。
  2. 复用现有类：它允许复用现有的类，而不需要修改其源代码。
  3. 两种形式：适配器模式有对象适配器和类适配器两种形式。对象适配器使用组合，类适配器使用继承。
代码示例

假设我们有一个旧的支付系统和一个新的支付系统，我们希望通过适配器模式来统一它们的接口：

// 旧的支付系统
class OldPaymentSystem {
    public void makePayment() {
        System.out.println("使用旧系统进行支付");
    }
}

// 新的支付系统接口
interface NewPaymentSystem {
    void processPayment();
}

// 适配器类
class PaymentAdapter implements NewPaymentSystem {
    private OldPaymentSystem oldPaymentSystem;

    public PaymentAdapter(OldPaymentSystem oldPaymentSystem) {
        this.oldPaymentSystem = oldPaymentSystem;
    }

    @Override
    public void processPayment() {
        oldPaymentSystem.makePayment();
    }
}

// 客户端代码
public class AdapterPatternExample {
    public static void main(String[] args) {
        OldPaymentSystem oldPaymentSystem = new OldPaymentSystem();
        NewPaymentSystem paymentSystem = new PaymentAdapter(oldPaymentSystem);
        paymentSystem.processPayment();
    }
}

对比：

门面模式

  • 目的：简化对复杂子系统的访问。
  • 使用场景：当你需要提供一个简单的接口来访问一个复杂的子系统时。
  • 优点：简化接口，隐藏复杂性，降低耦合度。

适配器模式

  • 目的：将一个类的接口转换成客户希望的另一个接口。
  • 使用场景：当你需要使用一个现有的类，但它的接口不符合你的需求时。
  • 优点：接口转换，复用现有类，不需要修改源代码。

中介者模式

门面模式和中介者模式的职责类似： 它们都尝试在大量紧密耦合的类中组织起合作。

  • 门面 为子系统中的所有对象定义了一个简单接口，但是它不提供任何新功能。子系统本身不会意识到外观的存在。子系统中的对象可以直接进行交流。
  • 中介者 将系统中组件的沟通行为中心化。各组件只知道中介者对象，无法直接相互交流。
avatar
文章
阅读
粉丝