今天要说的,是一种不常见的设计模式,组合模式,这个组合模式,和组合关系没有任何的关系,之所以不常见,是因为组合模式要求比较高,要求数据必须能够形成树型结构,才能够发挥作用
在设计模式一书中,组合模式是这样定义的,将一组对象组织成树型结构,以表示部分-整体的层次关系,组合让客户端可以统一的处理 单一对象和组合对象
我们可以举一个文件目录的例子,来解释组合模式,现在有一个这样的需求
动态地添加,删除某个目录下的子目录或者文件
统计指定目录下的文件个数
统计指定目录下的文件总大小
那么我们可以设计一个类
| public class FileSystemNode {
private String path; private boolean isFile; private List<FileSystemNode> subNodes = new ArrayList<>(); public FileSystemNode(String path, boolean isFile) { this.path = path; this.isFile = isFile; } public int countNumOfFiles() { // TODO:… } public long countSizeOfFiles() { // TODO:… } public String getPath() { return path; } public void addSubNode(FileSystemNode fileOrDir) { subNodes.add(fileOrDir); } public void removeSubNode(FileSystemNode fileOrDir) { int size = subNodes.size(); int i = 0; for (; i < size; ++i) { if (subNodes.get(i).getPath().equalsIgnoreCase(fileOrDir.getPath())) { break; } } if (i < size) { subNodes.remove(i); } } } |
上面基本实现了这个需求,而是用起来,只需要创建后递归删除即可
上面虽然实现了,但是并不合适于大型的项目,因为文件和文件夹是有区别的
所以我们应该讲这个类拆分为文件和文件夹两种类型 File Directory两个雷
按照这种思路,我们对代码进行重新划分,设计出一个接口FileSystemNode()
| public abstract class FileSystemNode {
protected String path; public FileSystemNode(String path) { this.path = path; } public abstract int countNumOfFiles(); public abstract long countSizeOfFiles(); public String getPath() { return path; } } public class File extends FileSystemNode { public File(String path) { super(path); } @Override public int countNumOfFiles() { return 1; } @Override public long countSizeOfFiles() { java.io.File file = new java.io.File(path); if (!file.exists()) return 0; return file.length(); } } public class Directory extends FileSystemNode { private List<FileSystemNode> subNodes = new ArrayList<>(); public Directory(String path) { super(path); } @Override public int countNumOfFiles() { int numOfFiles = 0; for (FileSystemNode fileOrDir : subNodes) { numOfFiles += fileOrDir.countNumOfFiles(); } return numOfFiles; } @Override public long countSizeOfFiles() { long sizeofFiles = 0; for (FileSystemNode fileOrDir : subNodes) { sizeofFiles += fileOrDir.countSizeOfFiles(); } return sizeofFiles; } public void addSubNode(FileSystemNode fileOrDir) { subNodes.add(fileOrDir); } public void removeSubNode(FileSystemNode fileOrDir) { int size = subNodes.size(); int i = 0; for (; i < size; ++i) { if (subNodes.get(i).getPath().equalsIgnoreCase(fileOrDir.getPath())) { break; } } if (i < size) { subNodes.remove(i); } } } |
这样,在我们的使用中,不用关心是文件还是文件夹,直接使用即可
使用代码如下
| public class Demo {
public static void main(String[] args) { /** * / * /wz/ * /wz/a.txt * /wz/b.txt * /wz/movies/ * /wz/movies/c.avi * /xzg/ * /xzg/docs/ * /xzg/docs/d.txt */ Directory fileSystemTree = new Directory(“/”); Directory node_wz = new Directory(“/wz/”); Directory node_xzg = new Directory(“/xzg/”); fileSystemTree.addSubNode(node_wz); fileSystemTree.addSubNode(node_xzg); File node_wz_a = new File(“/wz/a.txt”); File node_wz_b = new File(“/wz/b.txt”); Directory node_wz_movies = new Directory(“/wz/movies/”); node_wz.addSubNode(node_wz_a); node_wz.addSubNode(node_wz_b); node_wz.addSubNode(node_wz_movies); File node_wz_movies_c = new File(“/wz/movies/c.avi”); node_wz_movies.addSubNode(node_wz_movies_c); Directory node_xzg_docs = new Directory(“/xzg/docs/”); node_xzg.addSubNode(node_xzg_docs); File node_xzg_docs_d = new File(“/xzg/docs/d.txt”); node_xzg_docs.addSubNode(node_xzg_docs_d); System.out.println(“/ files num:” + fileSystemTree.countNumOfFiles()); System.out.println(“/wz/ files num:” + node_wz.countNumOfFiles()); } } |
接下来,再来一个实例场景
比如一个OA系统,公司组织结构包括了部门和员工两种数据类型,那么我们可以创建一个如下的两个表
那么在实际上,部门中可以包含子部门和员工,我们亦可以抽取一个父类,让部门表和员工表对应的数据结构继承这个父类,从而处理起来更加的方便
| public abstract class HumanResource {
protected long id; protected double salary; public HumanResource(long id) { this.id = id; } public long getId() { return id; } public abstract double calculateSalary(); } public class Employee extends HumanResource { public Employee(long id, double salary) { super(id); this.salary = salary; } @Override public double calculateSalary() { return salary; } } public class Department extends HumanResource { private List<HumanResource> subNodes = new ArrayList<>(); public Department(long id) { super(id); } @Override public double calculateSalary() { double totalSalary = 0; for (HumanResource hr : subNodes) { totalSalary += hr.calculateSalary(); } this.salary = totalSalary; return totalSalary; } public void addSubNode(HumanResource hr) { subNodes.add(hr); } } // 构建组织架构的代码 public class Demo { private static final long ORGANIZATION_ROOT_ID = 1001; private DepartmentRepo departmentRepo; // 依赖注入 private EmployeeRepo employeeRepo; // 依赖注入 public void buildOrganization() { Department rootDepartment = new Department(ORGANIZATION_ROOT_ID); buildOrganization(rootDepartment); } private void buildOrganization(Department department) { List<Long> subDepartmentIds = departmentRepo.getSubDepartmentIds(department.getId()); for (Long subDepartmentId : subDepartmentIds) { Department subDepartment = new Department(subDepartmentId); department.addSubNode(subDepartment); buildOrganization(subDepartment); } List<Long> employeeIds = employeeRepo.getDepartmentEmployeeIds(department.getId()); for (Long employeeId : employeeIds) { double salary = employeeRepo.getEmployeeSalary(employeeId); department.addSubNode(new Employee(employeeId, salary)); } } } |
那么,这个处理逻辑非常的统一了,而且使用起来并不困难
本章其实很简单
组合模式的设计思路,不如说是业务场景下的一种数据结构和算法的抽象,将多个不同的类,抽象化出来,形成一个树型的数据结构,然后利用递归遍历的手段来实现
但正因为需要抽象成一个树型的结构,所以并不常用,比较局限