Java 利用反射实现C#的委托

一, 观察者模式的缺点

在之前的博文的介绍过观察者模式了.

观察者模式可以让多个观察者同时观察1个被观察者.

也就说被观察者可以1次过执行所有观察者的update()方法.

再通俗d来讲, 就是多个观察者的Update()方法交给被观察者来执行了.



观察者主要应用在Gui 界面的控件事件上, 例如按个按钮可以,令多个其他控件同时产生变化.

但是观察者模式有1个限制, 就是所有观察者类必须实现观察者(Observer)接口. 这个也是回调(callback)方法的1个实现.

现实项目中, 相当于一部分类是不能修改的, 很可能是Jar包发布或者你没有修改权限. (封闭--开放原则)

如果某个类没有实现观察者(Observer)接口, 那么有没有1个办法将这个类的某个方法也交给被观察者来执行呢?

二, 一个题目

假如当前有两个类,

1个是类A, 里面有1个无返回值无参方法a().

另1个是类B, 里面有1无返回值个无参方法b().

这两个类没有实现任何接口, 也不能被修改.

要求写1个类S, 这个类S类似与观察者模式的被观察者(Subject), 可以添加若干个类A或者类B的对象), 并可以通知它们执行自己的a()/b() 方法.

如果让类A和类B实现观察者(Observer)是很简单的.

难点就是它们都不能被修改.

三, C#的委托实现

C#有一种类叫delegate(委托), 他可以让方法(函数)的本身作为1个参数.

同样, 委托也可以是1个容器, 用于存放不同的对象的方法(前提是这些方法返回值和参数类型一样)

C#是这样实现的.

3.1 类A

class A
{
public void a()
{
Console.WriteLine("A.a()");
}

}

3.2 类B

class B
{
public void b()
{
Console.WriteLine("B.b()");
}

}

3.3 类S

public delegate void DelegateNoPra();

class S
{
public DelegateNoPra dg;

public void sNotify()
{
dg();
}
}

注意, 这里的委托(delegate void DelegateNoPra是定义在类S的外面的, 也就是跟类S同级.

然后在类S里构造1个DelegateNoPra的对象dg.

这里的dg相当于1个容器.

在sNotify()调用dg(); 相当于调用dg容器内所有的传入的方法.

3.4 客户端代码

static void Main(string[] args)
{

S s = new S();
s.dg += new A().a;
s.dg += new B().b;
s.dg += new B().b;

s.sNotify();
Console.Read();
}

客户端代码很容易看懂,

先实例化1个S对象

然后将1个A对象的方法a, 两个B对象的方法b 放入S对象的委托容器.

最终一次过被执行

输出:

A.a()
B.b()
B.b()

注意, 传入的方法必须是无参方法(). 也就是将委托对象必须具有相同的参数类型和



如果有参数的方法怎么传入?

则必须再定义1个对应的delegate委托.

四, Java的反射实现

可以见到, C#的代码相当简洁.

而委托这种东西看起来比观察者模式更加方便.

但是现实上是先有观察者模式, 再有C#的委托的.

而且Java是没有委托(delegate)这种东西的, 但是java有反射, 利用java的反射特性也可以实现上面的功能.

4.1 类A

public class A {
public void a(){
System.out.println("A.a()");
}
}

4.2 类B

public class B {
public void b(){
System.out.println("B.b()");
}
}

4.3 类ObjMethod

这里稍稍想想, 到底如何将类A和类b的指定方法传入到另1个类呢?

其实我们可以把它拆分成两部分:

1. 传送对象本身(Object).

2. 传送方法的名字(String).

至于怎样把这两种不同类型的东西放入类S的容器? 方法有很多种,

这里我新建1个类ObjMethod, 把这两种东西封装在一起.

而且我是打算把它放入HashSet容器的, 所以重写了hashCode()和 equals()方法, 只要上面两个成员相等, 我们就认为是相同的两个对象.

代码:

public class ObjMethod {
private Object obj;
private String method;

public ObjMethod(Object obj, String method){
this.obj = obj;
this.method = method;
}

public String getMethod() {
return this.method;
}

public Object getObj() {
return this.obj;
}

@Override
public boolean equals(Object o){
ObjMethod m = (ObjMethod)o;
return (this.getObj() == m.getObj()) && (this.getMethod().equals(m.getMethod()));
}

@Override
public int hashCode(){
return this.getObj().hashCode() * this.getMethod().hashCode();
}
}

4.4 类S

类S的Notify()方法要用到反射了.

其实步骤很简单:

1. 从HashSet获取对象Obj 和 方法名method

2. 利用反射特性获得Obj的类.

3. 利用Obj的类和方法名获得那个方法.

4. 执行这个方法.

import java.util.HashSet;
import java.util.Iterator;
import java.lang.reflect.Method;
public class S {
private HashSet<ObjMethod> methodList = new HashSet<ObjMethod>();

public void attach(Object obj, String method){
this.methodList.add(new ObjMethod(obj,method));
}

public void detach(Object obj, String method){
this.methodList.remove(new ObjMethod(obj,method));
}

public void sNotify(){
if (this.methodList.isEmpty()){
return;
}

Iterator<ObjMethod> it = this.methodList.iterator();
while (it.hasNext()){
ObjMethod m = (ObjMethod)it.next();

Class<?> objClass = m.getObj().getClass(); //get the class of the object
try{
Method method = objClass.getMethod(m.getMethod(), new Class[]{}); //no any parameters
method.invoke(m.getObj(),new Object[]{});//no parameters
}catch(Exception e){
e.printStackTrace();
}

}
}

}

4.5 客户端代码

S s = new S();
s.attach(new A(), "a");
s.attach(new A(), "a");

B b1 = new B();
s.attach(b1, "b");
s.sNotify();

System.out.println("Step 2!");
s.detach(b1,"b");
s.sNotify();

代码也很容易看懂,

跟C#版本差不多. 只不过要把对象和方法名作为两个参数传入到类S对象的HashSet容器.

输出:

A.a()
B.b()
A.a()
Step 2!
A.a()
A.a()

上面的例子跟C#的委托一样, 同样要求传入的方法具有相同的参数类型.

当然, 再完善下甚至可以有一定限度地支持不同的参数类型.

五, 小结

利用Java的反射特性同样实现类似C#委托的功能, 当然代码看起来远远没有C#委托的简洁.
这是因为微软把很多底层的东西封装起来了, 更加方便程序猿的使用.