java基础-委派模式

概述

委派模式（Delegate Pattern）又叫委托模式。它的基本作用就是负责任务的调度和任务分配，将任务的分配和执行分离开来。可以看做是一种特殊情况下的静态代理的全权代理。
不属于GOF 23种设计模式之一。
属于行为型模式。

---

场景

1、委派对象本身不知道如何处理一个任务（或一个请求)，把请求交给其它对象来处理。
2、实现程序的解耦。
 

---

优点

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

---

缺点

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

---

栗子1#任务分发

public interface Task {
    void doTask();
}
public class ConcreteA implements Task {
    public void doTask() {
        System.out.println("执行 , 由A实现");
    }
}
public class ConcreteB implements Task {
    public void doTask() {
        System.out.println("执行 , 由B实现");
    }
}
public class Delegate implements Task{
    public void doTask() {
        System.out.println("代理执行开始....");

        Task task = null;
        if (new Random().nextBoolean()){
        task = new ConcreteA();
        task.doTask();
        }else{
            task = new ConcreteB();
            task.doTask();
        }

        System.out.println("代理执行完毕....");
    }
}
public class Test {
    public static void main(String[] args) {
        new Delegate().doTask();
    }
}

图：

栗子2 老板让leader去吩咐员工做事

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

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

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);
    }
}

图1-2：

---

源码中的使用案例#ClassLoader

public abstract class ClassLoader {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    private final ClassLoader parent;

}

 protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
             
            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
                }

源码中的使用案例#Method

   
    private volatile MethodAccessor methodAccessor;
 public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        // 调用的是这个 
        MethodAccessor ma = methodAccessor;             // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }
// 可以知道调用的是MethodAccessor，Method啥是都没做，

源码中的使用案例#Spring解析XML

	@Nullable
	private BeanDefinitionParserDelegate delegate;

// 根据xml类型来生成不同的委派
protected BeanDefinitionParserDelegate createDelegate(
			XmlReaderContext readerContext, Element root, @Nullable BeanDefinitionParserDelegate parentDelegate) {

		BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
		delegate.initDefaults(root, parentDelegate);
		return delegate;
	}

源码中的使用案例#Dsipatcher#doDispatch

扫描所有的controller，然后加载到一个map，然后分化执行

  protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {

            try {
                ModelAndView mv = null;
                Object dispatchException = null;

           try {
                    processedRequest = this.checkMultipart(request);
                    multipartRequestParsed = processedRequest != request;
                    // 获取映射handler url以及对应当执行参数
                    mappedHandler = this.getHandler(processedRequest);
                    if (mappedHandler == null) {
                        this.noHandlerFound(processedRequest, response);
                        return;
             }

 
     mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
}

委派和代理的区别

1、委派模式是行为型模式,代理模式是结构型模式
2、委派模式注重的是任务派遣,注重结果;
      代理模式注重的是代码增强，注重过程。
3、委派模式是一种特殊的静态代理,相当于全权代理。

---

1