java设计模式之——委托模式

你的名字 2022-08-26 08:35 158阅读 0赞

委托模式是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。委托模式是一项基本技巧，许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托模式使得我们可以用聚合来替代继承，它还使我们可以模拟mixin。  
“委托”在C\#中是一个语言级特性，而在Java语言中没有直接的对应，但是我们可以通过动态代理来实现委托！代码如下：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
       
    public abstract class Delegator implements InvocationHandler {
        //--------------------------------------------
    
        protected Object obj_orgin = null; //原始对象
        protected Object obj_proxy = null; //代理对象
        //--------------------------------------------
    
        public Delegator() {
        }
    
        public Delegator(Object orgin) {
            this.createProxy(orgin);
        }
       
    
        protected Object createProxy(Object orgin) {
            obj_orgin = orgin;
            //下面语句中orgin.getClass().getClassLoader()为加载器，orgin.getClass().getInterfaces()为接口集
            obj_proxy = Proxy.newProxyInstance(orgin.getClass().getClassLoader(), orgin.getClass().getInterfaces(), this); //委托
            return obj_proxy;
        }
       
    
        protected Object invokeSuper(Method method, Object[] args) throws Throwable {
            return method.invoke(obj_orgin, args);
        }
        //--------------实现InvocationHandler接口，要求覆盖------------
        //下面实现的方法是当委托的类调用toString()方法时，操作其他方法而不是该类默认的toString()，这个类的其他方法则不会。
    
        public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
            // 缺省实现：委托给obj_orgin完成对应的操作
            if (method.getName().equals("toString")) { //对其做额外处理
                return this.invokeSuper(method, args) + "$Proxy";
            } else { //注意，调用原始对象的方法，而不是代理的（obj==obj_proxy）
                return this.invokeSuper(method, args);
            }
        }
    }

下面的代码，则是作为一个委托的例子，实现Map的功能。

import java.io.IOException;
    import java.lang.reflect.Method;
    import java.util.Hashtable;
    import java.util.Map;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import com.bs2.core.UtilLog;
    
    public class Delegator4Map extends Delegator {
        private static Log _log = LogFactory.getLog(Delegator4Map.class);
        private Map orginClass = null; //原始对象
        private Map proxyClass = null; //代理对象
    
        public Map getOrgin() {
            return orginClass;
        }
    
        public Map getProxy() {
            return proxyClass;
        }
    
        public Delegator4Map(Map orgin) {
            super(orgin);
            orginClass = orgin;
            proxyClass = (Map) super.obj_proxy;
        }
    
        public Object invoke(Object obj, Method method, Object[] args) throws Throwable {
            if (method.getName().equals("size")) { //修改size处理逻辑
                Object res2 = new Integer(-1);
                System.out.println("调用委托的方法");
                return res2;
            } else {
                System.out.println("调用原始的方法");
                return super.invoke(obj, method, args);
            }
        }
    
        public static void main(String[] args) throws IOException {
            Delegator4Map rtm = new Delegator4Map(new Hashtable());
            Map m = rtm.getProxy();
            m.size();
        }
    }

代码编写有个这样的原则：能不用继承就不用继承，能使用委托实现的就不使用继承。两个类有明显示的层级关系时使用继承，没有明显的层级关系，仅仅是为了在一个类中使用另一个类的方法时应该使用委托。  
  
根据《重构》一书称：现在有滥用继承的趋势，JDK 中 Stack 就是一个滥用继承的典型！  
  
java.util.Stack 继承自 java.util.Vector，其实 Stack 与 Vector 在用途上完全是风马牛不相及的两个容器。