Java implements Facade pattern
Facade pattern is a structural design mode, which encapsulates a complex subsystem combination by providing a unified interface, so that the client can simplify the interaction with the subsystem through this interface.
Applicable scenarios:
-When there is a complex subsystem and a simplified interface needs to be provided to the outside, Facade pattern can be used.
-When the subsystem needs to be completely decoupled from the client, Facade pattern can be used.
-Facade pattern can be used when following the principle of least knowledge (also known as Dimit's Law).
Benefits:
-Simplify the interaction between clients and complex subsystems, and reduce the complexity of client code.
-The complexity of hidden subsystems makes it easier for clients to use them.
-Reduced the coupling between subsystems and clients, minimizing the impact of subsystem changes on clients.
The following is a sample code of a simple Java Facade pattern:
//Subsystem A
class SubsystemA {
public void operationA() {
System.out.println("SubsystemA operation");
}
}
//Subsystem B
class SubsystemB {
public void operationB() {
System.out.println("SubsystemB operation");
}
}
//Subsystem C
class SubsystemC {
public void operationC() {
System.out.println("SubsystemC operation");
}
}
//Appearance class
class Facade {
private SubsystemA subsystemA;
private SubsystemB subsystemB;
private SubsystemC subsystemC;
public Facade() {
subsystemA = new SubsystemA();
subsystemB = new SubsystemB();
subsystemC = new SubsystemC();
}
public void operationOne() {
subsystemA.operationA();
subsystemB.operationB();
}
public void operationTwo() {
subsystemB.operationB();
subsystemC.operationC();
}
}
//Client
public class Client {
public static void main(String[] args) {
Facade facade = new Facade();
facade.operationOne();
facade.operationTwo();
}
}
In the above example code, subsystem A, subsystem B, and subsystem C each provide different operations. The facade class encapsulates these operations and provides two simplified operations, operationOne and operationTwo, externally. In this way, the client only needs to interact with the subsystem through Facade without understanding the specific implementation details of the subsystem, thus simplifying the use of the client.
