java设计模式之——委托模式
委托模式是软件设计模式中的⼀项基本技巧。在委托模式中，有两个对象参与处理同⼀个请求，接受请求的对象将请求委托给另⼀个对象来处理。委托模式是⼀项基本技巧，许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采⽤了委托模式。委托模式使得我们可以⽤聚合来替代继承，它还使我们可以模拟mixin。
“委托”在C#中是⼀个语⾔级特性，⽽在Java语⾔中没有直接的对应，但是我们可以通过动态代理来实现委托！代码如下：
import flect.InvocationHandler;
import flect.Method;
import flect.Proxy;
public abstract class Delegator implements InvocationHandler {
java中常用的设计模式有哪些
//--------------------------------------------
protected Object obj_orgin = null; //原始对象
protected Object obj_proxy = null; //代理对象
//--------------------------------------------
public Delegator() {
}
public Delegator(Object orgin) {
}
protected Object createProxy(Object orgin) {
obj_orgin = orgin;
//下⾯语句中Class().getClassLoader()为加载器，Class().getInterfaces()为接⼝集
obj_proxy = Class().getClassLoader(), Class().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 (Name().equals("toString")) { //对其做额外处理
return this.invokeSuper(method, args) + "$Proxy";
} else { //注意，调⽤原始对象的⽅法，⽽不是代理的（obj==obj_proxy）
return this.invokeSuper(method, args);
}
}
}
下⾯的代码，则是作为⼀个委托的例⼦，实现Map的功能。
import java.io.IOException;
import flect.Method;
import java.util.Hashtable;
import java.util.Map;
import org.apachemons.logging.Log;
import org.apachemons.logging.LogFactory;
import UtilLog;
public class Delegator4Map extends Delegator {
private static Log _log = Log(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 (Name().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 = Proxy();
m.size();
}
}
代码编写有个这样的原则：能不⽤继承就不⽤继承，能使⽤委托实现的就不使⽤继承。两个类有明显⽰的层级关系时使⽤继承，没有明显的层级关系，仅仅是为了在⼀个类中使⽤另⼀个类的⽅法时应该使⽤委托。
根据《重构》⼀书称：现在有滥⽤继承的趋势，JDK 中 Stack 就是⼀个滥⽤继承的典型！
java.util.Stack 继承⾃ java.util.Vector，其实 Stack 与 Vector 在⽤途上完全是风马⽜不相及的两个容器。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。