门面模式 Facade
1、什么是门面模式
门面模式(Facade Pattern)是一种结构型设计模式,旨在为系统提供一个统一的接口,以便于访问子系统中的一群接口。它通过定义一个高层接口,简化了客户端与子系统之间的交互,从而降低了系统的复杂性。
2、为什么使用门面模式
- 简化接口:门面模式通过定义一个高层接口,简化了客户端与子系统之间的交互,使得客户端无需直接与子系统的复杂接口打交道。
- 解耦客户端和子系统:通过引入门面,客户端与子系统的依赖关系得到解耦,客户端只需与门面进行交互,而不需要关心子系统的具体实现。
- 提高可维护性:门面模式将子系统的实现细节封装起来,有助于提高系统的可维护性,降低了系统的复杂性。
3、如何实现门面模式
设计实现一个简单的计算启动过程
// 子系统 - CPU
class CPU {public void start() {System.out.println("CPU is starting...");}
}// 子系统 - Memory
class Memory {public void load() {System.out.println("Memory is loading...");}
}// 子系统 - HardDrive
class HardDrive {public void read() {System.out.println("HardDrive is reading...");}
}// 门面类 - ComputerFacade
class ComputerFacade {private CPU cpu;private Memory memory;private HardDrive hardDrive;public ComputerFacade() {this.cpu = new CPU();this.memory = new Memory();this.hardDrive = new HardDrive();}public void startComputer() {cpu.start();memory.load();hardDrive.read();System.out.println("Computer is started and ready to use.");}
}// 客户端代码
public class Client {public static void main(String[] args) {ComputerFacade computerFacade = new ComputerFacade();computerFacade.startComputer();}
}
4、是否存在缺陷和不足
- 不符合开闭原则:当系统中的子系统发生变化时,可能需要修改门面类,不符合开闭原则。
- 可能导致过多门面类:随着系统的不断扩展,可能会出现多个门面类,导致系统变得复杂。
5、如何缓解缺陷和不足
- 使用配置文件:将子系统的配置信息放置在配置文件中,通过读取配置文件的方式动态创建门面类,提高系统的灵活性。
- 使用抽象工厂模式:可以结合抽象工厂模式,将门面的创建过程交给工厂类,从而降低客户端与门面的耦合度。
// 抽象产品 - CPU
interface CPU {void start();
}// 具体产品A - ConcreteCPUA
class ConcreteCPUA implements CPU {@Overridepublic void start() {System.out.println("ConcreteCPUA is starting...");}
}// 具体产品B - ConcreteCPUB
class ConcreteCPUB implements CPU {@Overridepublic void start() {System.out.println("ConcreteCPUB is starting...");}
}// 抽象产品 - Memory
interface Memory {void load();
}// 具体产品A - ConcreteMemoryA
class ConcreteMemoryA implements Memory {@Overridepublic void load() {System.out.println("ConcreteMemoryA is loading...");}
}// 具体产品B - ConcreteMemoryB
class ConcreteMemoryB implements Memory {@Overridepublic void load() {System.out.println("ConcreteMemoryB is loading...");}
}// 抽象产品 - HardDrive
interface HardDrive {void read();
}// 具体产品A - ConcreteHardDriveA
class ConcreteHardDriveA implements HardDrive {@Overridepublic void read() {System.out.println("ConcreteHardDriveA is reading...");}
}// 具体产品B - ConcreteHardDriveB
class ConcreteHardDriveB implements HardDrive {@Overridepublic void read() {System.out.println("ConcreteHardDriveB is reading...");}
}// 抽象工厂接口
interface ComputerFactory {CPU createCPU();Memory createMemory();HardDrive createHardDrive();
}// 具体工厂A
class ConcreteFactoryA implements ComputerFactory {@Overridepublic CPU createCPU() {return new ConcreteCPUA();}@Overridepublic Memory createMemory() {return new ConcreteMemoryA();}@Overridepublic HardDrive createHardDrive() {return new ConcreteHardDriveA();}
}// 具体工厂B
class ConcreteFactoryB implements ComputerFactory {@Overridepublic CPU createCPU() {return new ConcreteCPUB();}@Overridepublic Memory createMemory() {return new ConcreteMemoryB();}@Overridepublic HardDrive createHardDrive() {return new ConcreteHardDriveB();}
}// 门面类
class ComputerFacade {private CPU cpu;private Memory memory;private HardDrive hardDrive;public ComputerFacade(ComputerFactory factory) {this.cpu = factory.createCPU();this.memory = factory.createMemory();this.hardDrive = factory.createHardDrive();}public void startComputer() {cpu.start();memory.load();hardDrive.read();System.out.println("Computer is started and ready to use.");}
}// 客户端代码
public class Client {public static void main(String[] args) {// 使用工厂A创建电脑ComputerFactory factoryA = new ConcreteFactoryA();ComputerFacade computerFacadeA = new ComputerFacade(factoryA);computerFacadeA.startComputer();// 使用工厂B创建电脑ComputerFactory factoryB = new ConcreteFactoryB();ComputerFacade computerFacadeB = new ComputerFacade(factoryB);computerFacadeB.startComputer();}
}
上面这个例子中,抽象工厂模式用于创建不同系列的电脑产品,而门面类的创建过程交给工厂类,客户端代码通过选择不同的工厂来创建不同系列的电脑,无需关心具体产品的创建过程,有助于提高系统的灵活性和可维护性
组合模式 Composite
1、什么是组合模式
组合模式通过将对象组织成树形结构来表示整体-部分层次结构,使得客户端可以统一对待单个对象和对象的组合。它主要包含三个角色:叶子节点(Leaf)、组合节点(Composite)、客户端(Client)。
2、为什么使用组合模式
- 统一接口:组合模式使得客户端可以统一对待单个对象和对象的组合,因为它们共享相同的接口。
- 灵活性:客户端无需关心对象是叶子节点还是组合节点,可以在不同层次构建复杂的对象结构。
- 简化客户端代码:客户端无需判断操作的是单个对象还是对象组合,简化了客户端代码。
3、如何使用组合模式
设计实现一个文件系统
import java.util.ArrayList;
import java.util.List;// 抽象组件 - 文件和目录的共同接口
interface FileSystemComponent {void display();
}// 叶子节点 - 文件
class FileLeaf implements FileSystemComponent {private String name;public FileLeaf(String name) {this.name = name;}@Overridepublic void display() {System.out.println("File: " + name);}
}// 组合节点 - 目录
class DirectoryComposite implements FileSystemComponent {private String name;private List<FileSystemComponent> components;public DirectoryComposite(String name) {this.name = name;this.components = new ArrayList<>();}public void addComponent(FileSystemComponent component) {components.add(component);}public void removeComponent(FileSystemComponent component) {components.remove(component);}@Overridepublic void display() {System.out.println("Directory: " + name);for (FileSystemComponent component : components) {component.display();}}
}// 客户端代码
public class Client {public static void main(String[] args) {// 构建文件系统结构FileSystemComponent file1 = new FileLeaf("file1.txt");FileSystemComponent file2 = new FileLeaf("file2.txt");DirectoryComposite dir1 = new DirectoryComposite("Folder 1");dir1.addComponent(file1);dir1.addComponent(file2);FileSystemComponent file3 = new FileLeaf("file3.txt");DirectoryComposite dir2 = new DirectoryComposite("Folder 2");dir2.addComponent(file3);dir2.addComponent(dir1);// 显示文件系统结构dir2.display();}
}
4、是否存在缺陷和不足
- 限制类型一致性:组合模式要求所有组件都实现相同的接口,这可能限制了组件的类型一致性。
- 不支持单个对象的特殊处理:组合模式统一对待单个对象和组合对象,因此可能无法支持对单个对象的特殊处理。
5、如何缓解缺陷和不足
- 使用抽象构件类:引入一个抽象构建类,包含所有子类共有的方法,从而提高组件的类型一致性。
- 在叶子节点实现特殊处理:在叶子节点类中实现特殊处理逻辑,以满足对单个对象的特殊需求。