本文節選自《設計模式就該這樣學》
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彈架構 』可獲取更多技術干貨！