设计模式之委派模式（java实现）

清疚 2022-04-11 08:44 196阅读 0赞

委派模式（delegate）：并不属于23种设计模式，但是面向对象常用的一种设计模式，而且在SpringMVC源码中有大量使用。这种模式原理就是类 B和类 A 是两个互相没有任何关系的类，B 具有和 A 一模一样的方法和属性;并且调用 B 中的方法，属性就是调用 A 中同名的方法和属性。B 好像就是一个受 A 授权委托的中介。第三方的代码不需要知道 A 的 存在，也不需要和 A 发生直接的联系，通过 B 就可以直接使用 A 的功能，这样既能够使用到 A 的各种功能，又能够很好的将 A 保护起来了，一举两得。也是一种行为型的设计模式。

举一个生活化的例子，例如公司中三个层级员工，执行员工staff，项目经理manager，老板boss，老板将相对应的任务和目标和项目经理沟通，他并不关心执行员工staff执行的情况，只需要重manager这里了解项目进展和结果，项目经理manager将具体项目拆解或者分配给相对应的员工去执行，这种情况就类似一种委派模式。

下面就按照上述这种方式简单的用代码来实现举例一下：

首先是类图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70][]

员工类StuffA,StuffB实现接口Stuff，项目经理manager，将具体任务进行分配执行，Boss是直接调用manger下达命令

具体实现：

Stuff接口：

package Delegate.company;
    
    public interface Stuff {
        public void doing(String command);
    }

StuffA:

package Delegate.company;
    
    public class StuffA implements Stuff {
        @Override
        public void doing(String command) {
            System.out.println("我是员工A，我现在开始干" + command + "工作");
    
        }
    }

StuffB:

package Delegate.company;
    
    public class StuffB implements Stuff {
        @Override
        public void doing(String command) {
            System.out.println("我是员工B，我现在开始干" + command + "工作");
    
        }
    }

Manager:

package Delegate.company;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class Manager  {
        private Map<String,Stuff> targets = new HashMap<String,Stuff>();
    
        public Manager() {
            targets.put("加密",new StuffA());
            targets.put("登录",new StuffB());
        }
    
        public void doing(String command){
            targets.get(command).doing(command);
        }
    }

Boss调用：

package Delegate.company;
    
    public class Boss {
        public static void main(String[] args) {
            Manager manager = new Manager();
            manager.doing("加密");
            manager.doing("登录");
            
        }
    
    }

执行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 1][]

以上是一个简单的委派模式实现的方式。委派模式中委派者（manager）要持有被委派者（staff）的引用。可以看到在实际实现中和代理模式以及策略模式稍微有点相似。实际上可以这样理解：代理模式注重的是过程，委派模式注重的是结果，策略模式注重的是可扩展（外部扩展），委派模式注重的是内部的灵活和复用。委派模式的核心是分发，调度，派遣。委派模式可以看做是静态代理和策略模式的一种特殊组合。

在实际的Sping中有大量使用到委派模式，在Spring中以Delegate，Dispatcher结尾的类名中，就使用到了委派模式。

下面以简化的ServletDispatcher举例：

public class ServletDispatcher {
    
        private List<Handler> handlerMapping = new ArrayList<Handler>();
    
        public ServletDispatcher(){
            try {
                Class<?> memberActionClass = MemberAction.class;
                handlerMapping.add(new Handler()
                        .setController(memberActionClass.newInstance())
                        .setMethod(memberActionClass.getMethod("getMemberById", new Class[]{String.class}))
                        .setUrl("/web/getMemberById.json"));
            }catch(Exception e){
    
            }
        }
    
    
    
        public void doService(HttpServletRequest request, HttpServletResponse response){
            doDispatch(request,response);
        }
    
    
        private void doDispatch(HttpServletRequest request, HttpServletResponse response){
    
            //1、获取用户请求的url
            //   如果按照J2EE的标准、每个url对对应一个Serlvet，url由浏览器输入
           String uri = request.getRequestURI();
    
            //2、Servlet拿到url以后，要做权衡（要做判断，要做选择）
            //   根据用户请求的URL，去找到这个url对应的某一个java类的方法
    
            //3、通过拿到的URL去handlerMapping（我们把它认为是策略常量）
            Handler handle = null;
            for (Handler h: handlerMapping) {
                if(uri.equals(h.getUrl())){
                    handle = h;
                    break;
                }
            }
    
            //4、将具体的任务分发给Method（通过反射去调用其对应的方法）
            Object object = null;
            try {
                object = handle.getMethod().invoke(handle.getController(),request.getParameter("mid"));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
    
            //5、获取到Method执行的结果，通过Response返回出去
    //        response.getWriter().write();
    
        }
    
    
        class Handler{
    
            private Object controller;
            private Method method;
            private String url;
    
            public Object getController() {
                return controller;
            }
    
            public Handler setController(Object controller) {
                this.controller = controller;
                return this;
            }
    
            public Method getMethod() {
                return method;
            }
    
            public Handler setMethod(Method method) {
                this.method = method;
                return this;
            }
    
            public String getUrl() {
                return url;
            }
    
            public Handler setUrl(String url) {
                this.url = url;
                return this;
            }
        }
    
    
    }

在上面这个代码中，用户通过url请求过来可以看做是之前例子中的boss，ServletDispatcher可以看做是之前例子中的manager，实际执行的Handler可以看做是stuff。

熟悉了委派模式，对分析学习SpringMVC源码有好处。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70]: /images/20220411/1925b9d87ab8481fb875facd3b9e72b5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhcnJ5cHR0ZXI_size_16_color_FFFFFF_t_70 1]: /images/20220411/ace6310283ef4484ad1d2fc720f9c31f.png