java反射

初识反射，反射有什么用？

举几个例子：

• 我们使用的开发IDE，在初始化一个对象后，通过点的方式，IDE就能提示到我们有哪写方法，变量能使用。
• 在使用各种框架时，比如spring，他的AOP功能，就是通过读取配置文件中java类的命名空间，反射实现的。
• 数据库JDBC中通过Class.forName(Driver).来获得数据库连接驱动

嗯，上边这些都是反射实现的，就效果而言，反射功能感觉很强大，java给提供这个功能，在框架、工具的地方非常常见。

反射就是这样一种能力：
能让代码在运行期，获取类的信息（包括方法，变量，注解等类信息）。api上是使用类的Class类获取实现的，如下图示例

package com.lxqn.jiapeng.reflect;

import java.lang.reflect.Method;

public class Test {
    private int sum = 1;
    private void function(){
    }

    public static void main(String[] args) throws Exception{
        Class clazz = Class.forName("com.lxqn.jiapeng.reflect.Test");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods){
            System.out.println(method.getName());
        }
    }
}

运行时获取类的方法名信息

如何实现反射？

反射这么吊，实现的细节时怎样的昵。
肯定绕不开Class类，Class类是实现反射的基础。

Class类概念讲解

首先，Class是一个java类，跟Java API中定义的诸如Thread、Integer类、我们自己定义的类是一样，也继承了Object（Class是Object的直接子类）。总之，必须明确一点，它其实只是个类，只不过名字比较特殊。更进一步说，Class是一个java中的泛型类型。

• JVM在类加载后，会生成类的字节码文件，同时会生成一个同名Class类文件。这个类文件存放这在jvm的方法区。
• Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。
• 虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。
• Class 没有公共构造方法，只有个private修饰的构造方法。Class 对象是在加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。
• 基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。

如何获取类的Class对象

有三种方式：

1. 使用对象的getClass方法。
2. 使用Class类的静态方法forName，入参必须是类的包名全称。
3. 如果T是一个Java类型，那么T.class就代表了匹配的Class类对象。
   比如：
   Class cl1 = Test.class;
   Class cl2 = int.class;//基本类型

public class Test {

    public static void main(String[] args) throws Exception{

        //1.使用对象的getClass方法
        Test test = new Test();
        Class clazz1 = test.getClass();
        //2.使用Class类的静态方法forName
        Class clazz2 = Class.forName("com.lxqn.jiapeng.reflect.Test");
        //3.如果T是一个Java类型，那么T.class就代表了匹配的类对象
        Class clazz3  = Test.class;
        Method[] methods = clazz1.getDeclaredMethods();
        for (Method method : methods){
            System.out.println(method.getName());
        }
    }
}

Class类一些api方法使用

1. getName()
   方法以 String 的形式返回此 Class 对象所表示的实体名称。
2. newInstance()
   方法可以为类创建一个实例，这个方法叫做newInstance()。
   跟new关键字达到一样的功效，但是原理不一样，下边会单独比较下，以及这个方法的使用场景好处。newInstance()方法调用默认构造器（无参数构造器）初始化新建对象。
3. getClassLoader()
   返回该类的类加载器。
4. forName
   获取类Class对象的一种方法。
5. getConstructors
   获取构造方法
6. getDeclaredField
   获取成员变量
7. getDeclaredMethods
   获取方法
   这个例子写的很全，可以看下

new关键字和Class类的newInstance()方法区别

• new是jvm提供的一个关键字，new一个对象需要2步：加载类、并且实例化。看下new代码的字节码文件。（使用javap指令）

javap -c TestnewInstance

image.png

public static void main(java.lang.String[])   throws java.lang.Exception;
  Code:
   0:   new #2; //class com/lxqn/jiapeng/reflect/Testnew
   3:   dup
   4:   invokespecial   #3; //Method "<init>":()V
   7:   astore_1
   8:   aload_1
   9:   invokespecial   #4; //Method test:()V
   12:  return
}

加载类，实例化，调用构造函数。

• newInstance()方法使用，则需要先声明一个类，然后获取这个类的无参构造方法，之后调用构造方法来创建对象。是java反射包提供的功能。
  一般配合forName方法使用。这是因为，先看下forName的注释说明。

forName是Class类提供的静态方法，这个方法提供两种入参。

public static Class<?> forName(String className)
public static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)

其中第一个参数是类的包名路径全称。
initialize表示类是否已经初始化。
loader是初始化的类加载器。
可以看出来，第一个方法，默认initialize=true，classLoader使用当前类加载器。

所以Class.forName(className)可以简单的理解为：获得字符串参数中指定的类，并初始化该类。

所以回归到上边newInstance的方法，看下它的字节码文件。

image.png

public static void main(java.lang.String[])   throws java.lang.Exception;
  Code:
   0:   ldc #2; //String com.lxqn.jiapeng.reflect.TestnewInstance
   2:   invokestatic    #3; //Method java/lang/Class.forName:(Ljava/lang/String;)Ljava/lang/Class;
   5:   invokevirtual   #4; //Method java/lang/Class.newInstance:()Ljava/lang/Object;
   8:   checkcast   #5; //class com/lxqn/jiapeng/reflect/TestnewInstance
   11:  astore_1
   12:  aload_1
   13:  invokespecial   #6; //Method test:()V
   16:  return
}

可以看出来关键步骤就是，调用Class的forName静态方法。
利用反射调用newInstance方法。这些的前提就是类已经被初始化

反射的应用

文章最开头就提到了好处，应用。
中间温习了下原理点。最后还是想说明下，框架里边基本都会使用反射，带来好处的俩个点。

1. Class.forName("类包名字符串").newInstance()，这个功能上跟new关键字一样，但是在框架灵活性，伸缩性软件设计上，却带来了好处。
   比如
   还是那个db的jdbc，如果有一天，原来的oracle要换成mysql。
   如果是new的话，要把代码中所有的new oracle()换成new mysql()；然后重现编译下。才能生效。
   而使用反射就可以，把代码写成：

String className = "从配置文件读取Db的具体实现类的类名"; 
Db db= (Db) Class.forName(className).newInstance();

Db是数据库实现类的接口。
这样就可以达到不用重新编译代码的，实现加载切换。

2. 使用反射，可以获取类的注解信息，方法，构造函数，成员变量等信息。在运行时，得到他们，做一些逻辑判断，可以是软件架构看着更解耦灵活。

参考文章：
http://blog.csdn.net/bingduanlbd/article/details/8424243
http://blog.csdn.net/fengyuzhengfan/article/details/38086743
http://blog.csdn.net/ljphhj/article/details/12858767
http://www.jianshu.com/p/f454662f497e