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

淡淡的烟草味﹌ 2022-08-06 07:16 169阅读 0赞

## 一, 观察者模式的缺点 ##

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

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

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

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

![444127020141231225911060.png_609x419_130][]

观察者主要应用在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\#委托的简洁.

这是因为微软把很多底层的东西封装起来了, 更加方便程序猿的使用.

[444127020141231225911060.png_609x419_130]: http://image15.poco.cn/mypoco/myphoto/20141231/22/444127020141231225911060.png?609x419_130