你以为委派模式很神秘,其实你每天都在用

Tom弹架构
本文节选自《设计模式就该这样学》

1 使用委派模式模拟任务分配场景

我们用代码来模拟老板给员工分配任务的业务场景。
首先创建IEmployee员工接口。


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

创建员工EmployeeA类。


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

创建员工EmployeeB类。


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

创建项目经理Leader类。


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

然后创建Boss类下达命令。


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

通过上面代码,我们生动地还原了老板分配任务的业务场景,这也是委派模式的生动体现。其类图如下图所示。

image.png

2 委派模式在JDK源码中的应用

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


public abstract class ClassLoader {
    ...
    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) {
                }

                if (c == null) {
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    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()也存在类似机制,代码如下。


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

看完代码,相信小伙伴们把委派模式和代理模式的区别弄清楚了吧。

3 委派模式在Spring源码中的应用

下面来看委派模式在Spring中的应用,Spring IoC模块中的DefaultBeanDefinitionDocumentReader类,当调用doRegisterBeanDefinitions()方法时,即在BeanDefinition进行注册的过程中,会设置BeanDefinitionParserDelegate类型的Delegate对象传给this.delegate,并将这个对象作为一个参数传入parseBeanDefinitions(root, this.delegate)。主要的解析工作就是由delegate作为主要角色来完成的,代码如下。


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

上面代码中的parseDefaultElement(ele, delegate)方法,主要功能是针对不同的节点类型,完成Bean的注册操作,而在这个过程中,delegate会调用element的parseBeanDefinitionElement()方法,从而得到一个BeanDefinitionHolder类型的对象,之后通过这个对象完成注册。
再来还原一下Spring MVC的DispatcherServlet是如何实现委派模式的。创建业务类MemberController。


/**
 * Created by Tom.
 */
public class MemberController {

    public void getMemberById(String mid){

    }

}

创建OrderController类。


/**
 * Created by Tom.
 */
public class OrderController {

    public void getOrderById(String mid){

    }

}

创建SystemController类。


/**
 * Created by Tom.
 */
public class SystemController {

    public void logout(){

    }
}

创建DispatcherServlet类。


public class DispatcherServlet extends HttpServlet {

    private Map<String,Method> handlerMapping = new HashMap<String,Method>();

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doDispatch(req,resp);
    }

    private void doDispatch(HttpServletRequest req, HttpServletResponse resp) {
        String url = req.getRequestURI();
        Method method = handlerMapping.get(url);
       //此处省略反射调用方法的代码
           ...
        
    }

    @Override
    public void init() throws ServletException {
        try {
            handlerMapping.put("/web/getMemeberById.json", MemberController.class.getMethod("getMemberById", new Class[]{String.class}));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

配置web.xml文件。


<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:javaee="http://java.sun.com/xml/ns/javaee"
   xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
   version="2.4">
   <display-name>Web Application</display-name>


   <servlet>
      <servlet-name>delegateServlet</servlet-name>
      <servlet-class>com.tom.pattern.delegate.mvc.DispatcherServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>delegateServlet</servlet-name>
      <url-pattern>/*</url-pattern>
   </servlet-mapping>

</web-app>

这样,一个完整的委派模式就实现了。当然,在Spring中运用委派模式的情况还有很多,大家通过命名就可以识别。在Spring源码中,只要以Delegate结尾的都实现了委派模式。例如,BeanDefinitionParserDelegate根据不同的类型委派不同的逻辑来解析BeanDefinition。

关注微信公众号『 Tom弹架构 』回复“设计模式”可获取完整源码。

【推荐】Tom弹架构:收藏本文,相当于收藏一本“设计模式”的书
本文为“Tom弹架构”原创,转载请注明出处。技术在于分享,我分享我快乐!
如果本文对您有帮助,欢迎关注和点赞;如果您有任何建议也可留言评论或私信,您的支持是我坚持创作的动力。关注微信公众号『 Tom弹架构 』可获取更多技术干货!
阅读 532

设计模式就该这样学
设计模式就该这样学

《Spring 5核心原理》、《Netty 4核心原理》、《设计模式就该这样学》作者。

36 声望
25 粉丝
0 条评论

《Spring 5核心原理》、《Netty 4核心原理》、《设计模式就该这样学》作者。

36 声望
25 粉丝
文章目录
宣传栏