【转】【Java之JavaSE】反射机制剖析

http://blog.csdn.net/lfsf802/article/details/7239652

什么是Java反射机制 Java的反射机制是在程序运行时，能够完全知道任何一个类，及其它的属性和方法，并且能够任意调用一个对象的属性和方法。这种运行时的动态获取就是Java的反射机制。其实这也是Java是动态语言的一个象征。

用一句话来概括反射就是加载一个运行时才知道的类以及它的完整内部结构。

为什么要有Java反射机制我们为什么要用Java的反射机制呢？我认为有两种：第一种：反射的目的就是为了扩展未知的应用。比如你写了一个程序，这个程序定义了一些接口，只要实现了这些接口的dll都可以作为插件来插入到这个程序中。那么怎么实现呢？就可以通过反射来实现。就是把dll加载进内存，然后通过反射的方式来调用dll中的方法。

第二种：在编码阶段不知道那个类名,要在运行期从配置文件读取类名, 这时候就没有办法硬编码new ClassName(),而必须用到反射才能创建这个对象。

一个生活中常看到的例子有助于理解我们为什么要用Java的反射机制：你进了一家饭店，你不知道他们都有那些菜，要多少钱。那么你第一件事情是干啥“服务员拿个菜单过来”，然后指着菜单说“我要这个，我要那个”。

一起来看ReflectionAPI 在生活中，我们使用一个未知的东西的时候总会用帮助来解决我们的使用问题，电视机有帮助，电脑有帮助，几乎所有的事物都携带着它的一本帮助，Java的反射机制也不例外。

在JDK中有Reflection API的帮助，它主要说明了什么是Java反射机制，这种反射机制提供了什么样的属性和方法，进一步我们能够知道能够通过它完成什么样的工作。

下面咱就一起看看这部分的API。这些接口和类都位于lang包里。如图：接口：类：简单介绍一些类和接口的用法。 1) Member成员是一种接口，反映有关单个成员（字段或方法）或构造方法的标识信息

2) InvocationHandler是代理实例的调用处理程序实现的接口（这个接口的具体用法等到java反射机制剖析4着重介绍）

3) Method提供一个类的方法的信息以及访问类的方法的接口。

示例：

import java.lang.reflect.Method;

public class TestMethod {

    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class classType=Class.forName(args[0]);
        Method methods[]=classType.getDeclaredMethods();
        for(int i=0;i<methods.length;i++){
            System.out.println(methods[i].toString());
        }
    }

}

4) Filed提供一个类的域的信息以及访问类的域的接口。示例：

import java.lang.reflect.Field;

public class TestField {

    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class classType=Class.forName(args[0]);
        Field[] fields = classType.getFields();
        for(int i=0;i<fields.length;i++){
        System.out.println(fields[i].toString());
        }
    }

}

5) Array 类提供了动态创建和访问 Java 数组的方法。示例：

import java.lang.reflect.Array;

public class TestArray {

    public TestArray(){

    }
    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {

        Class<?> classType = Class.forName("java.lang.String");

        Object array = Array.newInstance(classType, 10);

        Array.set(array, 5, "hello");

        String s = (String)Array.get(array, 5);
        System.out.println(s);

    }

}

6) Proxy提供动态地生成代理类和类实例的静态方法（这个方法在java放射机制剖析4着重介绍）。其余的类和接口的使用方法详见API 从《java反射机制剖析（一）》的API我们看到了许多接口和类，我们能够通过这些接口做些什么呢？

从上篇API中我们能看到它能够完成下面的这些功能：

1) 获得类 A. 运用getClass() (每个class都有此函数) i. String str = "abc"; ii. Class c1 = str.getClass();

B. 运用Class.forName() (static method 最常被使用) i. Class c1 = Class.forName ("java.lang.String"); ii. Class c2 = Class.forName ("java.awt.Button"); C. 运用 .class 语法 i. Class c1 = String.class; ii. Class c2 = java.awt.Button.class; iii. Class c4 = int.class; iv. Class c5 = int[].class; D. 运用 TYPE语法 ( primitive wrapper classes 基本数据类型包装类的 TYPE语法) i. Class c1 = Boolean.TYPE;

2) 获得属性（这个功能的实例见Java反射机制剖析（2））以下四个方法可以获得属性，主要参见的是Java.lang.class

Public Field getField (String name) 返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段 public Field[] getFields() 返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段 Public Field getDeclaredField(String name) 返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段 public Field[] getDeclaredFields() 返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段

3) 获得方法（）以下四个方法可以获得方法，要参见的是Java.lang.class

public Method getMethod(String name, ... ) 返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法 public Method[] getMethods() 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法 public Method getDeclaredMethod(String name,…) 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法 public Method[] getDeclaredMethods() 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法

4) 获取类的构造器以下四个方法可以获得方法，要参见的是Java.lang.class

public Constructor getConstructor(Class<?>... ) 返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法 public Constructor<?>[] getConstructors() 返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法 Public Constructor getDeclaredConstructor(Class<?>...) 返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法 public Constructor<?>[] getDeclaredConstructors() 返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。它们是公共、保护、默认（包）访问和私有构造方法示例代码：

import java.lang.reflect.Constructor;

public class TestConstructor {
    /**
     * @param args
     * @throws ClassNotFoundException 
     * @throws SecurityException 
     * @throws NoSuchMethodException 
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class classType=Class.forName(args[0]);
        Constructor Constructor= classType.getConstructor();

            System.out.println(Constructor.toString());

    }

}

5) 新建类的实例调用类的Class对象的newInstance方法

import java.lang.reflect.Constructor;

public class TestConstructor {
    /**
     * @param args
     * @throws ClassNotFoundException 
     * @throws SecurityException 
     * @throws NoSuchMethodException 
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class classType=Class.forName(args[0]);
        //Constructor Constructor= classType.getConstructor();
        Object inst=classType.newInstance();
        System.out.println(inst);   
    }
}

调用默认Constructor对象的newInstance方法

import java.lang.reflect.Constructor;

public class TestConstructor {
    /**
     * @param args
     * @throws ClassNotFoundException 
     * @throws SecurityException 
     * @throws NoSuchMethodException 
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class classType=Class.forName(args[0]);
        Constructor Constructor= classType.getConstructor();
        Object inst=Constructor.newInstance();
        System.out.println(inst);   
    }
}

调用带参数Constructor对象的newInstance方法

Class classType=User.class
Constructor constructor2 =
        classType.getDeclaredConstructor(int.class, String.class);

Object inst = constructor2.newInstance(1, "123");

System.out.println(inst);

通过Java反射机制剖析（一）和Java反射机制剖析（二）的学习，已经对反射有了一定的了解，这一篇通过动态代理的例子来进一步学习反射机制。

代理模式代理模式就是为其他对象提供一种代理来控制对这个对象的访问。其实代理模式是在访问的对象时引入一定程度的间接性，这种间接性可以附加多种用途。

它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

```
分类
```
代理类按照创建时期可以分为两种，静态代理类和动态代理类。静态代理类：由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。动态代理类：在程序运行时，运用反射机制动态创建而成。
```
静态代理和动态代理举例
```
静态代理：业务接口类：

package com.bjpowernode.pattern;

public interface UserManager {

    public void addUser(String userId, String userName);

    public void delUser(String userId);

    public void modifyUser(String userId, String userName);

    public String findUser(String userId);
}

业务接口实现类：

package com.bjpowernode.pattern;

public class UserManagerImpl implements UserManager {

    public void addUser(String userId, String userName) {
        //System.out.println("start-->>addUser() userId-->>" + userId);
        try {
            System.out.println("UserManagerImpl.addUser() userId-->>" + userId);

            //System.out.println("success-->>addUser()");
        }catch(Exception e) {
            e.printStackTrace();
            //System.out.println("error-->>addUser()");
            throw new RuntimeException();
        }   
    }

    public void delUser(String userId) {
        System.out.println("UserManagerImpl.delUser() userId-->>" + userId);
    }

    public String findUser(String userId) {
        System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
        return "张三";
    }

    public void modifyUser(String userId, String userName) {
        System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);
    }

}

业务代理类：

package com.bjpowernode.pattern;

public class UserManagerImplProxy implements UserManager {

    private UserManager userManager;

    public UserManagerImplProxy(UserManager userManager) {
        this.userManager = userManager;
    }

    public void addUser(String userId, String userName) {
        try {
            System.out.println("start-->>addUser() userId-->>" + userId);
            userManager.addUser(userId, userName);
            System.out.println("success-->>addUser()");
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println("error-->>addUser()");
        }   
    }

    public void delUser(String userId) {

    }

    public String findUser(String userId) {
        return null;
    }

    public void modifyUser(String userId, String userName) {

    }

}

客户端类：

package com.bjpowernode.pattern;

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //UserManager userManager = new UserManagerImpl();
        UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
        userManager.addUser("0001", "张三");
    }

}

运行结果：

start-->>addUser() userId-->>0001
UserManagerImpl.addUser() userId-->>0001
success-->>addUser()

动态代理：业务接口类:

package com.bjpowernode.pattern;

public interface UserManager {

    public String test(String userId);
}

业务接口实现类：

package com.bjpowernode.pattern;

public class UserManagerImpl implements UserManager {

    public String test(String userId) {
        System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
        return "张三";
    }

}

BusinessHandler类：

package com.bjpowernode.pattern;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class BusinessHandler implements InvocationHandler {

    private Object targetObject;

    public Object newProxyInstance(Object targetObject) {

        this.targetObject = targetObject;
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                               targetObject.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("start-->>" + method.getName());
        for (int i=0; i<args.length; i++) {
            System.out.println(args[i]);
        }
        Object ret = null;
        try {
            //调用目标方法
            ret = method.invoke(targetObject, args);
            System.out.println("success-->>" + method.getName()); 
        }catch(Exception e) {
            e.printStackTrace();
            System.out.println("error-->>" + method.getName());
            throw e;
        }
        return ret;
    }

}

客户端类：

package com.bjpowernode.pattern;

import java.lang.reflect.Field;

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {

        BusinessHandler businessHandler = new BusinessHandler();
        UserManager userManager = (UserManager)businessHandler.newProxyInstance(new UserManagerImpl());

        //userManager.addUser("0001", "张三");
        //userManager.delUser("0001");
       // System.out.println(userManager.getClass().getName());

        String name = userManager.test("0001");
    //String name = ((UserManagerImpl) logHandler.newProxyInstance(new UserManagerImpl())).test("0001");
        System.out.println("Client.main() --- " + name);
    }

}

运行结果：

start-->>test
0001
UserManagerImpl.findUser() userId-->>0001
success-->>test
Client.main() --- 张三

动态代理类原理（示例代码参见java反射机制剖析（三）） a) 理解上面的动态代理示例流程 b) 代理接口实现类源代码剖析咱们一起来剖析一下代理实现类（$Proxy0）的源代码和整个动态代理的流程。 $Proxy0生成的代码如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Manager {

private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;

static {
   try {
    m1 = Class.forName("java.lang.Object").getMethod("equals",
      new Class[] { Class.forName("java.lang.Object") });
    m0 = Class.forName("java.lang.Object").getMethod("hashCode",
      new Class[0]);
    m3 = Class.forName("com.ml.test.Manager").getMethod("test",
      new Class[0]);
    m2 = Class.forName("java.lang.Object").getMethod("toString",
      new Class[0]);
   } catch (NoSuchMethodException nosuchmethodexception) {
    throw new NoSuchMethodError(nosuchmethodexception.getMessage());
   } catch (ClassNotFoundException classnotfoundexception) {
    throw new NoClassDefFoundError(classnotfoundexception.getMessage());
   }
}

public $Proxy0(InvocationHandler invocationhandler) {
   super(invocationhandler);
}

@Override
public final boolean equals(Object obj) {
   try {
    return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))
      .booleanValue();
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

@Override
public final int hashCode() {
   try {
    return ((Integer) super.h.invoke(this, m0, null)).intValue();
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

public final void test() {
   try {
    super.h.invoke(this, m3, null);
    return;
   } catch (Error e) {
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

@Override
public final String toString() {
   try {
    return (String) super.h.invoke(this, m2, null);
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}
}

引入眼帘的是这个代理接口实现类实现了业务类的接口（也就是例子中的UserManager接口），又继承了基类Proxy类；接着就是构造函数，在构造方法中把BusinessHandler传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值（这里要看Proxy的构造方法）；随后看到的就是这个类重写了Proxy类的Equals、hashCode、toString方法，又实现了业务类接口的方法（即UserManager的test方法），具体重写和实现都是用到的super.h.invoke（即Proxy.h.invoke）这个方法。

简单分析完这个代理接口实现类，咱们下面来整体看一下这个动态代理是怎么实现的：

首先客户端初始化了BusinessHandler类，调用这个类的newProxyInstance(new UserManagerImpl())方法来初始化了上面的代理接口实现类；接下来代理接口实现类通过构造函数把BusinessHandler传过去（也就是代码中的this），并通过Proxy的构造函数给h赋值；随后再客户端就能实例化出代理接口实现类$Proxy0，我们把它强制转换为业务实现接口（UserManager）类型的（为什么要强制转换，这里非常有意思，如果不强制转换就会报错，这里很好解释，因为当前的环境根本不会知道这个代理接口实现类$Proxy0既继承Proxy又实现业务实现接口UserManager，但是强制转换成UserManager它是可以做到的，因为当前环境中就有UserManager。这就是反射的厉害之处，可以在运行时动态调用任何一个类并可以使用这个类的具体细节。）；之后当我们调用test方法的时候其实是调用了$Proxy0中的test方法，这个方法的实现是通过Proxy.h的invoke方法实现的（即调用了BusinessHandler.invoke方法）；之后在调用了Method的invoke方法（这时的参数是this，和args）。这样就调用了UserManagerImpl的对应方法，之后返回给客户端。

到此就完成了整个的调用关系。

反射，反射，程序员的快乐通过上篇文章对动态代理进行了深度剖析，现在想起来还感觉非常有意思，这里面其实最根本的机制就是反射机制，运行时动态实例化任何一个类，并且调用它的具体细节。现在反看动态代理的示例，其实发现这里最关键的还是在就在Proxy.newProxyInstance(..)方法执行时生成了$Proxy0的内存字节码这一点上，当我们有了内存字节码，我们的反射就会大显威力，这样才有了我们之后的一系列的调用关系。

通过反射机制的分析和动态代理示例的剖析，发现编程是一件多么有意思的事情，以至于我们沉浸其中不能自拔。

最后总结一下：反射，反射，程序员的快乐！

vagabond1-1983 / blog

【转】【Java之JavaSE】反射机制剖析 #20