委派模式

• 委派模式得基本作用就是负责任务得调用和分配任务，跟代理模式很像，可以看作是一种特殊情况下得静态代理得全权代理，但是代理模式注重过程，而委派模式注重结果。
• 不属于GOF 23种设计模式之一
• 属于行为型模式
• 例如Spring中的DispatcherServlet
• Delegate结尾的一般都是委派，Dispatcher

代码：简单案例

public interface IEmployee {
    public void doing(String command);
}

public class EmployeeA implements IEmployee {
    @Override
    public void doing(String command) {
        System.out.println("员工A，擅长加密");
    }
}

public class EmployeeB implements IEmployee {
    @Override
    public void doing(String command) {
        System.out.println("员工B，擅长架构");
    }
}

public class Leader {
    private Map<String,IEmployee> register=new HashMap<>();
    public Leader() {
        register.put("加密",new EmployeeA());
        register.put("架构",new EmployeeB());
    }
    public void doing(String command) {
        register.get(command).doing(command);
    }
}

public class Boss {
    public void command(String command,Leader leader) {
            leader.doing(command);
    }
}

public class DelegateTest {
    public static void main(String[] args) {
    //重要：委派模式更偏向于结果，而策略模式强调可替换，所以一般会多出一个抽象或者接口
        new Boss().command("加密",new Leader()); //员工A，擅长加密
    }
}

1.jpg

MVC小案例

public class DispatcherServlet extends HttpServlet {
    private List<Handler> handlerList = new ArrayList<>();

    @Override
    public void init() throws ServletException {
        try {
        
        //此处根据反射动态创建，而且例如spring应该是读取配置文件，然后for形式添加
            Class<MemberController> memberControllerClass = MemberController.class;
            handlerList.add(new Handler().setController(memberControllerClass.newInstance())
                    .setMethod(memberControllerClass.getMethod("getMemberById", new Class[]{String.class}))
                    .setUrl("/web/getMemberById.json"));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doDiapatch(req, resp);
    }

    private void doDiapatch(HttpServletRequest req, HttpServletResponse resp) {
        String uri = req.getRequestURI();
        Handler handler=null;
        for (Handler h : handlerList) {
            if (uri.equals(h.getUrl())) {
                handler=h;
                break;
            }
        }
        try {
           Object obj= handler.getMethod().invoke(handler.getController(),req.getParameter("mid"));
            resp.getWriter().write(obj.toString());
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

//    private void doDiapatch(HttpServletRequest req, HttpServletResponse resp) throws IOException {
//        String uri = req.getRequestURI();
//        String mid = req.getParameter("mid");
//        if ("getMemberById".equals(uri)) {
//            new MemberController().getMemberById(mid);
//        } else if ("getOrderById".equals(uri)) {
//            new OrderController().getOrderById(mid);
//        } else if ("logout".equals(uri)) {
//            new SystemController().logout();
//        }else{
//            resp.getWriter().write("404 Not Found");
//        }
//    }


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