说明

委托模式不属于23种设计模式中，但是它在Spring框架中使用的很频繁，Spring的作用在Java的开发是非常大，所以需要学习一下委托模式。委托模式是指两个对象都有相同的方法与功能，比如A、B两个对象都有相同的方法，但是有调用A的method方法，A不会自己来处理而是直接调用了B的同名方法，由两个对象参与同一个请求，接受请求的对象将委托给另一个对象来处理。

委托模式

在一般的公司中，都会分为老板、项目经理、开发人员结构，老板负责制定决策，分配给项目经理后，他不会自己来完成，而是把需要的功能进行分解，交给擅长的开发人员进行实现。虽然项目经理也可以完成，但是是他把这些事情委托给了多个开发人员来做，加快了完成任务的速度。就以这个需求来说，使用委托模式来进行实现:

定义抽象的人类接口：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package cn.imcompany.delegate;

/**
 * Created by tomyli on 2018/6/27.
 * Github: https://github.com/peng051410
 */
public interface Member {

    void showName();

    void showSkill();

    void doWork();
}

上面代码中定义了抽象的人类接口，显示这个人的名字，拥有的技能，工作的状态情况，接下来实现需求中的每个人。

定义老板(BOSS):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package cn.imcompany.delegate;

/**
 * Created by tomyli on 2018/6/27.
 * Github: https://github.com/peng051410
 */
public class Boss implements Member {

    @Override
    public void showName() {
        System.out.println("i am boss");
    }

    @Override
    public void showSkill() {
        System.out.println("send commend");
    }

    @Override
    public void doWork() {
    }
}

定义项目经理和员工:

 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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

package cn.imcompany.delegate;

/**
 * Created by tomyli on 2018/6/27.
 * Github: https://github.com/peng051410
 */
public class Leader implements Member {

    private Member developerA;
    private Member developerB;

    public void setDeveloperA(Member developerA) {
        this.developerA = developerA;
    }

    public void setDeveloperB(Member developerB) {
        this.developerB = developerB;
    }

    @Override
    public void showName() {
        System.out.println("i am leader");
    }

    @Override
    public void showSkill() {

        showName();
        System.out.println("i want to select member to doWork");
    }

    public void doWork(){
        showSkill();
        developerA.doWork();
        developerB.doWork();
    }
}

public class DeveloperA implements Member {

    @Override
    public void showName() {
        System.out.println("i am developer a");
    }

    @Override
    public void showSkill() {
        showName();
        System.out.println("i can do login function");
    }

    public void doWork() {
        showSkill();
        System.out.println("start work login");
    }
}

public class DeveloperB implements Member {

    @Override
    public void showName() {
        System.out.println("i am developer b");
    }

    @Override
    public void showSkill() {
        showName();
        System.out.println("i can do pay function");
    }

    public void doWork() {
        showSkill();
        System.out.println("start do pay");
    }
}

在上面代码中，定义一个项目经理与两个开发，在项目经理中维护(管理)着对两个开发的引用。这样在项目经理的doWork中其实是调用开发者A与开发者B的doWork来都完成工作。接下来测试一下：

 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

package cn.imcompany.delegate;

/**
 * Created by tomyli on 2018/6/27.
 * Github: https://github.com/peng051410
 */
public class WorkTest {

    public static void main(String[] args) {

        Boss boss = new Boss();
        boss.showName();
        boss.showSkill();

        Leader leader = new Leader();
        Member memberA = new DeveloperA();
        Member memberB = new DeveloperB();

        leader.setDeveloperA(memberA);
        leader.setDeveloperB(memberB);

        leader.doWork();

    }
}

BOSS下发了一个工作，由项目经理选择要真正来工作的人，最后调用了项目经理的doWork方法来实现需求，其实是DeveloperA与DeveloperB在真正的工作，对于BOSS而言，他不在乎谁在工作，他只要结果，结果导向嘛。。。苦了我们这帮程序员。

整体的类图结构:

总结

  1. 委托模式定义了实现功能的窗口，对于具体的实现由谁实现对于调用者是无感知的，对外提供方换了内部的实现对于调用方无影响。最大限度的实现了解耦
  2. 委托方的功能简单通用，可以在绝大情况下通用，在框架中使用非常适合，可以实现分层解耦
  3. 委托模式使用我们可以使用组合来代替继承