关于java:你以为委派模式很神秘其实你每天都在用

5次阅读

共计 5454 个字符，预计需要花费 14 分钟才能阅读完成。

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

咱们用代码来模仿老板给员工分配任务的业务场景。
首先创立 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());
    }
}

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

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

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

上面来看委派模式在 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。