委派模式

委派模式：负责任务的调度和任务的分配，将任务的分配和执行分离开来。可以看作是一种特殊情况下的静态代理的全权代理

适用场景：委派对象是不知道如何处理一个任务的，只是把任务交给其他对象来处理

优点：通过任务委派的方式，能够把一个大型的任务细化，然后通过统一管理这些子任务的完成情况实现任务的跟进，能够加快任务执行的效率

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

示例

以员工、领导、老板为例，老板让领导干活，领导不会亲自去做，而是把任务一个一个委派给下面的员工来具体完成

员工统一接口

public interface IEmployee {
    void doing(String task);
}

用两个员工的实现代表两种擅长能力

员工A具体实现

public class EmployeeA implements IEmployee {
    protected String goodAt = "编程";
    public void doing(String task) {
        System.out.println("我是员工A，我擅长" + goodAt + ",现在开始做" +task + "工作");
    }
}

员工B具体实现

public class EmployeeB implements IEmployee {
    protected String goodAt = "平面设计";
    public void doing(String task) {
        System.out.println("我是员工B，我擅长" + goodAt + ",现在开始做" +task + "工作");
    }
}

领导实现，不亲自完成工作，而是去委派给擅长做的员工来完成

public class Leader implements IEmployee {

    private Map<String,IEmployee> employee = new HashMap<String,IEmployee>();

    public Leader(){
        employee.put("爬虫",new EmployeeA());
        employee.put("海报图",new EmployeeB());
    }

    public void doing(String task) {
        if(!employee.containsKey(task)){
            System.out.println("这个任务" +task + "超出我的能力范围");
            return;
        }
        employee.get(task).doing(task);
    }
}

老板角色，传达指令给领导

public class Boss {
    public void command(String task,Leader leader){
        leader.doing(task);
    }
}

客户端调用

public class Test {
    public static void main(String[] args) {
        new Boss().command("海报图",new Leader());
        new Boss().command("爬虫",new Leader());
        new Boss().command("卖手机",new Leader());
    }
}

我是员工B，我擅长平面设计,现在开始做海报图工作 我是员工A，我擅长编程,现在开始做爬虫工作 这个任务卖手机超出我的能力范围

委派模式在源码中的体现

JVM双亲委派模式

一个类加载器在加载类时，先把这个请求委派给自己的父类加载器去执行，如果父类加载器还存在父类加载器，就继续往上委派，直到顶层的启动类加载器。如果父类加载器能够完成类加载的工作，就成功返回，如果父类加载器无法完成加载，那么子加载器才会尝试去自己加载这个类

public abstract class ClassLoader {
 	// The parent class loader for delegation
  // Note: VM hardcoded the offset of this field, thus all new fields must be added *after* it.
  private final ClassLoader parent; 
  
  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;
    }
  }
}

Spring的IoC模块

Spring 中的 DefaultBeanDefinitionDocumentReader 类，在调用 doRegisterBeanDefinitions() 方法时会把一个类型为 BeanDefinitionParserDelegate 的对象 this.delegate 传入到 parseBeanDefinitions() 方法，然后主要的解析工作就通过 delegate 作为主要角色来完成

protected void doRegisterBeanDefinitions(Element root) {
  BeanDefinitionParserDelegate parent = this.delegate;
  this.delegate = this.createDelegate(this.getReaderContext(), root, parent);
  // ...
  this.preProcessXml(root);
  this.parseBeanDefinitions(root, this.delegate);
  this.postProcessXml(root);
  this.delegate = parent;
}

最终走到注册 bean 的部分的时候，针对不同类型的结点进行真正的的注册操作，delegate 对象会对 element 调用 parseBeanDefinitions() ，得到一个 BeanDefinitionHolder 类型的对象，通过这个对象完成真正注册到 Factory 的操作

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
  if (delegate.isDefaultNamespace(root)) {
    NodeList nl = root.getChildNodes();
    for(int i = 0; i < nl.getLength(); ++i) {
      Node node = nl.item(i);
      if (node instanceof Element) {
        Element ele = (Element)node;
        if (delegate.isDefaultNamespace(ele)) {
          this.parseDefaultElement(ele, delegate);
        } else {
          delegate.parseCustomElement(ele);
        }
      }
    }
  } else {
    delegate.parseCustomElement(root);
  }
}

在Spring的源码中，只要以 Delegate 结尾的都是实现了委派模式。如：BeanDefinitionParserDelegate 根据不同类型委派不同的逻辑来解析 BeanDefinition

委派模式和静态代理的区别

• 从设计模式的类型来看：委派模式属性行为型模式；代理模式属性结构型模式
• 从注重点来看：委派模式注重的是任务派遣，注重的是结果；代理模式注重的是代码增强，注重的是过程
• 委派模式是一种特殊的静态代理，属于全权代理，与中间处理无关，直接委托并返回，无需关心实现细节