你以為委派模式很神秘，其實你每天都在用-有解無憂

本文節選自《設計模式就該這樣學》

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

通過上面代碼，我們生動地還原了老板分配任務的業務場景，這也是委派模式的生動體現，其類圖如下圖所示，

file

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彈架構』可獲取更多技術干貨！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/354412.html

標籤：Java

上一篇：【JAVA】編程（2）---時間管理

下一篇：【JAVA】編程（3）---王狗蛋先生去取錢，發現余額不足！？！？

你以為委派模式很神秘，其實你每天都在用

1 使用委派模式模擬任務分配場景

2 委派模式在JDK原始碼中的應用

3 委派模式在Spring原始碼中的應用

1　使用委派模式模擬任務分配場景

2　委派模式在JDK原始碼中的應用

3　委派模式在Spring原始碼中的應用