委派模式精讲

委派模式是一种行为型模式,这种模式的原理为类 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);
    }
}

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