委派模式（行为）

简介

委派模式的作用：基本作用就是负责任务的调用和分配任务，跟代理模式很像，可以看做是一种特殊情况下的静态代理的全权代理，但是代理模式注重过程，而委派模式注重结果

:::tip 委派模式不属于23种设计模式之一，属于是一种行为模式 :::

类型：行为型

UML图例

示例讲解

业务执行者 (Worker) 的具体实现

/** 工人接口 */
public interface Worker {
    /**
     * 做事情
     * @param thing 任务
     */
    void doing(String thing);
}
/** 厨师工 */
public class ChefWorker implements Worker {
    /** 
    * 做事情 
    * @param thing 任务
    */
    @Override
    public void doing(String thing) {
        System.out.println("我是厨师，我接到任务，需要做美食。");
    }
}

/** 缝纫工 */
public class TailorWorker implements Worker {
    /** 
    * 做事情 
    * @param thing 任务
    */
    @Override
    public void doing(String thing) {
        System.out.println("我是缝纫工，我接到任务，需要做衣服。");
    }
}

任务派发者 (Leader) 的具

/** 组长 */
public class Leader implements Worker {
    private static Map<String, Worker> OFFICE = new HashMap<>();

    public Leader() {
        OFFICE.put("cooking", new ChefWorker());
        OFFICE.put("sewing", new TailorWorker());
    }

    /**
     * 做事情
     * @param thing 任务
     */
    @Override
    public void doing(String thing) {
        System.out.println("我是组长，领导需要: " + thing + "，我来安排任务: " + thing);
        if (OFFICE.containsKey(thing)) {
            OFFICE.get(thing).doing(thing);
        } else {
            System.err.println("目前办公室没有对应职位的工人");
        }
    }
}

大领导 (Boss) 的具体实现

/** 领导 */
public class Boss {
    /**
     * 下命令
     * @param thing  需要处理的事情
     * @param leader 安排给一个组长
     */
    public void command(String thing, Leader leader) {
        System.out.println("我是领导，我现在需要处理: " + thing);
        leader.doing(thing);
    }
}

测试类

/** 委派模式，测试类 */
public class PatternTest {
    public static void main(String[] args) {
        Boss boss = new Boss();
        boss.command("cooking", new Leader());
        System.out.println("------------------- ");
        boss.command("sewing", new Leader());
        System.out.println("------------------- ");
        boss.command("selling", new Leader());
    }
}

测试结果

我是领导，我现在需要处理: cooking
我是组长，领导需要: cooking，我来安排任务: cooking
我是厨师，我接到任务，需要做美食。
------------------- 
我是领导，我现在需要处理: sewing
我是组长，领导需要: sewing，我来安排任务: sewing
我是缝纫工，我接到任务，需要做衣服。
------------------- 
我是领导，我现在需要处理: selling
我是组长，领导需要: selling，我来安排任务: selling
目前办公室没有对应职位的工人

委派模式的实现mvc的简单实例

思考：在springmvc 访问地址的url与Controller层配置的url是如何映射的 Controller层配置的url如何跟具体的方法映射的，参数又是如何绑定的

猜测： url的地址可以根据request得到访问url地址，配置的url地址可以根据配置注解得到，这两者的url匹配上了说明映射成功了，除了url是不够的，还需要一个中间对象保存了url和method以及controller对象的信息，可以把这个中间的映射对象放入容器中，然后根据传入的url从容器取出进行匹配，取出来之后就可以根据映射来完成方法的调用了。

下面就简单实现一个mvc调用的例子

模拟controller层

/**
 * @description:  模拟controller层
 **/
public class MemberAction {
    public void getMemberById(String mid){
        
    }
}

模拟serlvert得到的请求如何转发,交给具体的controller处理的

/**
 * @description:   selvelt的任务分发者 ，主要完成url的映射和调用
 **/
public class SelvletDispatcher {
    //这里也可以用map 对象来保存Hanlder对象
    private List<Handler> handlerMapping = new ArrayList<Handler>();
    
    public SelvletDispatcher() {
        //简单实现一个controller的映射
        try {
      Class clazz  = MemberAction.class;

            handlerMapping.add(new Handler()
                            .setController(clazz.newInstance())
                            .setMethod(clazz.getMethod("getMemberById",new Class[]{String.class}))
                            .setUrl("/web/getMemberById.json")
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void  doService(HttpServletRequest request, HttpServletResponse response){
        doDispatch(request,response);
    }

    /**
     * 请求的分发工作
     * @param request
     * @param response
     */
    private void doDispatch(HttpServletRequest request, HttpServletResponse response) {
      //1.获取用户请求的url
      String uri =   request.getRequestURI();
      Handler handler =null;

      ////2、根据uri 去handlerMapping找到对应的hanler
      for(Handler h :handlerMapping){
          if(uri.equals(h.getUrl())){
              handler = h;
              break;
          }
      }
      //3.将具体的任务分发给Method（通过反射去调用其对应的方法）
        Object obj = null;
        try {
            obj =  handler.getMethod().invoke(handler.getController(),request.getParameter("mid"));
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        //4、获取到Method执行的结果，通过Response返回出去
        // response.getWriter().write();

    }
    /**
     * 具体的hanlder对象
     */
    class Handler{
        //controller对象
        private Object controller;
        //controller对象映射的方法
        private  String url;
        //ulr对应的方法
        private Method method;

        public Object getController() {
            return controller;
        }

        public Handler setController(Object controller) {
            this.controller = controller;
            return this;
        }

        public String getUrl() {
            return url;
        }

        public Handler setUrl(String url) {
            this.url = url;
            return  this;
        }

        public Method getMethod() {
            return method;
        }

        public Handler setMethod(Method method) {
            this.method = method;
            return this;
        }
    }
}