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

Tom彈架構發表於2021-11-09
模式

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

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

相關文章