从代理模式到Java反射机制

        代理模式，相信大多数人都非常熟悉，常见的实现方式是通过公共接口的方式，让我们的目标类和代理类实现同一接口，在代理类中调用目标类对象的方法。具体请看我另一个博客中的文章：Java的代理模式（通过公共接口实现） 。通过接口的方式，有个不好的地方，就是对每个目标类都要写一对与之相对应的接口和代理类，如果业务类很多，就是非常繁锁的工作了。

而加入反射机制的代理模式，可实现一个公共的代理类，省去我们不少功夫。Java的java.lang.reflect包及其子包中提供了Class、Method、Annotation等有用的类。下面，写个方法代理的类MethodProxy，实现动态地调用对象的方法。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
 * 方法代理类
 * @author rongxinhua
 *
 */
public class MethodProxy {
	
	private Class clazz;	//对象所属的类
	private Object target;	//目标对象
	private Method method;	//目标方法
	private Object[] params;	//参数数组
	
	@SuppressWarnings("unchecked")
	public MethodProxy(Object target, String methodName, Object ... params) {
		rebindTarget(target, methodName, params);	//设置目标对象与方法
	}
	
	/**
	 * 重新设置目标对象与方法
	 * @param target
	 * @param methodName
	 * @param params
	 */
	public void rebindTarget(Object target, String methodName, Object ... params) {
		this.target = target;
		this.clazz = target.getClass();
		rebindMethod(methodName, params);	//设置目标方法
	}
	
	/**
	 * 重新设置目标方法
	 * @param methodName
	 * @param params
	 */
	public void rebindMethod(String methodName, Object ...params) {
		this.params = params;
		int paramLength = params.length;
		Class[] paramTypes = new Class[paramLength];
		for(int i = 0 ; i < paramLength ; i ++ ) {
			paramTypes[i] = params[i].getClass();
		}
		try {
			this.method = clazz.getMethod(methodName, paramTypes);
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 动态调用已绑定的方法
	 */
	public void doMethod() {
		try {
			this.method.invoke(target, params);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}

}

这样就可以实现动态地调用某个对象的某个方法了，写个测试代码如下：

public class Manager {
	
	public void say() {
		System.out.println("Nobody say nothing");
	}
	
	public void love(String boy, String girl) {
		System.out.println(boy + " love " + girl);
	}
	
}

 我们通过代理类来调用Manager类中的say()和love()方法，测试代码如下：

		Manager man = new Manager();	//目标对象
		MethodProxy proxy = new MethodProxy(man, "say");	//方法代理对象
		proxy.doMethod();	//调用被代理的方法
		proxy.rebindMethod("love", "Tom", "Marry");	//重新绑定方法
		proxy.doMethod();	//调用被代理的方法

这样就实现了动态代理调用对象的方法，上面代码输出结果就不贴出来了。如果要设置前置通知和后置通知等功能，也很容易实现，只需在“proxy.doMethod()”代码处的前面和后面设置即行。

扩展应用：我们在上面的MethodProxy类中加入以下方法：

	/**
	 * 获取方法上的注解
	 * @param anClazz 注解类
	 * @return
	 */
	public Annotation getAnnotation(Class anClazz) {
		return this.method.getAnnotation(anClazz);
	}

这个方法用来读取方法上的注解（Annotation），有什么用呢？我们写一个注解来测试下。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Low {
	int boyAge();	//男孩法定的谈恋爱年龄
	int girlAge();	//女孩法定的谈恋爱年龄
}

我们要引进Annotation相关的类：

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

我们另外写一个测试用的业务类：

public class LoveManager {
	
	@Low(boyAge=12, girlAge=10)
	public void beAbleToLove(Person boy, Person girl) {
		System.out.println(boy.getName() + " is able to love " + girl.getName());
	}
	
}

public class Person {
	private String name;
	private int age;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//getter方法略
}

接写上例中的proxy对象测试代码：

		LoveManager loveManager = new LoveManager();
		Person boy = new Person("Tom", 13);
		Person girl = new Person("Marry", 10);
		proxy.rebindTarget(loveManager, "beAbleToLove", boy, girl);	//重新绑定对象和方法
		Low low = (Low)proxy.getAnnotation(Low.class);
		if(boy.getAge() < low.boyAge()) {
			System.out.println(boy.getName() + "还不到法定年龄，不能谈恋爱！");
		} else if(girl.getAge() < low.girlAge()) {
			System.out.println(girl.getName() + "还不到法定年龄，不能谈恋爱！");
		} else {
			proxy.doMethod();
		}

根据boy和girl的年龄大小，会相应地输出下列之一：

Tom还不到法定年龄，不能谈恋爱！

Marry还不到法定年龄，不能谈恋爱！

Tom is able to love Marry

这就实现了，通过Java的反射来读取Annotation的值，并根据Annotation的值，来处理业务数据有效性的判断，或者面向切面动态地注入对象，或者作日志、拦截器等等。这种用法在所多框架中都常常看到， 我们在开发自己的Java组件时，不妨也采用一下吧！

通过params 一定能得到正确的 method的 paramTypes吗?  子类可以代替父类,实现类可以代理接口作为参数.

这样 params[i].getClass 已经不是method meta里面的 class了.

只能说在通常情况下 ,能找到method

    是啊，如果class类中的方法的参数是个类，这个类存在子类，在直接调用class的时候，可以将子类作为参数出入，但通过类的反射，class.getMethod是找不到

    以子类为参数定义的方法的，谁能告诉我这种情况下该如何解决？