委派设计模式

一、委派模式

1、定义

委派模式（Delegate Pattern）又称作委托模式，是一种面相对性的设计模式，允许对象组合实现与继承相同的代码重用，属于行为型设计模式，不属于GoF的23种设计模式。

委派模式的基本作用是负责任务的调用和分配，是一种特殊的静态代理模式，可以理解为全权代理模式，但是代理模式注重过程，而委派模式注重结果。

2、结构

（1）模式的结构

主要角色如下：

• 抽象任务角色（ITask）：定义一个抽象接口，它有若干实现类。
• 委派者角色（Delegate）：负责在各个具体角色实例之间作出决策，判断并调用具体实现的方法。
• 具体任务角色（Concrete）：真正执行任务的角色。

3、优缺点

优点：

• 通过任务委派能够将一个大型任务细化，然后通过统一管理这些子任务的完成情况，来实现任务的跟进，加快任务执行的效率。

缺点：

• 任务委派方式需要根据任务的复杂程度进行不同的改变，在任务比较复杂的情况下，可能需要进行多重任务委派，容易造成紊乱。

4、使用场景

• 需要实现表现层和业务层之间的松耦合。
• 需要编排多个服务之间的调用。
• 需要封装一层服务查找和调用

5、在框架源码中使用

• JVM在加载类时使用的双亲委派机制，在 ClassLoader类中的 loadClass()方法。
• Spring IoC模块中，BeanDefinition进行解析注册的过程中使用的 BeanDefinitionParserDelegate类型的类。
• Spring源码中，以 Delegate为后缀的类基本都实现了委派模式。

二、模式的通用实现

代码如下：

public class DelegatePattern {
	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {
			Delegate delegate = new Delegate();
			delegate.doTask();
			System.out.println("---------");
		}
	}
}

// 抽象任务角色
interface ITask {
	void doTask();
}

// 具体任务角色
class ConcreteTaskA implements ITask {

	@Override
	public void doTask() {
		System.out.println("ConcreteTaskA 执行 任务");
	}
}

class ConcreteTaskB implements ITask {

	@Override
	public void doTask() {
		System.out.println("ConcreteTaskB 执行 任务");
	}
}

// 委派者角色
class Delegate implements ITask {

	@Override
	public void doTask() {
		System.out.println("随机委派执行开始");
		ITask task = null;
		if(new Random().nextBoolean()){
			task = new ConcreteTaskA();
			task.doTask();
		}else{
			task = new ConcreteTaskB();
			task.doTask();
		}
		System.out.println("随机委派执行结束");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

三、模式的应用实例

以项目经理给员工分配任务为例。

（1）员工

public interface Employee {

    String doTask(String task);
}
1
2
3
4

public class JavaEmployee implements Employee{

    private String name = "Java后端";

    @Override
    public String doTask(String task) {
        return "我" + name + "，开始努力工作，完成【" + task + "】任务";
    }
}

public class JsEmployee implements Employee{

    private String name = "Js前端";

    @Override
    public String doTask(String task) {
        return "我" + name + "，开始努力工作，完成【" + task + "】任务";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（2）项目经理 - 委派者

public class Leader {
    //private Map employeeMap;
    //
    //public Leader() {
    //    this.employeeMap = new ConcurrentHashMap<>();
    //    employeeMap.put(JavaEmployee.class.getSimpleName(), new JsEmployee());
    //    employeeMap.put(JsEmployee.class.getSimpleName(), new JsEmployee());
    //}

    public void doSomeThing(Employee employee, String taskName) {
        System.out.println("委派执行开始");

        if(employee == null){
            System.out.println("请执行委派人员");
            return;
        }
        String result = "";
        employee.getClass().getName();

        if(employee instanceof JavaEmployee){
            //employee = employeeMap.get(JavaEmployee.class.getSimpleName());
            result = employee.doTask(taskName);
        }else if(employee instanceof JsEmployee){
            //employee = employeeMap.get(JsEmployee.class.getSimpleName());
            result = employee.doTask(taskName);
        }else {
            System.out.println("部门不存在该委派人员");
            return;
        }

        System.out.println(result);
        System.out.println("委派执行开始");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

（3）测试

	public static void main(String[] args) {
		Leader leader = new Leader();

		leader.doSomeThing(new JavaEmployee(), "赵云打野");
		System.out.println("-----------");
		leader.doSomeThing(new JsEmployee(), "瑶妹辅助");

	}
1
2
3
4
5
6
7
8

– 求知若饥，虚心若愚。