Java反射机制的学习
Java反射机制是Java语言被视为准动态语言的关键性质。Java反射机制的核心就是允许在运行时通过Java Reflection APIs来取得已知名字的class类的相关信息，动态地生成此类，并调用其方法或修改其域（甚至是本身声明为private的域或方法）。
也许你使用Java已经很长时间了，可是几乎不会用到Java反射机制。你会嗤之以鼻地告诉我，Java反射机制没啥用。或许在J2EE、J2SE等平台，Java反射机制没啥用（具体我也不了解，不多做评论），但是在Android应用开发中，该机制会带给你许多惊喜。
如果熟悉Android，那么你应该知道，Google不知出于什么原因，在系统源码中一些类或方法中经常加上“@hide”注释标记。它的作用是使这个方法或类在生成SDK时不可见，因此由此注释的东西，你在编译期是不可见的。这就出现了一些问题。一些明明可以访问的东西编译期却无法访问了！这使得你的程序有些本来可以完成的功能无法编译通过。
当然，有一种办法是自己去掉Android源码中的所有“@hide”标记，然后重新编译一份自己的SDK。另一种办法就是使用Java反射机制。当然，你还可以利用反射来访问存在访问限制的方法和修改其域。不过这种使用方法比较特殊，我们在文章的最后单独讨论。
从Class类说起
如果你使用Java，那么你应该知道Java中有一个Class类。Class类本身表示Java对象的类型，我们可以通过一个Object（子）对象的getClass方法取得一个对象的类型，此函数返回的就是一个Class类。当然，获得Class对象的方法有许多，但是没有一种方法是通过Class的构造函数来生成Class对象的。
也许你从来没有使用过Class类，也许你曾以为这是一个没什么用处的东西。不管你以前怎么认为，Class类是整个Java反射机制的源头。一切关于Java反射的故事，都从Class类开始。
因此，要想使用Java反射，我们首先得到Class类的对象。下表列出了几种得到Class类的方法，以供大家参考。
Class object 诞生管道
示例
运用getClass()
注：每个class 都有此函数
String str = "abc";
Class c1 = str.getClass();
运用
Class.getSuperclass()
Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
运用static method
Class.forName()
（最常被使用）
Class c1 = Class.forName ("java.lang.String");
Class c2 = Class.forName ("java.awt.Button");
Class c3 = Class.forName ("java.util.LinkedList$Entry");
Class c4 = Class.forName ("I");
Class c5 = Class.forName ("[I");
运用
.class 语法
Class c1 = String.class;
Class c2 = java.awt.Button.class;
Class c3 = Main.InnerClass.class;
Class c4 = int.class;
Class c5 = int[].class;
运用
primitive wrapper classes
的TYPE 语法
Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Character.TYPE;
Class c4 = Short.TYPE;
Class c5 = Integer.TYPE;
Class c6 = Long.TYPE;
Class c7 = Float.TYPE;
Class c8 = Double.TYPE;
Class c9 = Void.TYPE;获取一些基本信息
在我们得到一个类的Class类对象之后，Java反射机制就可以大施拳脚了。首先让我们来了解下如何获取关于某一个类的一些基本信息。
Java class 内部模块
Java class 内部模块说明
相应之Reflection API，多半为Class methods。
返回值类型(return type)
package
class隶属哪个package
getPackage()
Package
import
class导入哪些classes
无直接对应之API。可间接获取。
modifier
class（或methods, fields）的属性
int getModifiers()
Modifier.toString(int)
Modifier.isInterface(int)
int
String
bool
class name or interface name
class/interface
名称getName()
String
type parameters
参数化类型的名称
getTypeParameters()
TypeVariable <Class>[]
base class
base class（只可能一个）
getSuperClass()
Class
implemented interfaces
实现有哪些interfaces
getInterfaces()
Class[]
inner classes
内部classes
getDeclaredClasses()
Class[]
outer class
如果我们观察的class 本身是inner classes，那么相对它就会有个outer class。
getDeclaringClass()
Class上表中，列出了一些Java class内部信息的获取方式。所采用的方法几乎都是调用Class对象的成员方法（由此你就可以了解到Class类的用处了吧）。当然，表中所列出的信息并不是全部，有很大一部分没有列出，你可以通过查阅Java文档得到更全面的了解。另外，下面将重点介绍一下类的构造函数、域和成员方法的获取方式。
类中最重要的三个信息
如果要对一个类的信息重要性进行排名的话，那么这三个信息理应获得前三的名次。它们分别是：构造函数、成员函数、成员变量。
也许你不同意我的排名，没关系。对于Java反射来说，这三个信息与之前介绍的基本信息相比较而言，有着本质的区别。那就是，之前的信息仅仅是只读的，而这三个信息可以在运行时被调用（构造函数和成员函数）或者被修改（成员变量）。所以，我想无可否认，至少站在Java反射机制的立场来说，这三者是最重要的信息。
下面，让我们分别了解一下这三个重要信息的获取方式。另外，我们将在后面的章节，详细介绍他们的调用方式或者修改方式。
构造函数
如果我们将Java对象视为一个二进制的生活在内存中生命体的话，那么构造函数无疑可以类比为Java对象生命体的诞生过程。我们在构造函数调用时为对象分配内存空间，初始化一些属性，于是一个新的生命诞生了。
Java是纯面向对象的语言，Java中几乎所有的一切都是类的对象，因此可想而知构造函数的重要性。
Java反射机制能够得到构造函数信息实在应该是一件令人惊喜的事情。正因为此，反射机制实质上才拥有了孵化生命的能力。换句话言之，我们可以通过反射机制，动态地创建新的对象。
获取构造函数的方法有以下几个：
Constructor getConstructor(Class[] params)
Constructor[] getConstructors()
Constructor getDeclaredConstructor(Class[] params)
Constructor[] getDeclaredConstructors()我们有两种方式对这四个函数分组。
首先可以由构造函数的确定性进行分类。我们知道，一个类实际上可以拥有很多个构造函数。那么我们获取的构造函数是哪个呢？我们可以根据构造函数的参数标签对构造函数进行明确的区分，因此，如果我们在Java反射时指定构造函数的参数，那么我们就能确定地返回我们需要的那个“唯一”的构造函数。getConstructor(Class[] params) 和getDeclaredConstructor(Class[] params)正是这种确定唯一性的方式。但是，如果我们不清楚每个构造函数的参数表，或者我们出于某种目的需要获取所有的构造函数的信息，那么我们就不需要明确指定参数表，而这时返回的就应该是构造函数数组，因为构造函数很可能不止一个。getConstructors()和getDeclaredConstructors()就是这种方式。
另外，我们还可以通过构造函数的访问权限进行分类。在设计类的时候，我们往往有一些构造函数需要声明为“private”、“protect”或者“default”，目的是为了不让外部的类调用此构造函数生成对象。于是，基于访问权限的不同，我们可以将构造函数分为public和非public两种。
getConstructor(Class[] params) 和getConstructors()仅仅可以获取到public的构造函数，而getDeclaredConstructor(Class[] params) 和getDeclaredConstructors()则能获取所有（包括public和非public）的构造函数。
成员函数
如果构造函数类比为对象的诞生过程的话，成员函数无疑可以类比为对象的生命行为过程。成员函数的调用执行才是绝大多数对象存在的证据和意义。Java反射机制允许获取成员函数（或者说成员方法）的信息，也就是说，反射机制能够帮助对象践行生命意义。通俗地说，Java反射能使对象完成其相应的功能。
和获取构造函数的方法类似，获取成员函数的方法有以下一些：
Method getMethod(String name, Class[] params)
Method[] getMethods()
Method getDeclaredMethod(String name, Class[] params)
Method[] getDeclaredMethods() 其中需要注意，String name参数，需要写入方法名。关于访问权限和确定性的问题，和构造函数基本一致。
成员变量
成员变量，我们经常叫做一个对象的域。从内存的角度来说，构造函数和成员函数都仅仅是Java对象的行为或过程，而成员变量则是真正构成对象本身的细胞和血肉。简单的说，就是成员变量占用的空间之和几乎就是对象占用的所有内存空间。
获取成员变量的方法与上面两种方法类似，具体如下：
Field getField(String name)
Field[] getFields()
Field getDeclaredField(String name)
Field[] getDeclaredFields()其中，String name参数，需要写入变量名。关于访问权限和确定性的问题，与前面两例基本一致。
让动态真正动起来
在本文的一开始就说，Java反射机制是Java语言被视为准动态语言的关键性质。如果Java反射仅仅能够得到Java类（或对象）运行时的信息，而不能改变其行为和属性，那么它当然算不上“动态”。百度了一把何谓“动态语言”，解释如下：动态语言，是指程序在运行时可以改变其结构：新的函数可以被引进，已有的函数可以被删除等在结构上的变化。由此看来，Java确实不能算作“动态语言”。但是和C、C++等纯静态语言相比，Java语言允许使用者在运行时加载、探知、使用编译期间完全未知的classes，所以我们说Java是“准动态”语言。
细心地读者可能已经发现，在“类中最重要的三个信息”一节中，我们获取的信息其实都是属于类的，而不是对象。对于类的信息提取，其实并不涉及到对象内存，在程序编译完成的那一刻起，一切都已经是确定的了。因此，它并不能算“动态”。而如何对对象内存进行操作和访问，才是“动”的真正含义。
说了这么多，关键还在于如何利用反射让Java真正动起来。下面我将按照创生、行为与属性三个方面来介绍反射机制是如何让Java动的。
创生
不知是否本性使然，人类偏爱于思索起源与终结的话题。如果将程序类比于一个二进制的世界的话，那么我们程序员则是这个世界的上帝。我们掌控着这个世界的起源和终结，熟悉世界中一草一木的属性和所有生灵的习性。现在就让我们开始创世纪吧！
在 “构造函数”那一小节中，我们列出了获取构造函数的四种方法。这四种方法的返回值不知是否引起了各位的注意，那就是Constructor类。Constructor就类比于女娲吹给泥人的那一口真气，有了它，一个生命才真正出现。
Constructor支持泛型，也就是它本身应该是Constructor。这个类有一个public成员函数，T newInstance(Object... args)，其中args为对应的参数。我们正是通过它来实现创生的过程。
行为
行为践行着生命的意义，而众多事物的行为才得以构成整个世界的运转。尽管道家的老子主张“无为而治”，宣扬“圣人处无为之事，行不言之教”，但那是因为他本身就是 “无”的信仰者（“道”即“无”）。我们是唯物主义的信徒，所以必然要以“有”为价值。那么，在二进制的世界里，我们如何调用Java对象的行为呢？
同样，我们首先回顾“成员函数”小节中四种方法的返回值。对，那就是Method类。此类有一个public成员函数，Object invoke(Object receiver, Object... args)。我们能很好理解此函数的第二个参数args，它代表这个方法所需要接收的参数。也许大家对第一个参数receiver还存在疑惑之处。这得从编程语言的发展历程讲起。
如果你关注几种主流编程语言的起源，那么你能有这样的印象：C从汇编而来，C++从C而来，而Java从C/C++而来。有这样一种印象就足够了。从这样的发展史我们可以看出，C++和Java这两种面向对象的编程语言都是从面向过程的C语言基础上发展而来的。OOP是一种思想，它本身与编程语言无关。也就是说，我们用C也能写出面向对象的程序，这也是C++和Java能够以C为基础的根本所在。然而，C无法实现类似object.method()这种表现形式，因为C语言的结构体中并不支持函数定义。那么我们用C实现OOP的时候，如何调用对象的方法呢？
本质上说，object.method()这种调用方式是为了表明具体method()的调用对象。而invoke(Object receiver, Object... args)的第一个参数正是指明调用对象。在C++中，object.method()其实是有隐含参数的，那就是object对象的指针，method原型的第一个参数其实是this指针，于是原型为method(void* this)。
这样一溯源，也许你更清楚了Object receiver参数的含义，或许更迷糊了？不管怎样，历史就是如此，只不过我个人能力有限，说不清楚而已。
另外需要注意的是，如果某个方法是Java类的静态方法，那么Object receiver参数可以传入null，因为静态方法不从属于对象。
属性
同样是人类，令狐冲和岳不群是如何被区分开的？那是因为他们有着不同的属性。同样，同一个类可以生成多个对象，几个同类型的对象之间如何区分？属性起着决定性的作用。说到这里，想起一个科幻故事。人体瞬移机，作用的根本原理就是人进入A位置，被完全扫描之后，再在B位置重新组成它的细胞、血肉等属性，从而完全创造出另一个一模一样的人。当然，这是唯物主义的极致，它假设了只要一切物质相同，连记忆和灵魂都不会出现偏差，另外还存在伦理的问题，例如A位置的人会被销毁掉吗？
尽管这是一个科幻，但是在程序的世界里，我们早已经用上了这类似幻想的技术。Java中如何远程传递一个对象？我们已经使用上了Java对象序列化的接口。不仅如此，利用序列化接口，我们甚至可以将一个生命保存起来，在需要的时候将它复活，这就是对象的持久化。不得不感慨，在程序的世界里，我们就是上帝啊！
对象序列化如此强大，那么它的本质是什么呢？它的工作原理是怎样的呢？简单的说，对象序列化的本质就是属性的序列化。原理就是我们崇尚的唯物主义，如果同一个类的两个对象所有属性值都完全相同，那么我们可以认为这是同一个对象。
说了这么多，只是想说明一件事情，属性对于对象而言是多么的重要。那么如何读写对象中属性的值呢？回顾获取属性信息的方法返回值类型，那是Field。Field类有两个public方法，分别对应读与写，它们是：
Object get(Object object)
void set(Object object, Object value)object参数需要传入的对象，原理类似于成员方法需要指明对象一样。如果是静态属性，此值同样可以为null。
关于反射的一些高级话题
如果说前面那些属于Java反射的基本知识，那么在文章的最后，我们来探讨一下反射的一些高级话题。另外，本文对基础知识的讲解仅属于抓主干，具体的一些旁支可以自己参看文档。需要提一下的是，Java反射中对数组做过单独的优化处理，具体可查看java.lang.reflect.Array类；还有关于泛型的支持，可查看java.lang.reflect.ParameterizedType及相关资料。
暂时想到的高级话题有三个，由于对Java反射理解的也不算深入，所以仅仅从思路上进行探讨，具体实现上，大家可以参考其他相关资料，做更深入研究。
Android编译期问题
Android的安全权限问题我把它简单的划分成三个层次，最不严格的一层就是仅仅骗过编译器的“@hide”标记。对于一款开源的操作系统而言，这个标记本身并不具备安全上的限制。不过，从上次Google过来的负责Android工程师的说法来看，这个标记的作用更多的是方便硬件厂商做闭源的二次开发。这样解释倒也说得过去。
不过这并不影响我们使用反射机制以绕过原生Android的第一层安全措施。如果你熟悉源码的话，会发现这可以应用到很多地方。并且最关键的是你并不需要放在源码中编译，而是像普通应用程序的开发过程一样。
具体使用范围我不能一一列举了，例如自定义窗口、安装程序等等。简单的说，在Android上使用反射技术，你才会对Android系统有更深的理解和更高的控制权。
软件的解耦合
我们在架构代码的时候，经常提到解耦合、弱耦合。其实，解耦和不仅仅只能在代码上做文章。我们可以考虑这样一种情况：软件的功能需求不可能一开始就完全确定，有一些功能在软件开发的后期甚至是软件已经发布出去之后才想到要加入或者去掉。
按我们惯有的思维，这种情况就得改动源码，重新编译。如果软件已经发布出去，那么就得让客户重新安装一次软件。反思一下，我们是否认为软件和程序是同一回事呢？事实上，如果你能将软件和程序分开来理解，那么你会发现，为了应对以上的情况，我们还有其他的解决办法。
我国有一个很重要但是很麻烦的制度，那就是户籍制度。它的本意是为了更好的管理人口事宜。每当一个孩子出生，我们就需要在户籍管理的地方去给他办理户籍入户；而每当一个人去世，我们也需要在相应的地方销去他的户籍。既然我们可以视类为生命，那么我们能否通过学习这样的户籍管理制度来动态地管理类呢？
事实上这样的管理是可行的，而且Java虚拟机本身正是基于这样的机制来运行程序的。因此我们是否可以这样来架构软件框架。首先，我们的软件有一个配置文件，配置文件其实是一个文本，里面详细描述了，我们的软件核心部分运行起来后还需要从什么路径加载些什么类需要何时调用什么方法等。这样当我们需要加或减某些功能时，我们只需要简单地修改配置文本文件，然后删除或者添加相应的.class文件就可以了。
如果你足够敏感，你或许会发现，这种方式形成的配置文件几乎可以相当于一门脚本语言了。而且这个脚本的解释器也是我们自己写的，另外关键是它是开发的，你可以为它动态地加入一些新的类以增加它的功能。
不要以为这仅仅是一个设想，虽然要开发成一门完备的脚本语言确实比较麻烦。但是在一些网络端的大型项目中，通过配置文件 + ClassLoader + 反射机制结合形成的这种软件解耦和方式已经用得比较普遍了。
所以，在此我不是在提出一种设想，而是在介绍业界处理此类问题的一种解决方案。
反射安全
文章读到这里，我想你应该由衷地感叹，Java反射机制实在是太强大了。但是，如果你有一些安全意识的话，就会发现Java这个机制强大得似乎有些过头了。前面我们提到，Java反射甚至可以访问private方法和属性。为了让大家对Java反射有更全面的了解，树立正确的人生观价值观，本小节将对Java的安全问题做一个概要性的介绍。
相对于C++来说，Java算是比较安全的语言了。这与它们的运行机制有密切的关系，C++运行于本地，也就是说几乎所有程序的权限理论上都是相同的。而Java由于是运行于虚拟机中，而不直接与外部联系，所以实际上Java的运行环境是一个“沙盒”环境。
Java的安全机制其实是比较复杂的，至少对于我来说是如此。作为Java的安全模型，它包括了：字节码验证器、类加载器、安全管理器、访问控制器等一系列的组件。之前文中提到过，我把Android安全权限划分为三个等级：第一级是针对编译期的“@hide”标记；第二级是针对访问权限的private等修饰；第三级则是以安全管理器为托管的Permission机制。
Java反射确实可以访问private的方法和属性，这是绕过第二级安全机制的方法（之一）。它其实是Java本身为了某种目的而留下的类似于“后门”的东西，或者说是为了方便调试？不管如何，它的原理其实是关闭访问安全检查。
如果你具有独立钻研的精神的话，你会发现之前我们提到的Field、Method和Constructor类，它们都有一个共同的父类AccessibleObject 。AccessibleObject 有一个公共方法：void setAccessible(boolean flag)。正是这个方法，让我们可以改变动态的打开或者关闭访问安全检查，从而访问到原本是private的方法或域。另外，访问安全检查是一件比较耗时的操作，关闭它反射的性能也会有较大提升。
不要认为我们绕过了前两级安全机制就沾沾自喜了，因为这两级安全并不是真正为了安全而设置的。它们的作用更多的是为了更好的完善规则。而第三级安全才是真正为了防止恶意攻击而出现的。在这一级的防护下，你甚至可能都无法完成反射（ReflectPermission），其他的一切自然无从说起。
对于这一级，我的了解还太少，并且也与本文的主题相关甚少。以后有机会，深入学习之后再聊吧！
最近在成都写一个移动增值项目，俺负责后台server端。功能很简单，手机用户通过GPRS打开Socket与服务器连接，我则根据用户传过来的数据做出响应。做过类似项目的兄弟一定都知道，首先需要定义一个类似于MSNP的通讯协议，不过今天的话题是如何把这个系统设计得具有高度的扩展性。由于这个项目本身没有进行过较为完善的客户沟通和需求分析，所以以后肯定会有很多功能上的扩展，通讯协议肯定会越来越庞大，而我作为一个不那么勤快的人，当然不想以后再去修改写好的程序，所以这个项目是实践面向对象设计的好机会。
首先定义一个接口来隔离类：
package org.bromon.reflect;
public interface Operator
{
public java.util.List act(java.util.List params)
}
根据设计模式的原理，我们可以为不同的功能编写不同的类，每个类都继承Operator接口，客户端只需要针对Operator接口编程就可以避免很多麻烦。比如这个类：
package org.bromon.reflect.*;
public class Success implements Operator
{
public java.util.List act(java.util.List params)
{
List result=new ArrayList();
result.add(new String(“操作成功”));
return result;
}
}我们还可以写其他很多类，但是有个问题，接口是无法实例化的，我们必须手动控制具体实例化哪个类，这很不爽，如果能够向应用程序传递一个参数，让自己去选择实例化一个类，执行它的act方法，那我们的工作就轻松多了。
很幸运，我使用的是Java，只有Java才提供这样的反射机制，或者说内省机制，可以实现我们的无理要求。编写一个配置文件emp.properties:
#成功响应
1000=Success
#向客户发送普通文本消息
2000=Load
#客户向服务器发送普通文本消息
3000=Store文件中的键名是客户将发给我的消息头，客户发送1000给我，那么我就执行Success类的act方法，类似的如果发送2000给我，那就执行Load类的act方法，这样一来系统就完全符合开闭原则了，如果要添加新的功能，完全不需要修改已有代码，只需要在配置文件中添加对应规则，然后编写新的类，实现act方法就ok，即使我弃这个项目而去，它将来也可以很好的扩展。这样的系统具备了非常良好的扩展性和可插入性。
下面这个例子体现了动态加载的功能，程序在执行过程中才知道应该实例化哪个类：
package org.bromon.reflect.*;
import java.lang.reflect.*;
public class TestReflect
{
//加载配置文件,查询消息头对应的类名
private String loadProtocal(String header)
{
String result=null;
try
{
Properties prop=new Properties();
FileInputStream fis=new FileInputStream("emp.properties");
prop.load(fis);
result=prop.getProperty(header);
fis.close();
}catch(Exception e)
{
System.out.println(e);
}
return result;
}
//针对消息作出响应,利用反射导入对应的类
public String response(String header,String content)
{
String result=null;
String s=null;
try
{
/*
* 导入属性文件emp.properties,查询header所对应的类的名字
* 通过反射机制动态加载匹配的类,所有的类都被Operator接口隔离
* 可以通过修改属性文件、添加新的类(继承MsgOperator接口)来扩展协议
*/
s="org.bromon.reflect."+this.loadProtocal(header);
//加载类
Class c=Class.forName(s);
//创建类的事例
Operator mo=(Operator)c.newInstance();
//构造参数列表
Class params[]=new Class[1];
params[0]=Class.forName("java.util.List");
//查询act方法
Method m=c.getMethod("act",params);
Object args[]=new Object[1];
args[0]=content;
//调用方法并且获得返回
Object returnObject=m.invoke(mo,args);
}catch(Exception e)
{
System.out.println("Handler-response:"+e);
}
return result;
}
public static void main(String args[])
{
TestReflect tr=new TestReflect();
tr.response(args[0],”消息内容”);
}
}本文出自seven的测试人生公众号最新内容请见作者的GitHub页：http://qaseven.github.io/
