• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

委派模式

开发技术 开发技术 2周前 (04-30) 7次浏览

一、定义

委派模式又叫委托模式,是一种面向对象的设计模式,允许对象组合实现与继承相同的代码重用。它的基本作用就是负责任务的调用和分配任务,是一种特殊的静态代理,可以理解为全权代理,但是代理模式注重过程,而委派模式注重结果。委派模式属于行为型模式,不属于GOF23种设计模式中。

委派模式有3个参与角色

  1. 抽象任务角色(ITask):定义一个抽象接口,它有若干实现类。
  2. 委派者角色(Delegate):负责在各个具体角色实例之间做出决策,判断并调用具体实现的方法。
  3. 具体任务角色(Concrete):真正执行任务的角色。

二、委派模式的应用场景

 委派模式在业务场景中的例子很多:需要实现表现层和业务层之间的松耦合;需要编排多个服务之间的调用;需要封装一层服务查找和调用。前面说的都是业务场景,下面来说下生活场景中的例子,例如:大老板跟项目经理下了个任务,项目经理不可能自己亲自去做所有事吧,他肯定会把收到的任务进行分解,然后分给下面的员工下发任务,等员工把工作完成后,再把结果汇总向老板汇报

//抽象任务角色
public interface ITask {
    void doTask(String mission) throws IllegalAccessException, InstantiationException;
}
//具体任务角色 ConcreteA
public class ConcreteA  implements ITask {
    @Override
    public void doTask(String mission) {
        System.out.println("我是员工A,我的工作是UI");
    }
}
//具体任务角色 ConcreteB
public class ConcreteB implements ITask {
    @Override
    public void doTask(String mission) {
        System.out.println("我是员工B,我的工作是开发");
    }
}
//委派者角色 Delegate 经理
public class Delegate implements ITask{
    private Map<String,Class> map=new HashMap<>();

    public Delegate(){
        map.put("UI",ConcreteA.class);
        map.put("开发",ConcreteB.class);
    }
    @Override
    public void doTask(String mission) throws IllegalAccessException, InstantiationException {
        if (!map.containsKey(mission)){
            System.out.println("没有这样的业务员");
            return;
        }
       ITask iTask= (ITask) map.get(mission).newInstance();
        iTask.doTask(mission);

    }
}
//老板
public class Robam {
    public void command(String mission,ITask iTask) throws InstantiationException, IllegalAccessException {
        iTask.doTask(mission);
    }
}
public class Test {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        new Robam().command("UI",new Delegate());
    }
}

三、委派模式在源码中的体现

JDK中有一个典型的委派,JVM在加载类是用的双亲委派模型,一个类加载器在加载类时,先把这个请求委派给自己的父类加载器去执行,如果父类加载器还存在父类加载器,就继续向上委派,直到顶层的启动类加载器。如果父类加载器能够完成类加载,就成功返回,如果父类加载器无法完成加载,那么子加载器才会尝试自己去加载;从定义中可以看到双亲加载模型一个类加载器加载时,首先不是自己加载,而是委派给父加载器,下面看loadClass()方法的源码,此方法在ClassLoader中,在这个类里就定义了一个双亲,用于下面的类加载

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

同样在Method类里常用的代理执行方法invoke()也存在类似的机制

@CallerSensitive
    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();
        }
        //MethodAccessor没有做任何事情只是拿到了ma的返回结果而已
        return ma.invoke(obj, args);
    }

IOC中对象实例化委派模式

 在调用doRegisterBeanDefinitions()方法时即BeanDefinition进行注册的过程中,会设置BeanDefinitionParserDelegate类型的Delegate对象传给this.delegate,并将这个对象作为一个参数传给:parseBeanDefinitions(root, this.delegate)中,然后主要的解析的工作就是通过delegate作为主要角色来完成的,可以看到下方代码:

 

/**
 * Parse the elements at the root level in the document:
 * "import", "alias", "bean".
 * @param root the DOM root element of the document
 */
 
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)) {
 
               parseDefaultElement(ele, delegate);
 
            }
 
            else {
 
               //注解定义的Context的nameSpace进入到这个分支中
 
               delegate.parseCustomElement(ele);
 
            }
 
         }
 
      }
 
   }
 
   else {
 
      delegate.parseCustomElement(root);
 
   }
 
}
 

其中最终能够走到bean注册部分的是,会进入到parseDefaultElement(ele, delegate)中,然后针对不同的节点类型,针对bean的节点进行真正的注册操作,而在这个过程中,delegate会对element进行parseBeanDefinitionElement,得到了一个BeanDefinitionHolder类型的对象,之后通过这个对象完成真正的注册到Factory的操作

SpringMVC中,类DispatcherServlet

DispatcherServlet 虽然没带delegate,但也是委派模式的一种实现。

前端请求都统一走到DispatcherServlet 的doService()方法中,然后在doService()方法中调用doDispatch()方法,在doDispatch()方法中,会获取业务处理的handler,执行handle()方法处理请求。

doDispatch()方法核心源码截图
 委派模式

 

 看过源码的人从上面逻辑可以知道用于HTTP请求处理程序/控制器的中央调度程序,针对通过WEB UI输入的url请求,委派给DispatcherServlet处理,从委派者的角度来看,关注结果即可

 四、总结

优点:

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

缺点:

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

委派模式与代理模式异同

代理模式是由代理来帮你完成一些工作,而这里的委派模式,是由委派对象来帮你完成一些工作,字面上来看,好像并没有什么差别。首先,我们代理可以增强我们的代理目标类,而委派模式,像上面的例子,老板要做一件事只用跟经理说下就行,接下来的所有的事情,都交给经理去处理即可了,自己完全不必实际去参与到行动中。

 

git源码:https://github.com/ljx958720/design_patterns.git


程序员灯塔
转载请注明原文链接:委派模式
喜欢 (0)