委派模式精讲

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