Technology Sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

The Facade design pattern, also known as the appearance pattern, is a structural design pattern. It is mainly used to provide a unified high-level interface for a group of interfaces in a subsystem, making the subsystem easier to use. The following is a detailed introduction to the Facade design pattern:

I. Definition

The Facade pattern provides an external interface for multiple complex subsystems, making these subsystems easier to access. This pattern has a unified external interface, and external applications do not need to care about the details of the subsystem, which greatly reduces the complexity of the application and improves maintainability.

2. Motivation and Purpose

• Reduce complexity: By encapsulating the complexity of the subsystem in the Facade class, the client can call the subsystem through a simple interface without having to have an in-depth understanding of the specific implementation of the subsystem.
• Improve usability: The Facade pattern provides a simple interface that makes it easier for clients to use the subsystem.
• Loose coupling: By introducing the Facade class, the coupling between the client and the subsystem is reduced, so that changes within the subsystem will not affect the client.

3. Structure and Class Diagram

Class Diagram:

The Facade pattern mainly includes the following three roles:

• Facade：The client can call the methods of this role. The facade class knows the functions and responsibilities of the relevant (one or more) subsystems. Under normal circumstances, this role will delegate all requests sent from the client to the corresponding subsystem.
• Subsystem: There can be one or more subsystems at the same time. Each subsystem is not a separate class, but a collection of classes. Each subsystem can be called directly by the client or by the facade role. The subsystem is unaware of the existence of the facade. For the subsystem, the facade is just another client.
• Client：Users call the subsystem functions through the appearance class.

4. Advantages and Disadvantages

advantage

1. Reduce system complexity: By providing a simple interface for the subsystem, it makes it easier for clients to understand and use the system.
2. Improve system flexibility: When changes occur within the subsystem, only the Facade class needs to be modified without modifying the client code.
3. The law of Demeter: By introducing the Facade class, the dependency between the client and the subsystem is reduced.

shortcoming

1. Adding subsystems or extending subsystem behavior can easily introduce risks: Because all requests need to be forwarded through the Facade class, if the Facade class is not designed properly, new risks may be introduced.
2. Not in compliance with the opening and closing principle: In some cases, if the system needs to be expanded, the code of the Facade class may need to be modified, which violates the open-closed principle (that is, open for extension and closed for modification).

5. Application Scenarios

• When the system needs to provide a simple interface to the outside world, the Facade pattern can be used.
• The Facade pattern can be used when a system needs to hide the complexity of a subsystem.
• When you need to build a multi-layer system structure, you can use the Facade object as the entrance to each layer to simplify hierarchical calls.

6. Implementation Example

In a home theater system, the Facade pattern can be used to simplify user operations. For example, users only need to use one remote control (Facade class) to control devices (subsystems) such as projectors, audio systems, and DVD players, without having to operate these devices separately.

// 投影仪接口  
interface Projector {  
    void on();  
    void off();  
    void focus();  
    void wideScreenMode();  
}  
  
// 投影仪实现类  
class SimpleProjector implements Projector {  
    @Override  
    public void on() {  
        System.out.println("Projector is on");  
    }  
  
    @Override  
    public void off() {  
        System.out.println("Projector is off");  
    }  
  
    @Override  
    public void focus() {  
        System.out.println("Adjusting projector focus");  
    }  
  
    @Override  
    public void wideScreenMode() {  
        System.out.println("Switching to wide screen mode");  
    }  
}  
  
// DVD播放器接口  
interface DVDPlayer {  
    void on();  
    void off();  
    void play();  
    void stop();  
    void pause();  
    void eject();  
    void setTwoChannelAudio();  
    void setSurroundAudio();  
}  
  
// DVD播放器实现类  
class SimpleDVDPlayer implements DVDPlayer {  
    @Override  
    public void on() {  
        System.out.println("DVD Player is on");  
    }  
  
    @Override  
    public void off() {  
        System.out.println("DVD Player is off");  
    }  
  
    @Override  
    public void play() {  
        System.out.println("DVD Player is playing");  
    }  
  
    @Override  
    public void stop() {  
        System.out.println("DVD Player stopped");  
    }  
  
    @Override  
    public void pause() {  
        System.out.println("DVD Player paused");  
    }  
  
    @Override  
    public void eject() {  
        System.out.println("DVD ejected");  
    }  
  
    @Override  
    public void setTwoChannelAudio() {  
        System.out.println("Stereo mode is on");  
    }  
  
    @Override  
    public void setSurroundAudio() {  
        System.out.println("Surround sound mode is on");  
    }  
}  
  
// 音响接口  
interface Amplifier {  
    void on();  
    void off();  
    void setStereoSound();  
    void setSurroundSound();  
    void setVolume(int volume);  
}  
  
// 音响实现类  
class StereoAmplifier implements Amplifier {  
    @Override  
    public void on() {  
        System.out.println("Amplifier is on");  
    }  
  
    @Override  
    public void off() {  
        System.out.println("Amplifier is off");  
    }  
  
    @Override  
    public void setStereoSound() {  
        System.out.println("Stereo mode is on");  
    }  
  
    @Override  
    public void setSurroundSound() {  
        System.out.println("Surround sound mode is on");  
    }  
  
    @Override  
    public void setVolume(int volume) {  
        System.out.println("Setting volume to " + volume);  
    }  
}  
  
// 家庭影院Facade类  
class HomeTheaterFacade {  
    private Projector projector;  
    private DVDPlayer dvdPlayer;  
    private Amplifier amplifier;  
  
    public HomeTheaterFacade(Projector projector, DVDPlayer dvdPlayer, Amplifier amplifier) {  
        this.projector = projector;  
        this.dvdPlayer = dvdPlayer;  
        this.amplifier = amplifier;  
    }  
  
    // 提供一个简单的方法来观看电影  
    public void watchMovie(String movie) {  
        System.out.println("Get ready to watch a movie...");  
  
        projector.on();  
        projector.wideScreenMode();  
  
        amplifier.on();  
        amplifier.setSurroundSound();  
        amplifier.setVolume(5);  
  
        dvdPlayer.on();  
        dvdPlayer.play(movie);  
  
        System.out.println("Enjoy the movie...");  
    }  
  
    // 提供一个简单的方法来结束观看  
    public void endMovie() {  
        System.out.println("Shutting movie theater down...");  
  
        projector.off();  
        amplifier.off();  
        dvdPlayer.stop();  
        dvdPlayer.eject();  
        dvdPlayer.off();
    }
}
        
class Client{
    public static void main(String[] args) { 
        Projector projector = new SimpleProjector();
        DVDPlayer dvdPlayer = new SimpleDVDPlayer();
        Amplifier amplifier = new StereoAmplifier();
        HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade(projector,dvdPlayer,amplifier);
        homeTheaterFacade.watchMovie("肖申克的救赎");
        homeTheaterFacade.endMovie();
    }
}

In this example, we can see the facade pattern, which is particularly suitable for using multiple components, assembling fixed processes, and reducing the complexity of client calls.

VII. Conclusion

The Facade design pattern is a very practical design pattern that reduces the complexity of the system and improves the usability and flexibility of the system by providing a unified interface for the subsystem. However, when using this pattern, you also need to pay attention to its possible shortcomings and risks.

If this mode is useful to you, please like and collect it.