设计模式-委派模式

委派模式定义

委派模式是允许对象组合实现与继承相同的代码复用，其基本作用是负责任务调度和分配任务，是一种全权的静态代理，与代理模式不同的是委派模式注重结果，而代理模式注重过程。

委派模式结构

委派模式有三个角色：
抽象任务角色Task: 定义一个抽象接口，约定要执行的任务
委派者角色Delegate: 负责在各个具体角色实例之间做出决策，判断调用哪一个具体的实现
具体任务角色Concrete: 真正执行任务的角色

委派模式示例

Spring中的DispatcherServlet也用到了委派模式。生活场景中，老板给项目经理下达任务，项目经理根据项目成员擅长的业务技能分派工作任务，待员工完成任务后，由项目经理把结果汇报给老板，用代码模拟如下：
创建一个IEmployee 接口，

package com.lchtest.pattern.delegate.simple;
public interface IEmployee {
     void doing(String command);
}

两个员工的实例：

package com.lchtest.pattern.delegate.simple;

public class EmployeeA implements IEmployee{
    @Override
    public void doing(String command) {
        System.out.println("我是员工A,我擅长加密,开始执行" +command);
    }
}

package com.lchtest.pattern.delegate.simple;

public class EmployeeB implements IEmployee {
    @Override
    public void doing(String command) {
        System.out.println("我是员工B,我擅长架构,我开始执行" + command);
    }
}

创建项目经理Leader类

package com.lchtest.pattern.delegate.simple;

import java.util.HashMap;
import java.util.Map;

/**
 * 负责任务调度
 */
public class Leader implements IEmployee {
    //leader预先知道每个员工的特长
    private Map<String, IEmployee> register = new HashMap<>();

    public Leader() {
        register.put("加密", new EmployeeA());
        register.put("架构", new EmployeeB());
    }

    public void doing(String command) {
//leader负责调度,把任务分配给员工,让员工去干活
        register.get(command).doing(command);
    }
}

创建Boss类下达命令

package com.lchtest.pattern.delegate.simple;

public class Boss {
    //boss给leader下命令
    public void command(String command,Leader leader){
        //leader接受一个命令去干活
        leader.doing(command);
    }
}

测试：

package com.lchtest.pattern.delegate.simple;

public class DelegateTest {
    public static void main(String[] args) {
        Boss boss = new Boss();
        boss.command("架构", new Leader());
        boss.command("加密", new Leader());
    }
}

委派模式在源码中的应用

ClassLoader 类中有个属性parent,就是ClassLoader自己，它还有一个loadClass方法：

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

上面这段代码，是加载类的判断过程，如果父类的加载器有值，就让父类的加载器去加载类，如果没有，才使用自己的类加载器 ，这样就可以避免类的重复加载，通过parent加载就是一个委派的过程。这就是双亲委派