java类的加载机制和反射浅析

原文请参考(感谢作者)：http://blog.hesey.net/2011/04/introduction-to-java-virtual-machine.html

上面简单的描述了类的加载机制。下面继续介绍类的加载、反射、动态代理。

一、 类的加载

当程序加载某个类时，如果该类还并未加载到内存中，则系统会通过加载、连接、初始化3步来实现对这个类进行初始化。

1. 加载
   
   • 指将class文件读入内存，并为之创建一个Class对象；
   • 任何类被使用时系统都会为之创建一个Class对象。（这个Class就是用来表示.class文件内容的）
2. 连接
   
   • 验证 是否有正确的内部结构，并和其他类协调一致
   • 准备 负责为类的静态成员分配内存，并设置默认初始化值
   • 解析 将类的二进制数据中的符号引用替换为直接引用
3. 初始化

1、类初始化的时机

• 创建类的实例
• 访问类的静态变量，或者为静态变量赋值
• 调用类的静态方法
• 使用Java反射机制来强制创建某个类或接口对应的java.lang.Class对象
• 初始化某个类的子类
• 直接使用java.exe命令来运行某个主类

2、类加载器

类加载器：负责将.class文件加载到内存中，并为之生成对应的Class对象。
类加载器的组成：根类加载器、扩展类加载器、系统类加载器。（参考文章开始的图片）

二、反射

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有的属性和方法；对于任意一个对象，都能够调用他的任意一个属性和方法；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。
要想解剖一个类必须要先获取到该类的字节码文件对象，而解剖使用的就是Class类中的方法，所以要先获取到每一个字节码文件对应的Class类型的对象。

1. 获取类的Class对象（有三种方式）：

public class ReflectDemo {
    // 获取Class对象的方式
    public static void main(String[] args) throws ClassNotFoundException {
        // 方式一：
        Person p = new Person();
        Class cp = p.getClass();
        System.out.println(cp); // Class对象class cn.qidd.Person

        Person p1 = new Person();
        Class cp1 = p1.getClass();

        System.out.println(p == p1); // false
        System.out.println(cp == cp1); // true 该class文件的Class对象只有一个

        // 方式二：
        Class cp3 = Person.class;
        System.out.println(cp3 == cp); // true

        // 方式三：
        Class cp4 = Class.forName("cn.qidd.Person");
        System.out.println(cp4 == cp); // true
    }
}

以上的三种方式都可以获取到类的Class对象，但是一般开发时推荐使用的是第三种，因为参数是一个字符串，而不是一个具体的类名，在开发中这个字符串可以放在配置文件中。前面的2种方式，可以在平时练习时使用比较方便。

2. 通过Class对象获取它的成员

• 通过反射获取构造器

  public class ReflectDemo1 {
  
  public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
      Class c = Class.forName("cn.qidd.Person");
      // 获取到它的所有构造方法
          // 1-获取到所有公共构造方法，返回数组
      Constructor[] constructors = c.getConstructors();
      System.out.println(Arrays.toString(constructors));
          // 2-获取到所有构造方法，返回数组
      Constructor[] declaredConstructors = c.getDeclaredConstructors();
      System.out.println(Arrays.toString(declaredConstructors));
          // 3-获取到构造方法，返回构造器对象
          // Constructor getConstructor(Class<?> ...parameterType)
      Constructor constructor = c.getConstructor(String.class,int.class);
      System.out.println(constructor);
  }
  }

• 通过反射获取构造方法并使用

public class ReflectDemo2 {

    public static void main(String[] args) throws  Exception {
        Class c = Class.forName("cn.qidd.Person");
        // 获取公有构造器（public）
        // 当使用此方法获取私有构造器时出现没有该方法的异常
        Constructor constructor = c.getConstructor(String.class,int.class,String.class);
        // 创建对象
        Object o = constructor.newInstance("孙艳平", 25, "陕西省");
        System.out.println(o);

        // 获取私有构造器/公有构造器
        Constructor con = c.getDeclaredConstructor(String.class);
        con.setAccessible(true); // 当不设置时非法异常，此处意思是指示使用Java反射的对象在使用时取消Java语言的访问权限
        Object o1 = con.newInstance("孙艳平");
        System.out.println(o1);
    }
}

• 获取成员变量

  public class ReflectDemo3 {
  
  public static void main(String[] args) throws Exception {
      Class c = Class.forName("cn.qidd.Person");
      Field[] fields = c.getFields(); // 获取到所有公共成员变量
      Field[] fields1 = c.getDeclaredFields(); // 获取到所有成员变量
      Field f = c.getField("address"); // 获取某公共成员变量
      Field f2 = c.getDeclaredField("name"); // 获取任意一个成员变量
      Constructor constructor = c.getConstructor();
      Object o = constructor.newInstance();
      f2.setAccessible(true);
      f2.set(o, "孙艳平");
      System.out.println(o);
  }
  }

• 获取成员方法

public class ReflectDemo4 {

    public static void main(String[] args) throws Exception {
        Class c = Class.forName("cn.qidd.Person");
        // 获取所有公共的方法（将他的父类的公共的方法也拿到）
        Method[] methods = c.getMethods();
        // 获取所有的方法（只有自己的），包含私有的
        Method[] methods1 = c.getDeclaredMethods();
        // 获取单个方法并使用（public）
        Constructor con = c.getConstructor();
        Object o = con.newInstance();

        Method method = c.getMethod("show");
        method.setAccessible(true);
        Object invoke = method.invoke(o); // 调用o的show方法
        // 获取单个方法（private修饰）
        Method m = c.getDeclaredMethod("function",String.class);
        m.setAccessible(true);
        Object o1 = m.invoke(o, "孙艳平");
        System.out.println(o1);
    }
}

3. 通过反射越过泛型检查

在此处先看一段代码：

public class ReflectDemo5 {

    public static void main(String[] args) throws Exception {
        ArrayList<Integer> arr = new ArrayList<Integer>();
        arr.add(10);
    }
}

编译之后的：

public class ReflectDemo5 {
    public ReflectDemo5() {
    }

    public static void main(String[] args) throws Exception {
        ArrayList arr = new ArrayList();
        arr.add(Integer.valueOf(10));
    }
}

我们可以看见泛型在编译之后就不存在了，但是10变成Integer类型加到List中了。
对于那些泛型来说，实际上是Object类型。
使用反射直接操作Class对象，在Class对象中ArrrayList的add方法并没有泛型限制。

public class ReflectDemo5 {

    public static void main(String[] args) throws Exception {
        ArrayList<Integer> arr = new ArrayList<Integer>();
//        arr.add(10);
        // 使用反射获取ArrayList的add方法，并使用
        Class c = arr.getClass();
        Method addM = c.getMethod("add", Object.class);
        addM.setAccessible(true);
        // 调用后arr的add方法，存入“hello”
        addM.invoke(arr, "hello");
        System.out.println(arr);
    }
}