委派模式精讲

委派模式是一种行为型模式,这种模式的原理为类 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.addnew Handler).setControllerclazz.newInstance)).setMethodclazz.getMethod"getMemberById",new Class[]{String.class})).setUrl"/web/getMemberById.json"));
        }catch Exception e){
            e.printStackTrace);
        }
    }
    public void doServiceHttpServletRequest request, HttpServletResponse response){
        try {
            doDispatchrequest,response);
        } catch Exception e) {
            e.printStackTrace);
        }
    }

    private void doDispatchHttpServletRequest request, HttpServletResponse response) throws Exception {
        String uri=request.getRequestURI);
        Handler handle=null;
        for Handler h:handlerMapping){
           ifuri.equalsh.getUrl))){
               handle=h;

               break;
           }
        }
        Object object=handle.getMethod).invokehandle.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 setControllerObject controller) {
            this.controller = controller;
            return this;
        }

        public Method getMethod) {
            return method;
        }

        public Handler setMethodMethod method) {
            this.method = method;
            return this;
        }

        public String getUrl) {
            return url;
        }

        public Handler setUrlString url) {
            this.url = url;
            return this;
        }
    }
}
package pattern.delegate.controllers;
public class MemberAction {
    public void getMemberByIdString id){
        System.out.println"查询会员的编号:"+id);
    }

}
package pattern.delegate.controllers;
public class OrderAction {
    public void getOrderByIdString 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 mainString[] args) {
        //客户请求Boss)、委派者Leader)、被委派者Target)
        //委派者要持有被委派者的引用
        //代理模式主动的是过程,委派者主动的是结果
        //策略模式注重的是可扩展外部扩展),委派模式注重的是内部的灵活和复用
        //委派模式是静态代理和策略模式的组合
        new Leader).doing"登录");
    }
}
package pattern.delegate.leader;

public interface ITarget {

    public void doingString 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 doingString command){
        targetMap.getcommand).doingcommand);
    }

}
package pattern.delegate.leader;

public class TargetA implements ITarget {
    @Override
    public void doingString command) {
        System.out.println"我是员工A,我现在开始干:"+command);
    }
}
package pattern.delegate.leader;

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

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

Published by

风君子

独自遨游何稽首 揭天掀地慰生平