本文节选自《设计模式就该这样学》
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()); }}
复制代码
通过上面代码，我们生动地还原了老板分配任务的业务场景，这也是委派模式的生动体现。其类图如下图所示。
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 弹架构 』可获取更多技术干货！
评论