委派模式精讲

委派模式是一种行为型模式,这种模式的原理为类 B和类 A 是两个互相没有任何关系的类，B 具有和 A 一模一样的方法和属性；并且调用 B 中的方法，属性就是调用 A 中同名的方法和属性。B 好像就是一个受 A 授权委托的中介。第三方的代码不需要知道 A 的存在，也不需要和 A 发生直接的联系，通过 B 就可以直接使用 A 的功能，这样既能够使用到 A 的各种功能，又能够很好的将 A 保护起来了，一举两得。下面通过两个代码进行演示:

第一个是Servlet的DispatcherServlet：

package pattern.delegate;
import pattern.delegate.controllers.MemberAction;
import pattern.template.entity.Member;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
public class ServletDispatcher {
    private List<Handler> handlerMapping=new ArrayList<>();
    public ServletDispatcher(){
        try {
            Class<?> clazz= Member.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();
        }
    }
    public void doService(HttpServletRequest request, HttpServletResponse response){
        try {
            doDispatch(request,response);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        String uri=request.getRequestURI();
        Handler handle=null;
        for (Handler h:handlerMapping){
           if(uri.equals(h.getUrl())){
               handle=h;

               break;
           }
        }
        Object object=handle.getMethod().invoke(handle.getController(),request.getParameter("id"));
        response.getWriter().append("");
    }
    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;
        }
    }
}

package pattern.delegate.controllers;
public class MemberAction {
    public void getMemberById(String id){
        System.out.println("查询会员的编号:"+id);
    }

}

package pattern.delegate.controllers;
public class OrderAction {
    public void getOrderById(String id){
        System.out.println("查询订单的编号:"+id);
    }
}

package pattern.delegate.controllers;
public class SystemAction {
    public void logout(){
        System.out.println("退出");
    }
}

主要是理解什么是委派模式。

下面用一个经理给员工发任务的例子说明一下:

package pattern.delegate.leader;

public class Boss {
    public static void main(String[] args) {
        //客户请求(Boss)、委派者(Leader)、被委派者(Target)
        //委派者要持有被委派者的引用
        //代理模式主动的是过程,委派者主动的是结果
        //策略模式注重的是可扩展(外部扩展),委派模式注重的是内部的灵活和复用
        //委派模式是静态代理和策略模式的组合
        new Leader().doing("登录");
    }
}

package pattern.delegate.leader;

public interface ITarget {

    public void doing(String command);

}

package pattern.delegate.leader;

import java.util.HashMap;
import java.util.Map;

public class Leader implements ITarget {

    private Map<String,ITarget> targetMap=new HashMap<>();

    public Leader() {
        targetMap.put("加密",new TargetA());
        targetMap.put("登录",new TargetA());
    }

    /**
     * 项目经理不干活,只派发任务
     * @param command
     */
    public void doing(String command){
        targetMap.get(command).doing(command);
    }

}

package pattern.delegate.leader;

public class TargetA implements ITarget {
    @Override
    public void doing(String command) {
        System.out.println("我是员工A,我现在开始干:"+command);
    }
}

package pattern.delegate.leader;

public class TargetB implements ITarget {
    @Override
    public void doing(String command) {
        System.out.println("我是员工B,我现在开始干:"+command);
    }
}

这个例子比上面的比较好理解一点,需要好好的品味。