1 General
Definition: also known as Facade mode, it is a mode that makes multiple complex subsystems more accessible by providing a consistent interface. This mode has a unified interface to the outside, and the external application does not need to care about the specific details of the internal subsystem, which will greatly reduce the complexity of the application and improve the maintainability of the program. The Facade pattern is a typical application of the "Demeter's law"
2 Structure
The Facade mode contains the following main roles:
- Facade role: provides a common interface for multiple subsystems.
- Sub System role: it realizes some functions of the system, and customers can access it through the appearance role.
3 cases
Take Xiaomi smart home as an example to uniformly control household appliances Lamp, TV, air conditioner, etc
Lamps
public class Light { public void on() { System.out.println("Turn on the light...."); } public void off() { System.out.println("Turn off the light...."); } }
Television
public class TV { public void on() { System.out.println("Turn on the TV...."); } public void off() { System.out.println("Turn off TV...."); } }
Air conditioning
public class AirCondition { public void on() { System.out.println("Air conditioning on...."); } public void off() { System.out.println("Air conditioning turned off...."); } }
Xiaomi smart speaker
public class SmartAppliancesFacade { private Light light; private TV tv; private AirCondition airCondition; public SmartAppliancesFacade() { light = new Light(); tv = new TV(); airCondition = new AirCondition(); } public void say(String message) { if(message.contains("open")) { on(); } else if(message.contains("close")) { off(); } else { System.out.println("I still don't understand what you said!!!"); } } // One button switch private void on() { light.on(); tv.on(); airCondition.on(); } // One button switch off private void off() { light.off(); tv.off(); airCondition.off(); } }
Test class
public class Client { public static void main(String[] args) { // Create appearance objects SmartAppliancesFacade facade = new SmartAppliancesFacade(); // Clients interact directly with appearance objects facade.say("Turn on the appliance"); facade.say("Turn off appliances"); } } /* Turn on the light Turn on the TV Turn on the air conditioner Turn off the lights Turn off TV Turn off the air conditioner */
Benefits:
- The coupling between the subsystem and the client is reduced, so that the change of the subsystem will not affect the client class that calls it.
- It shields subsystem components from customers, reduces the number of objects handled by customers, and makes the subsystem easier to use.
Disadvantages:
- It does not conform to the opening and closing principle, and it is troublesome to modify
4 usage scenarios
- When building a hierarchical system, using appearance patterns to define the entry points of each layer in the subsystem can simplify the dependencies between subsystems.
- When a complex system has many subsystems, the appearance pattern can design a simple interface for the system to be accessed by the outside world.
- When there is a great connection between the client and multiple subsystems, the appearance pattern can be introduced to separate them, so as to improve the independence and portability of the subsystem.
5 source code application
When tomcat is used as a web container, the request information will be encapsulated into a ServletRequest pair. ServletRequest is an interface, and it also has a sub interface HttpServletRequest. The request object is a sub implementation class object of an HttpServletRequest object, that is, an object of the RequestFacade class
Instructions for use
The RequestFacade class implements ServletRequest, defines the private member variable Request, and the implementation of the method calls the implementation of the Request. Then, turn the RequestFacade into a ServletRequest and pass it to the service method of the servlet. In this way, even if the RequestFacade is turned down in the servlet, the methods in the private member variable object cannot be accessed. It not only uses Request, but also prevents unreasonable access to the methods.