反射

一、什么是反射：

能够分析类能力的程序称为反射（reflective)。
二、获得class类对象的三种方式

在程序运行期间，Java 运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。 虚拟机利用运行时类型信息选择相应的方法执行。

然而，可以通过专门的 Java 类访问这些信息。保存这些信息的类被称为 Class, 这个名字很容易让人混淆。Object 类中的 getClass( ) 方法将会返回一个 Class 类型的实例。


  • Student.class 类名.class
  • Student stu = new Student();
    stu.getClass(); 对象.getClass();
  • Class.forName(“com.qcby.entity.Student”); 字符串是一个全限定名 包名.类名的形式

创建对象

//等价的
Student student = Student.class.newInstance();
Student student1 = new Student();

通过反射只能拿到参数类型,拿不到参数名

可以拿到域的名字

public class Test {
     private int age;
     @Override
     public String toString() {
         return "Test{" +
                 "age=" + age +
                 '}';
     }
     public static void main(String[] args) {
         Test test = new Test();
         try {
             Field age = Test.class.getDeclaredField("age");
             //设置可访问非常重要
             age.setAccessible(true);
             age.set(test,20);
             System.out.println(test);
             System.out.println(age.get(test));
         } catch (NoSuchFieldException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         }
     }
 }

1、我们通过第一个try-catch可以看到即使是对象中的私有属性通过反射也是可以访问到的，前提是设置可访问的属性。

2、通过第二个try-catch的应用我们便实现了利用反射机制中的invoke方法来调用对象中的方法，也就是我们通常所说的代理，从这里我们可以看到，反射和代理是在一起使用的。

Method toString = Test.class.getDeclaredMethod("toString");
Object invoke = toString.invoke(test);
System.out.println(invoke);
import com.sun.org.apache.xpath.internal.operations.Mod;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;
public class RefelectionTest {
    public static void main(String[] args) {
        String name;
        if (args.length>0 ) name = args[0];
        else {
            Scanner in = new Scanner(System.in);
            System.out.println("Enter class name(e.g.java.util.Date):");
            name = in.next();
        }
        try {
            Class cl = Class.forName(name);
            Class supercl = cl.getSuperclass();
            String modifiers = Modifier.toString(cl.getModifiers());
            if(modifiers.length()>0){
                System.out.print(modifiers+" ");
            }
            System.out.print("class"+name);
            if (supercl!=null && supercl!=Object.class) System.out.print("extends"+supercl.getName());
            System.out.print("\n{\n");
            printConstructors(cl);
            System.out.println();
            printMethods(cl);
            System.out.println();
            printFields(cl);
            System.out.println("}");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }
    private static void printConstructors(Class cl) {
        Constructor[] constructors = cl.getDeclaredConstructors();
        for (Constructor c:constructors) {
            String name = c.getName();
            System.out.print("   ");
            String modifiers = Modifier.toString(c.getModifiers());
            if (modifiers.length()>0) System.out.print(modifiers+" ");
            System.out.printf(name+"(");
            Class[] paramTypes = c.getParameterTypes();
            for (int i = 0; i < paramTypes.length; i++) {
                if (i>0) System.out.print(",");
                System.out.printf(paramTypes[i].getName());
            }
            System.out.println(");");
        }
    }
    private static void printMethods(Class cl) {
        Method[] methods = cl.getDeclaredMethods();
        for (Method m:methods) {
            Class retType = m.getReturnType();
            String name = m.getName();
            System.out.printf("  ");
            String modifiers = Modifier.toString(m.getModifiers());
            if (modifiers.length()>0) System.out.printf(modifiers+" ");
            System.out.printf(retType.getName()+" "+name+"(");
            Class[] paramTypes = m.getParameterTypes();
            for (int i = 0; i < paramTypes.length; i++) {
                if (i>0) System.out.print(",");
                System.out.printf(paramTypes[i].getName());
            }
            System.out.println(");");
        }
    }
    private static void printFields(Class cl) {
        Field[] fields =cl.getDeclaredFields();
        for (Field f:fields) {
            Class type = f.getType();
            String name = f.getName();
            System.out.printf("  ");
            String modifiers = Modifier.toString(f.getModifiers());
            if (modifiers.length()>0) System.out.printf(modifiers+" ");
            System.out.println(type.getName() + " "+ name +";");
        }
    }
}

反射的具体用途

通过以上的介绍我们可以总结：

1、通过反射获取类信息；
2、根据类信息生成实例（实例化功能）；
3、反射最终的目的是拿到类的实例。

反射补充

反射的性能非常慢，是毫秒级的消耗。

所有的文件类型都是储存在磁盘上的

反射设置可以访问之后可以访问到私有属性

当程序没有主方法的时候，程序是不能自己独立运行的。此时它只能依靠别的程序来运行。比如servlet，它自己是没办法运行的，它需要依靠tomcat来运行

tomcat中依靠注解来分辨哪个是需要实例化的servlet类信息

反射的应用

一般反射在框架中应用是比较多的，但是为什么要在框架中运用反射机制呢？用new关键字来创建对象不是更好的选择吗？下面给出解答

例：tomcat是个容器，容器的开发者不知道项目的开发者会写什么类，所以无法用new的方法来给类进行实例化，所以容器开发者也会写出一个类的模板（servlet）来告诉项目的开发者开发规则是什么，当容器运行的时候，用反射的机制按照class.forName()这个方式获取类的信息然后在newInstance()进行实例化然后再运行，容器的开发者会把这个类的模板提供给项目开发者，项目开发者需要根据这个模板的规则来写对应的类，如果没有根据规则来写，也是不可以运行的。

那么，框架如果用new的方式来创建对象的话，首先需要有对应的类，也就是类是写死的，没有办法根据项目的开发进行动态的改变，而这就失去了开发框架的初衷

框架使用new关键字和反射机制的图示：

图一是写死的，图二是用反射机制

反射详解_java

如上就是对框架运用反射机制的解释。学习快乐！加油！