反射

概述

• 反射是Java被视为动态语言的关键，反射机制允许程序在执行期借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

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

• 加载完类之后，JVM内存的方法区中就会产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象包含了完整的类结构信息，通过这个对象看到类的结构称为：反射

  正常方式：引入需要的“包类”名称--通过new实例化--取得实例对象
  反射方式：实例化对象--getClass()方法--取得完整的"包类"名称
  

获取Class类的实例

• 已知具体的类，通过类的class属性获取，最为安全可靠，程序性能最高

  Class c = Person.class
  

• 已知某个类的实例，调用该实例的getClass()获取

  Class c = person.getClass() 
  

• 已知类的全类名，且该类在类路径下，通过Class的静态方法forName()获取

  Class c = Class.forName("com.lin.Person");
  

• 基本数据类型可以直接用 包装类名.Type

  Class c = Integer.TYPE
  ----------------------
  输出: int
  

哪些类型可以有Class对象

• class：外部类，成员内部类，静态内部类，匿名内部类
• 数组
• 接口
• 枚举
• 注解
• 基本数据类型
• void

  Class c1 = Object.class;
  Class c2 = Comparable.class;
  Class c3 = String[].class;
  Class c4=int[][].class;
  Class c5=Override.class;
  Class c6= ElementType.class;
  Class c7=Integer.class;
  Class c8=void.class;
  Class c9=Class.class;
  --------------------------输出
  class java.lang.Object
  interface java.lang.Comparable
  class [Ljava.lang.String;
  class [[I
  interface java.lang.Override
  class java.lang.annotation.ElementType
  class java.lang.Integer
  void
  class java.lang.Class
  

类加载内存分析

当程序主动使用某个类，该类还未被加载到内存中，系统会通过如下三个步骤对该类进行初始化

类加载理解

• 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象
• 链接：将Java类的二进制代码合并到JVM的运行状态之中的过程
  • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
  • 准备：正式为类变量(static)分配内存并设置类变量默认初始值阶段，这些内存都将在方法区中进行分配
  • 解析：虚拟机常量池内的符合引用(常量名)替换为直接引用(地址)的过程
• 初始化：
  • 执行类构造器()方法的过程，是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生。(类构造器是构造类信息的，不是构造该类对象的构造器)
  • 当初始化一个类时，发现其父类还没有进行初始化，则需要先触发其父类的初始化
  • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

类初始化

• 类的主动引用(发生类的初始化)
  • 当虚拟机启动，先初始化main方法所在的类
  • new一个类的对象
  • 调用类的静态成员(除了final常量)和静态方法
  • 使用java.lang.reflect包的方法对类进行反射调用
  • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
• 类的被动引用(不会发生类的初始化)
  • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：通过子类引用父类的静态变量，不会导致子类的初始化
  • 通过数组定义类引用，不会触发此类的初始化
  • 引用常量不会触发此类的初始化(常量在链接阶段就存入常量池中)

获取运行时类的完整结构

Filed，Method，Constructor，Superclass，Interface，Annotation...

动态创建对象执行方法

• 创建类的对象：调用Class对象的newInstance()方法
  • 类必须有一个无参数的构造器
  • 类的构造器访问权限需要是public

   //获取对象
   Class c = Class.forName("com.lin.reflection.User");
   //构造一个对象，无参构造器
   User  user = (User) c.getDeclaredConstructor().newInstance();
   System.out.println(user);
   --------------------------输出
   User{name='null', age=0}
  

• 当没有无参构造器时创建对象
  • 通过Class类的getDeclaredConstructor(Class...parameterTypes)取得本类的指定形参类型的构造器
  • 向构造器的形参传递构造器所需的各个参数
  • 通过Constructor实例化对象

  Class c = Class.forName("com.lin.reflection.User");
  //通过构造器创建对象
  Constructor constructor = c.getDeclaredConstructor(String.class, int.class);
  User one = (User) constructor.newInstance("林", 18);
  System.out.println(one);
  ---------------------------输出
  User{name='林', age=18}
  

• 调用指定方法

  //通过反射获取一个方法
  Method setName = c.getDeclaredMethod("setName", String.class);
  //invoke：激活 (对象，方法的值)
  setName.invoke(user3,"lin");
  System.out.println(user3.getName());
  ---------------------------------
  User{name='林', age=18}
  

• setAccessible
  • Method和Field，Constructor对象都有setAccessible()方法
  • 是启动和禁用访问安全检查的开关
  • 参数为true表示反射的对象在使用时取消Java语言访问检查
    • 使原本无法访问的私有成员也可以访问
  • 参数为false表示反射的对象开启Java语言访问检查

  //通过反射操作属性
      User user4 = (User) c.newInstance();
      Field name = c.getDeclaredField("name");
      name.setAccessible(true);//取消安全检测，可操作私有方法及属性
      name.set(user4, "反射");
      System.out.println(user4.getName());
  

获取注解信息

Class c = Class.forName("com.lin.reflection.Student");

//通过反射获取注解
Annotation[] annotations = c.getAnnotations();
for (Annotation annotation : annotations) {
          System.out.println(annotation);
	}

//获取注解的value的值
TabelLin tableLin = (TabelLin) c.getAnnotation(TabelLin.class);
System.out.println(tableLin.value());

//获取类指定的注解
Field field = c.getDeclaredField("name");
FieldLin annotation = field.getAnnotation(FieldLin.class);
System.out.println(annotation);
System.out.println(annotation.columnName());       System.out.println(annotation.type());    System.out.println(annotation.length());


@TabelLin("db_student")
class Student {
    @FieldLin(columnName = "db_id", type = "int", length = 10)
    private int id;
    @FieldLin(columnName = "db_age", type = "int", length = 10)
    private int age;
    @FieldLin(columnName = "db_name", type = "String", length = 3)
    private String name;  	
    ....
 }
 
//类名的注解
@Target(ElementType.TYPE)  //作用范围，类
@Retention(RetentionPolicy.RUNTIME)
@interface TabelLin {
    String value();
}

//属性的注解
@Target(ElementType.FIELD)  //作用范围，属性
@Retention(RetentionPolicy.RUNTIME)
        //运行时有效
@interface FieldLin {
    String columnName();

    String type();

    int length();
}

----------------------------------------
@com.lin.reflection.TabelLin(value="db_student")
db_student
@com.lin.reflection.FieldLin(columnName="db_name", type="String", length=3)
db_name
String
3

反射的应用场景

• 模块化的开发，通过反射去调用对应字节码，动态代理，Spring框架

- 使用JDBC连接数据库时：使用Class.forName反射加载数据库的驱动程序
- Spring通过XML配置模式装载Bean的过程：
   1.将程序内所有 XML 或 Properties 配置文件加载入内存中; 
   2.Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息; 
   3.使用反射机制，根据这个字符串获得某个类的Class实例; 
   4.动态配置实例的属性