Java反射机制

一、什么是反射机制  
    简单的来说，反射机制指的是程序在运行时能够获取自身的信息。运行时根据类名获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。

Java 反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类。

在运行时构造任意一个类的对象。

在运行时判断任意一个类所具有的成员变量和方法。

在运行时调用任意一个对象的方法。

二、哪里用到反射机制 

jdbc加载第三方类库的时候：Class.forName("com.mysql.jdbc.Driver.class").newInstance();

三、反射机制的优点与缺点

 为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，  
    静态编译：在编译时确定类型，绑定对象,即通过。  
    动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。

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

在JDK中，主要有下面几个类来实现JAVA的反射机制，这些类都位于java.lang.reflect包中：

– Class类：代表一个类。 – Field 类：代表类的成员变量（成员变量也称为类的属性）。 – Method类：代表类的方法。 – Constructor 类：代表类的构造方法。 – Array类：提供了动态创建数组，以及访问数组的元素的静态方法

五、用反射机制能干什么事  
     刚开始在使用jdbc时侯，在编写访问数据库时写到想吐，有八个表，每个表都有增删改查中操作  那时候还不知道有反射机制这个概念，所以就对不同的表创建不同的dao类,这样不仅开发速率地，而且代码  冗余的厉害，最要命的是看着差不多的，然后直接复制修改，由于容易犯各种低级的错误（大小写啊，多一  个或少一个字母啊……）,一个错误就可以让你找半天。  
      有了java反射机制，什么都好办了，只需要写一个dao类，四个方法，增删改查，传入不同的对象，就OK啦，  无需为每一个表都创建dao类，反射机制会自动帮我们完成剩下的事情，这就是它的好处。说白了，反射机制就是专门帮我们做那些重复的有规则的事情，所以现在很多的自动生成代码的软件就是运用反射机制来完成的，只要你按照规则输入相关的参数，所以低级的程序员慢慢的就被抹杀了，为什么？因为代码都不用写了，随便一个人都会开发，还要程序员干什么啊？所以我们只有一条出路，那就是努力努力再努力，成为高级程序员，专门开发傻瓜软件，让其他程序员  到 一边凉快去，呵呵~

什么是反射？反射有什么用处？

1. 什么是反射？

“反射（Reflection）能够让运行于JVM中的程序检测和修改运行时的行为。”这个概念常常会和内省（Introspection）混淆，以下是这两个术语在Wikipedia中的解释：

1. 内省用于在运行时检测某个对象的类型和其包含的属性；

2. 反射用于在运行时检测和修改某个对象的结构及其行为。

从它们的定义可以看出，内省是反射的一个子集。有些语言支持内省，但并不支持反射，如C++。

内省示例：instanceof 运算符用于检测某个对象是否属于特定的类。

1 2 3 4

if (obj instanceof Dog) { Dog d = (Dog) obj; d.bark(); }

反射示例：Class.forName()方法可以通过类或接口的名称（一个字符串或完全限定名）来获取对应的Class对象。forName方法会触发类的初始化。

1 2 3 4 5

// 使用反射 Class<?> c = Class.forName( "classpath.and.classname" ); Object dog = c.newInstance(); Method m = c.getDeclaredMethod( "bark" , new Class<?>[ 0 ]); m.invoke(dog);

在Java中，反射更接近于内省，因为你无法改变一个对象的结构。虽然一些API可以用来修改方法和属性的可见性，但并不能修改结构。

2. 我们为何需要反射？

反射能够让我们：

• 在运行时检测对象的类型；

• 动态构造某个类的对象；

• 检测类的属性和方法；

• 任意调用对象的方法；

• 修改构造函数、方法、属性的可见性；

• 以及其他。

反射是框架中常用的方法。

例如，JUnit通过反射来遍历包含 @Test 注解的方法，并在运行单元测试时调用它们。（这个连接中包含了一些JUnit的使用案例）

对于Web框架，开发人员在配置文件中定义他们对各种接口和类的实现。通过反射机制，框架能够快速地动态初始化所需要的类。

例如，Spring框架使用如下的配置文件：

1 2 3

< bean id = "someID" class = "com.programcreek.Foo" > < property name = "someField" value = "someValue" /> </ bean >

当Spring容器处理<bean>元素时，会使用Class.forName("com.programcreek.Foo")来初始化这个类，并再次使用反射获取<property>元素对应的setter方法，为对象的属性赋值。

Servlet也会使用相同的机制：

1 2 3 4

< servlet > < servlet-name >someServlet</ servlet-name > < servlet-class >com.programcreek.WhyReflectionServlet</ servlet-class > < servlet >

3. 如何使用反射？

让我们通过几个典型的案例来学习如何使用反射。

示例1：获取对象的类型名称。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

package myreflection; import java.lang.reflect.Method; public class ReflectionHelloWorld { public static void main(String[] args){ Foo f = new Foo(); System.out.println(f.getClass().getName()); } } class Foo { public void print() { System.out.println( "abc" ); } }

输出：

1	myreflection.Foo

示例2：调用未知对象的方法。

在下列代码中，设想对象的类型是未知的。通过反射，我们可以判断它是否包含print方法，并调用它。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

package myreflection; import java.lang.reflect.Method; public class ReflectionHelloWorld { public static void main(String[] args){ Foo f = new Foo(); Method method; try { method = f.getClass().getMethod( "print" , new Class<?>[ 0 ]); method.invoke(f); } catch (Exception e) { e.printStackTrace(); } } } class Foo { public void print() { System.out.println( "abc" ); } }

输出：

1

abc

示例3：创建对象

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

package myreflection; public class ReflectionHelloWorld { public static void main(String[] args){ // 创建Class实例 Class<?> c = null ; try { c=Class.forName( "myreflection.Foo" ); } catch (Exception e){ e.printStackTrace(); } // 创建Foo实例 Foo f = null ; try { f = (Foo) c.newInstance(); } catch (Exception e) { e.printStackTrace(); } f.print(); } } class Foo { public void print() { System.out.println( "abc" ); } }

示例4：获取构造函数，并创建对象。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

package myreflection; import java.lang.reflect.Constructor; public class ReflectionHelloWorld { public static void main(String[] args){ // 创建Class实例 Class<?> c = null ; try { c=Class.forName( "myreflection.Foo" ); } catch (Exception e){ e.printStackTrace(); } // 创建Foo实例 Foo f1 = null ; Foo f2 = null ; // 获取所有的构造函数 Constructor<?> cons[] = c.getConstructors(); try { f1 = (Foo) cons[ 0 ].newInstance(); f2 = (Foo) cons[ 1 ].newInstance( "abc" ); } catch (Exception e) { e.printStackTrace(); } f1.print(); f2.print(); } } class Foo { String s; public Foo(){} public Foo(String s){ this .s=s; } public void print() { System.out.println(s); } }

输出：

1 2

null abc

此外，你可以通过Class实例来获取该类实现的接口、父类、声明的属性等。

示例5：通过反射来修改数组的大小。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

package myreflection; import java.lang.reflect.Array; public class ReflectionHelloWorld { public static void main(String[] args) { int [] intArray = { 1 , 2 , 3 , 4 , 5 }; int [] newIntArray = ( int []) changeArraySize(intArray, 10 ); print(newIntArray); String[] atr = { "a" , "b" , "c" , "d" , "e" }; String[] str1 = (String[]) changeArraySize(atr, 10 ); print(str1); } // 修改数组的大小 public static Object changeArraySize(Object obj, int len) { Class<?> arr = obj.getClass().getComponentType(); Object newArray = Array.newInstance(arr, len); // 复制数组 int co = Array.getLength(obj); System.arraycopy(obj, 0 , newArray, 0 , co); return newArray; } // 打印 public static void print(Object obj) { Class<?> c = obj.getClass(); if (!c.isArray()) { return ; } System.out.println( "\nArray length: " + Array.getLength(obj)); for ( int i = 0 ; i < Array.getLength(obj); i++) { System.out.print(Array.get(obj, i) + " " ); } } }

输出：

1 2 3 4

Array length: 10 1 2 3 4 5 0 0 0 0 0 Array length: 10 a b c d e null null null null null