在学习HadoopRPC时，用到了函数调用，函数调用都是采用的java的反射机制和动态代理来实现的，所以现在回顾下java的反射和动态代理的相关知识。
一、反射
JAVA反射机制定义： JAVA反射机制是java程序在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
反射就是把Java类中的各种成分映射成相应的Java类。
Java反射机制主要提供了以下功能：
1、在运行时判断任意一个对象所属的类；
2、在运行时构造任意一个类的对象；
3、在运行时判断任意一个类所具有的成员变量和方法；
4、在运行时调用任意一个对象的方法；
5、生成动态代理。
我们了解了反射机制的功能，那么我们如何具体来实现它呢？
一个类中的每个成员都可以用相应的反射包中的一个类的实例对象来表示，通过Class类的方法可以得到这些实例对象；这个“成员”就包括：类的构造函数、成员变量、方法等一些信息。而他们所对应的反射包中的类分别是：Constructor类、Field类、Method类。
这里只要讲讲动态代理的知识。
二、动态代理
Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：
(1). Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。 这个抽象方法在代理类中动态实现。
(2).Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：
Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。
实例：
1、定义一个HelloWorld接口
- /**
- * 定义一个HelloWorld接口
- *
- * @author
- *
- */
- public interface HelloWorld {
- public void sayHelloWorld();
- }
2、类HelloWorldImpl是HelloWorld接口的实现
- /**
- * 类HelloWorldImpl是HelloWorld接口的实现
- *
- * @author
- *
- */
- public class HelloWorldImpl implements HelloWorld{
- public void sayHelloWorld() {
- System.out.println("HelloWorld!");
- }
- }
3、HelloWorldHandler是 InvocationHandler接口实现
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Method;
- /**
- * 实现在方法调用前后向控制台输出两句字符串
- *
- * @author
- *
- */
- public class HelloWorldHandler implements InvocationHandler{
- //要代理的原始对象
- private Object obj;
-
- public HelloWorldHandler(Object obj) {
- super();
- this.obj = obj;
- }
- /**
- * 在代理实例上处理方法调用并返回结果
- *
- * @param proxy 代理类
- * @param method 被代理的方法
- * @param args 该方法的参数数组
- */
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- Object result = null;
- //调用之前
- doBefore();
- //调用原始对象的方法
- result=method.invoke(obj, args);
- //调用之后
- doAfter();
- return result;
- }
-
- private void doBefore(){
- System.out.println("before method invoke");
- }
-
- private void doAfter(){
- System.out.println("after method invoke");
- }
-
- }
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Proxy;
- public class HelloWorldTest {
- public static void main(String[] args) {
- HelloWorld helloWorld=new HelloWorldImpl();
- InvocationHandler handler=new HelloWorldHandler(helloWorld);
-
- //创建动态代理对象
- HelloWorld proxy=(HelloWorld)Proxy.newProxyInstance(
- helloWorld.getClass().getClassLoader(),
- helloWorld.getClass().getInterfaces(),
- handler);
- proxy.sayHelloWorld();
- }
- }
before method invoke
HelloWorld
after method invoke
总结：
一个典型的动态代理创建对象过程可分为以下四个步骤：
1、通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(...);
2、通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类
Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});
3、通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型
Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4、通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
为了简化对象创建过程，Proxy类中的newInstance方法封装了2~4，只需两步即可完成代理对象的创建。
生成的ProxySubject继承Proxy类实现Subject接口，实现的Subject的方法实际调用处理器的invoke方法，而invoke方法利用反射调用的是被代理对象的的方法（Object result=method.invoke(proxied,args)）
综合上面所说的，作为一个Dynamic Proxy，它必须满足以下三个条件：
1、实现了InvocationHandler接口，实现接口中定义的invoke方法；
2、包含接口实现类的实例；
3、通过Proxy.newProxyInstance方法实现Proxy与接口之间的绑定
再来回顾一下定义
Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作 。
来自： http://blog.csdn.net//u011067360/article/details/25040463 | 
