java反射机制的实现原理

Posted 2023-04-18

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了java反射机制的实现原理相关的知识，希望对你有一定的参考价值。

反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。下面具体介绍一下java的反射机制。这里你将颠覆原来对java的理解。
Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class代表的时类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组成部分。

Class：程序运行时，java运行时系统会对所有的对象进行运行时类型的处理。这项信息记录了每个对象所属的类，虚拟机通常使用运行时类型信息选择正确的方法来执行（摘自：白皮书）。但是这些信息我们怎么得到啊，就要借助于class类对象了啊。在Object类中定义了getClass()方法。我们可以通过这个方法获得指定对象的类对象。然后我们通过分析这个对象就可以得到我们要的信息了。

比如：ArrayList arrayList;

Class clazz = arrayList.getClass();

然后我来处理这个对象clazz。

当然了Class类具有很多的方法，这里重点将和Constructor，Field，Method类有关系的方法。

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是个人认为要想对java有个更加深入的了解还是应该掌握的。

1．检测类：

reflection的工作机制

考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

import java.lang.reflect.*;

public class DumpMethods

public static void main(String args[])

try

Class c = Class.forName(args[0]);

Method m[] = c.getDeclaredMethods();

for (int i = 0; i < m.length; i++)

System.out.println(m[i].toString());

catch (Throwable e)

System.err.println(e);

按如下语句执行：

java DumpMethods java.util.ArrayList

这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

Java类反射中的主要方法

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

用于获得方法信息函数：

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

使用 Reflection：

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Intege ) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

处理对象：

a.创建一个Class对象

b.通过getField 创建一个Field对象

c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：

import java.lang.reflect.*;

import java.awt.*;

class SampleGet

public static void main(String[] args)

Rectangle r = new Rectangle(100, 325);

printHeight(r);

static void printHeight(Rectangle r)

Field heightField;

Integer heightValue;

Class c = r.getClass();

try

heightField = c.getField("height");

heightValue = (Integer) heightField.get(r);

System.out.println("Height: " + heightValue.toString());

catch (NoSuchFieldException e)

System.out.println(e);

catch (SecurityException e)

System.out.println(e);

catch (IllegalAccessException e)

System.out.println(e);

安全性和反射：

在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。

由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制：

从任意位置到类公共组件的接入

类自身外部无任何到私有组件的接入

受保护和打包（缺省接入）组件的有限接入

不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类 java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可，安全性管理器抛出一个例外。

下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：

public class ReflectSecurity

public static void main(String[] args)

try

TwoString ts = new TwoString("a", "b");

Field field = clas.getDeclaredField("m_s1");

// field.setAccessible(true);

System.out.println("Retrieved value is " +

field.get(inst));

catch (Exception ex)

ex.printStackTrace(System.out);

如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释 field.setAccessible(true)代码行，那么重新编译并重新运行该代码，它将编译成功。最后，如果我们在命令行添加了JVM参数 -Djava.security.manager以实现安全性管理器，它仍然将不能通过编译，除非我们定义了ReflectSecurity类的许可权限。

反射性能：（转录别人的啊）

反射是一种强大的工具，但也存在一些不足。一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

下面的程序是字段接入性能测试的一个例子，包括基本的测试方法。每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作，accessOther 使用可直接接入的另一对象的字段，accessReflection 使用可通过反射接入的另一对象的字段。在每种情况下，方法执行相同的计算 -- 循环中简单的加/乘顺序。

程序如下：

public int accessSame(int loops)

m_value = 0;

for (int index = 0; index < loops; index++)

m_value = (m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

return m_value;

public int acces

sReference(int loops)

TimingClass timing = new TimingClass();

for (int index = 0; index < loops; index++)

timing.m_value = (timing.m_value + ADDITIVE_VALUE) *

MULTIPLIER_VALUE;

return timing.m_value;

public int accessReflection(int loops) throws Exception

TimingClass timing = new TimingClass();

try

Field field = TimingClass.class.

getDeclaredField("m_value");

for (int index = 0; index < loops; index++)

int value = (field.getInt(timing) +

ADDITIVE_VALUE) * MULTIPLIER_VALUE;

field.setInt(timing, value);

return timing.m_value;

catch (Exception ex)

System.out.println("Error using reflection");

throw ex;

在上面的例子中，测试程序重复调用每种方法，使用一个大循环数，从而平均多次调用的时间衡量结果。平均值中不包括每种方法第一次调用的时间，因此初始化时间不是结果中的一个因素。下面的图清楚的向我们展示了每种方法字段接入的时间：

图 1：字段接入时间：

我们可以看出：在前两副图中(Sun JVM)，使用反射的执行时间超过使用直接接入的1000倍以上。通过比较，IBM JVM可能稍好一些，但反射方法仍旧需要比其它方法长700倍以上的时间。任何JVM上其它两种方法之间时间方面无任何显著差异，但IBM JVM几乎比Sun JVM快一倍。最有可能的是这种差异反映了Sun Hot Spot JVM的专业优化，它在简单基准方面表现得很糟糕。反射性能是Sun开发1.4 JVM时关注的一个方面，它在反射方法调用结果中显示。在这类操作的性能方面，Sun 1.4.1 JVM显示了比1.3.1版本很大的改进。

如果为为创建使用反射的对象编写了类似的计时测试程序，我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。使用newInstance()调用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的两部。使用Array.newInstance(type, size)创建一个数组耗用的时间是任何测试的JVM上使用new type[size]的两倍，随着数组大小的增加，差异逐步缩小。随着jdk6.0的推出，反射机制的性能也有了很大的提升。期待中….

总结：

Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方 ——记录其在目标类中的使用。

一下是对应各个部分的例子：

具体的应用：

1、模仿instanceof 运算符号

class A

public class instance1

public static void main(String args[])

try

Class cls = Class.forName("A");

boolean b1

= cls.isInstance(new Integer(37));

System.out.println(b1);

boolean b2 = cls.isInstance(new A());

System.out.println(b2);

catch (Throwable e)

System.err.println(e);

2、在类中寻找指定的方法，同时获取该方法的参数列表，例外和返回值

import java.lang.reflect.*;

public class method1

private int f1(

Object p, int x) throws NullPointerException

if (p == null)

throw new NullPointerException();

return x;

public static void main(String args[])

try

Class cls = Class.forName("method1");

Method methlist[]

= cls.getDeclaredMethods();

for (int i = 0; i < methlist.length;

i++)

Method m = methlist[i];

System.out.println("name

= " + m.getName());

System.out.println("decl class = " +

m.getDeclaringClass());

Class pvec[] = m.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("

param #" + j + " " + pvec[j]);

Class evec[] = m.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println("exc #" + j

+ " " + evec[j]);

System.out.println("return type = " +

m.getReturnType());

System.out.println("-----");

catch (Throwable e)

System.err.println(e);

3、获取类的构造函数信息，基本上与获取方法的方式相同

import java.lang.reflect.*;

public class constructor1

public constructor1()

protected constructor1(int i, double d)

public static void main(String args[])

try

Class cls = Class.forName("constructor1");

Constructor ctorlist[]

= cls.getDeclaredConstructors();

for (int i = 0; i < ctorlist.length; i++)

Constructor ct = ctorlist[i];

System.out.println("name

= " + ct.getName());

System.out.println("decl class = " +

ct.getDeclaringClass());

Class pvec[] = ct.getParameterTypes();

for (int j = 0; j < pvec.length; j++)

System.out.println("param #"

+ j + " " + pvec[j]);

Class evec[] = ct.getExceptionTypes();

for (int j = 0; j < evec.length; j++)

System.out.println(

"exc #" + j + " " + evec[j]);

System.out.println("-----");

catch (Throwable e)

System.err.println(e);

4、获取类中的各个数据成员对象，包括名称。类型和访问修饰符号

import java.lang.reflect.*;

public class field1

private double d;

public static final int i = 37;

String s = "testing";

public static void main(String args[])

try

Class cls = Class.forName("field1");

Field fieldlist[]

= cls.getDeclaredFields();

for (int i

= 0; i < fieldlist.length; i++)

Field fld = fieldlist[i];

System.out.println("name

= " + fld.getName());

System.out.println("decl class = " +

fld.getDeclaringClass());

System.out.println("type

= " + fld.getType());

int mod = fld.getModifiers();

System.out.println("modifiers = " +

Modifier.toString(mod));

System.out.println("-----");

catch (Throwable e)

System.err.println(e);

5、通过使用方法的名字调用方法

import java.lang.reflect.*;

public class method2

public int add(int a, int b)

return a + b;

public static void main(String args[])

try

Class cls = Class.forName("method2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Method meth = cls.getMethod(

"add", partypes);

method2 methobj = new method2();

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj

= meth.invoke(methobj, arglist);

Integer retval = (Integer)retobj;

System.out.println(retval.intValue());

catch (Throwable e)

System.err.println(e);

6、创建新的对象

import java.lang.reflect.*;

public class constructor2

public constructor2()

public constructor2(int a, int b)

System.out.println(

"a = " + a + " b = " + b);

public static void main(String args[])

try

Class cls = Class.forName("constructor2");

Class partypes[] = new Class[2];

partypes[0] = Integer.TYPE;

partypes[1] = Integer.TYPE;

Constructor ct

= cls.getConstructor(partypes);

Object arglist[] = new Object[2];

arglist[0] = new Integer(37);

arglist[1] = new Integer(47);

Object retobj = ct.newInstance(arglist);

catch (Throwable e)

System.err.println(e);

7、变更类实例中的数据的值

import java.lang.reflect.*;

public class field2

public double d;

public static void main(String args[])

try

Class cls = Class.forName("field2");

Field fld = cls.getField("d");

field2 f2obj = new field2();

System.out.println("d = " + f2obj.d);

fld.setDouble(f2obj, 12.34);

System.out.println("d = " + f2obj.d);

catch (Throwable e)

System.err.println(e);

使用反射创建可重用代码：

1、对象工厂

Object factory(String p)

Class c;

Object o=null;

try

c = Class.forName(p);// get class def

o = c.newInstance(); // make a new one

catch (Exception e)

System.err.println("Can't make a " + p);

return o;

public class ObjectFoundry

public static Object factory(String p)

throws ClassNotFoundException,

InstantiationException,

IllegalAccessException

Class c = Class.forName(p);

Object o = c.newInstance();

return o;

2、动态检测对象的身份，替代instanceof

public static boolean

isKindOf(Object obj, String type)

throws ClassNotFoundException

// get the class def for obj and type

Class c = obj.getClass();

Class tClass = Class.forName(type);

while ( c!=null )

if ( c==tClass ) return true;

c = c.getSuperclass();

return false;

参考资料：http://www.114java.com/JAVApeixunbiji/2009/0812/546.html

参考技术A 反射机制就是java语言在运行时拥有一项自观的能力。
通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。
下面具体介绍一下java的反射机制。这里你将颠覆原来对java的理解。
Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；
其中class代表的时类对象，
Constructor－类的构造器对象，
Field－类的属性对象，
Method－类的方法对象。
通过这四个对象我们可以粗略的看到一个类的各个组成部分。
Class：程序运行时，java运行时系统会对所有的对象进行运行时类型的处理。
这项信息记录了每个对象所属的类，虚拟机通常使用运行时类型信息选择正确的方法来执行（摘自：白皮书）。
但是这些信息我们怎么得到啊，就要借助于class类对象了啊。
在Object类中定义了getClass()方法。我们可以通过这个方法获得指定对象的类对象。然后我们通过分析这个对象就可以得到我们要的信息了。
比如：ArrayList arrayList;
Class clazz = arrayList.getClass();
然后我来处理这个对象clazz。
当然了Class类具有很多的方法，这里重点将和Constructor，Field，Method类有关系的方法。
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是个人认为要想对java有个更加深入的了解还是应该掌握的。
reflection的工作机制
考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。
import java.lang.reflect.*;
public class DumpMethods
public static void main(String args[])
try
//forName("java.lang.String")获取指定的类的对象
Class c = Class.forName("java.lang.String");
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m[i].toString());
catch (Throwable e)
System.err.println(e);

按如下语句执行：
java DumpMethods java.util.ArrayList
这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。
Java类反射中的主要方法
对于以下三类组件中的任何一类来说
-- 构造函数、字段和方法
-- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：
Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，
Constructor[] getConstructors() -- 获得类的所有公共构造函数
Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)
Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)
获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：
Field getField(String name) -- 获得命名的公共字段
Field[] getFields() -- 获得类的所有公共字段
Field getDeclaredField(String name) -- 获得类声明的命名的字段
Field[] getDeclaredFields() -- 获得类声明的所有字段
用于获得方法信息函数：
Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法
Method[] getMethods() -- 获得类的所有公共方法
Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法
Method[] getDeclaredMethods() -- 获得类声明的所有方法
使用 Reflection：
用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：
第一步是获得你想操作的类的 java.lang.Class 对象。
在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。
下面就是获得一个 Class 对象的方法之一：
Class c = Class.forName("java.lang.String");
这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：
Class c = int.class;
或者
Class c = Integer.TYPE;
它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Intege ) 中预先定义好的 TYPE 字段。
第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。
一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：
Class c = Class.forName("java.lang.String");
Method m[] = c.getDeclaredMethods();
System.out.println(m[0].toString());
它将以文本方式打印出 String 中定义的第一个方法的原型。
处理对象：
a.创建一个Class对象
b.通过getField 创建一个Field对象
c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).
例如：
import java.lang.reflect.*;
import java.awt.*;
class SampleGet
public static void main(String[] args) throws Exception
Rectangle r = new Rectangle(100, 325);
printHeight(r);
printWidth( r);

static void printHeight(Rectangle r)throws Exception
//Field属性名
Field heightField;
//Integer属性值
Integer heightValue;
//创建一个Class对象
Class c = r.getClass();
//.通过getField 创建一个Field对象
heightField = c.getField("height");
//调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).
heightValue = (Integer) heightField.get(r);
System.out.println("Height: " + heightValue.toString());

static void printWidth(Rectangle r) throws Exception
Field widthField;
Integer widthValue;
Class c = r.getClass();

widthField = c.getField("width");
widthValue = (Integer) widthField.get(r);
System.out.println("Height: " + widthValue.toString());

参考技术B 反射就是拿面镜子自己照自己自己有的东西通过镜子可以全部显示出来参考技术C Java中的反射机制主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。
反射是Java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以再运行时装配，无需在组件之间进行源代码链接。

深入理解java的反射机制

今天将从以下4方面来系统的学习一下java的反射机制：

java反射是什么
java反射(Reflection)底层实现原理
java反射的简单演示
java反射的应用场景

1，java反射是什么

首先大家应该先了解两个概念，编译期和运行期，编译期就是编译器帮你把源代码翻译成机器能识别的代码，比如编译器把java代码编译成jvm识别的字节码文件，而运行期指的是将可执行文件交给操作系统去执行，JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制

2，java反射(Reflection)的底层实现原理

众所周知Java有个Object 类，是所有Java 类的继承根源，其内声明了数个应该在所有Java 类中被改写的方法：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class 对象

而这个Class 类十分特殊。它和一般类一样继承自Object，当一个class被加载，或当加载器（class loader）的defineClass()被JVM调用，JVM 便自动产生一个Class 对象。

而Class对象是java反射故事起源。Class类提供了大量的实例方法来获取该Class对象所对应的详细信息,我们只是做简单的介绍,详细请参考JDK文档，这边提供一个在线的中文文档给大家如下：

http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

这边列了下Class类其中的很少yibufen方法,

获取公共构造器 getConstructors()
获取所有构造器 getDeclaredConstructors
获取包含的方法 getMethod()
获取包含的属性 getField(String name)
获取内部类 getDeclaredClasses()
获取外部类 getDeclaringClass()
获取所实现的接口 getInterfaces()
获取修饰符 getModifiers()
获取所在包 getPackage()
获取类名包含包路径 getName()
类名不包含包路径 getSimpleName()

3，java反射的简单演示

上面介绍了下java反射的实现机制，接下来我主要来演示一下反射的使用

首先定义一个user对象类如下：

/**
 * 定义一个用户对象
 *
 * @author zhangqh
 * @date 2018年4月24日
 */
public class User implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    /**
     * 用户id
     */
    private Integer userId;
    /**
     * 用户名称
     */
    private String userName;

    /**
     * 公共元素
     */
    public String age;

    private User(Integer userId){}

    public User(){}
    public User(Integer userId, String userName) {
        super();
        this.userId = userId;
        this.userName = userName;
    }
    /**
     * @return the userId
     */
    public Integer getUserId() {
        return userId;
    }
    /**
     * @param userId the userId to set
     */
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    /**
     * @return the userName
     */
    public String getUserName() {
        return userName;
    }
    /**
     * @param userName the userName to set
     */
    public void setUserName(String userName) {
        this.userName = userName;
    }

}

测试反射类：

/**
 * 测试反射类
 *
 * @author zhangqh
 * @date 2018年4月25日
 */
public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        // 第一种方法 直接通过类名获取class (一般不会这么用，因为实例都获取到了没必要多此一举)
        User user = new User();
        Class class1 = user.getClass();
        System.out.println("我是方法1反射处理的类 = "+class1);
        System.out.println("我是方法1反射处理的类的父类 = "+class1.getSuperclass());
        System.out.println("----------------------------------------------------");
        // 第二种办法通过类名的方法获取class 需要增加对应的类引用
        Class class2 = User.class;
        System.out.println("我是方法2反射处理的类 = "+class2);
        System.out.println("我是方法2反射处理的类的父类 = "+class2.getSuperclass());
        System.out.println("----------------------------------------------------");
        // 第三种办法通过全类名获取，用的比较多，也推荐使用这种方式
        Class class3 = Class.forName ("com.zhang.reflection.User");
        System.out.println("我是方法3反射处理的类 = "+class3);
        System.out.println("我是方法3反射处理的类的父类 = "+class3.getSuperclass());
        System.out.println("----------------------------------------------------");
        // 反射获取User对象的公共构造器
        Constructor<User>[] constructors = class3.getConstructors();
        for(int i=0;i<constructors.length;i++){
            System.out.println("我是公共构造器"+(i+1)+" = "+constructors[i]);
        }
        System.out.println("----------------------------------------------------");
        //反射获取User对象的所有构造器
        Constructor<User>[] dconstructors = class3.getDeclaredConstructors();
        for(int i=0;i<dconstructors.length;i++){
            System.out.println("我是所有构造器"+(i+1)+" = "+dconstructors[i]);
        }
        System.out.println("----------------------------------------------------");
        // 反射获取User对象的 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法
        Method[]  methods = class3.getMethods();
        for(int i=0;i<methods.length;i++){
            System.out.println("我是公共方法"+(i+1)+" = "+methods[i]);
        }
        System.out.println("----------------------------------------------------");
        // 反射获取User对象的 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法
        Method[]  dmethods = class3.getDeclaredMethods();
        for(int i=0;i<dmethods.length;i++){
            System.out.println("我是所有的方法"+(i+1)+" = "+dmethods[i]);
        }
        System.out.println("----------------------------------------------------");
        // 获取包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段
        Field[] fields = class3.getFields();
        for(int i=0;i<fields.length;i++){
            System.out.println("我是公共的field"+(i+1)+" = "+fields[i]);
        }
        System.out.println("----------------------------------------------------");
        Field[] dfields = class3.getDeclaredFields();
        for(int i=0;i<dfields.length;i++){
            System.out.println("我是所有的field"+(i+1)+" = "+dfields[i]);
        }
        System.out.println("----------------------------------------------------");
        String sname = class3.getSimpleName();
        System.out.println("我是类名不包含包路径 = "+sname);
        System.out.println("----------------------------------------------------");
        String name = class3.getName();
        System.out.println("我是类名包含包路径 = "+name);
        System.out.println("----------------------------------------------------");
        Package packA=class3.getPackage();
        System.out.println("我是类的包路径 = "+packA.getName());
        System.out.println("----------------------------------------------------");
        Class<?>[] interfaces=class3.getInterfaces();
        for(int i=0;i<interfaces.length;i++){
            System.out.println("我是实现的接口"+(i+1)+" = "+interfaces[i]);
        }
        System.out.println("----------------------------------------------------");
        // 返回此类或接口以整数编码的 Java 语言修饰符。修饰符由 Java 虚拟机的 public、 protected、 private、 final、 static、 abstract 和 interface 对应的常量组成；
        // 它们应当使用 Modifier 类的方法来解码
        Integer modefiers = class3.getModifiers();
        System.out.println("我是类的modefiers = "+modefiers);
    }
}

以上代码中有详细的代码注释，这边就不过多的解释了

4，java反射的应用场景

a，注解的使用

不知道大家是否有看过之前写的深入理解java注解的实现原理它的底层实现就是java反射，主要有如下方法：

getAnnotations()
getAnnotation(Class annotationClass)
getDeclaredAnnotations()
isAnnotation()
isAnnotationPresent(Class annotationClass)

b，编写基础框架

有一句话这么说来着：反射机制是很多Java框架的基石，经典的就是在xml文件或者properties里面写好了配置，然后在Java类里面解析xml或properties里面的内容，得到一个字符串，然后用反射机制，根据这个字符串获得某个类的Class实例，这样就可以动态配置一些东西，spring，Hibernate底层都有类似的实现

c，其他在编码阶段不知道那个类名,要在运行期从配置文件读取类名配置

如下：这段代码想必大家肯定都有写过，这个数据库的连接驱动类就是编译的时候不知道你到底是用的mysql，oracle还是其他数据库，而是由运行期动态加载的

// 1.加载驱动程序
        Class.forName("com.mysql.jdbc.Driver");
        // 2.获得数据库的连接
        Connection conn = DriverManager.getConnection(URL, NAME, PASSWORD);
        // 3.通过数据库的连接操作数据库，实现增删改查
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt
                .executeQuery("select user_name,age from user");
        while (rs.next()) {// 如果对象中有数据，就会循环打印出来
            System.out.println(rs.getString("user_name") + ","
                    + rs.getInt("age"));
        }

注：以上介绍了反射的应用场景，程序猿开发业务代码中应尽量少用反射，一个是代码可读性不是特别好，第二是反射需要运行期jvm去重新解析性能上也没有直接使用好，唯一比较合理的地方是业务中需要用到AOP可以大大简化业务代码建议使用

以上是今天文章的所有内容，欢迎大家吐槽

如果觉得文章对你有帮助，欢迎转发或关注如下公众号阅读更多优质文章

技术分享图片

以上是关于java反射机制的实现原理的主要内容，如果未能解决你的问题，请参考以下文章

反射机制在java中如何做呀？

请问java中的反射机制与用法

java 中反射机制和内省机制的区别是啥？

如何利用java的反射机制动态创建对象

Dubbo的底层实现原理和机制

java反射和动态代理有啥关系