Java中的委托模式
2015-12-27 14:30
459 查看
委托模式是软件设计模式中的一项基本技巧。在委托模式中,有两个对象参与处理同一个请求,接受请求的对象将请求委托给另一个对象来处理。委托模式是一项基本技巧,许多其他的模式,如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托模式使得我们可以用聚合来替代继承,它还使我们可以模拟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 orginCla
3ff0
ss;
}
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 在用途上完全是风马牛不相及的两个容器。
“委托”在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 orginCla
3ff0
ss;
}
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 在用途上完全是风马牛不相及的两个容器。
相关文章推荐
- java对世界各个时区(TimeZone)的通用转换处理方法(转载)
- java-注解annotation
- java-模拟tomcat服务器
- java-用HttpURLConnection发送Http请求.
- java-WEB中的监听器Lisener
- Android IPC进程间通讯机制
- Android Native 绘图方法
- Android java 与 javascript互访(相互调用)的方法例子
- 介绍一款信息管理系统的开源框架---jeecg
- 聚类算法之kmeans算法java版本
- java实现 PageRank算法
- PropertyChangeListener简单理解
- c++11 + SDL2 + ffmpeg +OpenAL + java = Android播放器
- 插入排序
- 冒泡排序
- 堆排序
- 快速排序
- 二叉查找树