类加载机制与反射

标签：反射 java class JVM var 机制 Class 加载

类的加载、连接和初始化

　　系统可能在第一次使用某个类时加载该类，也可能采用预加载机制来加载某个类.

1 JVM和类

　　当调用java程序运行某个java程序时，该命令将会启动一个java虚拟机进程，不管java程序有多么复杂，该程序启动了多少个线程，它们都处于java虚拟机进程里。同一个JVM的所有线程，所有变量都处于同一个进程里，它们都使用JVM进程的内存区。当系统出现以下几种情况时，JVM进程将被终止。

• 程序运行到最后正常结束
• 程序使用System.exit()或Runtime.getRuntime().exit()代码结束程序
• 程序运行过程中遇到未处理异常或错误而结束
• 程序所在平台强制结束了JVM进程

　　从上面介绍可以看出，当java程序运行结束时，JVM进程结束，该进程在内存中的状态将会丢失。下面通过类变量来说明这个问题

public Class A{
     public static int number = 10;  
}

public class ATest{

}

public class BTest{

}

2. 类的加载

　　当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会加载、连接、初始化三个步骤来对该类进行初始化。如果没有意外，JVM将会连续完成这个三个步骤，所以有时也把这三个步骤统称为类的加载或者类的初始化。类加载指将类的class文件读入内存，并为之创建一个java.lang.Class对象，也就是说，当程序使用任何类时，系统都会为之建立一个java.lang.Class对象。

　　类的加载由类加载器完成，类加载器通常由JVM提供，JVM提供的这些类加载器通常被称为系统类加载器。除此之外，开发者可以通过继承ClassLoader基类来创建自己的类加载器。通过使用不同的类加载器，可以从不同来源加载类的二进制数据，通常有一下几种来源：

• 从本地系统直接读取.class文件，这是绝大部分类的加载方法
• 从zip、jar等归档文件中加载.class文件，这种方式也是很常见的
• 通过网络加载class文件或数据
• 把一个java源文件动态编译，并执行加载

　　类加载器通常无须等到“首次使用"该类时才加载该类，Java虚拟机规范允许系统预先加载某些类。

3. 类的连接

　　当类被加载后，系统为之生成一个对应的Class对象，接着将会进入连接阶段，连接阶段会负责把类的二进制数据合并到JVM的运行状态之中，类连接又可以分为如下三个阶段

　　（1)、验证：确保加载的类信息符合JVM规范，
　　（2)、准备：正式为类变量（static）分配内存并设置类变量的默认初始值的阶段，这些内存都将在方法区中进行分配
　　（3)、解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程

4. 类的初始化

　　虚拟机对类进行初始化主要是对类变量进行初始化。在Java类中对类变量指定初始值有两种方式：声明变量时指定初始值；使用静态代码块为类变量指定初始值。

public class Student{
     private int id;
     private static int nextId;
     //声明变量时gender时指定初始值
     private String gender = "MALE";

     static{
          //使用静态代码块为变量nextId赋值
          nextId = id + 1;
     }    
}

5. 类初始化的时机

　　当java程序首次通过下面6种方式来使用某个类或接口时，系统就会初始化该类或接口

• 创建类的实例。为某个类创建实例的方式包括：使用new操作符创建实例；通过反射创建实例；通过反序列化的方式创建实例
• 调用某个类的类方法（静态方法）
• 访问某个类或接口的类变量，或为该类变量赋值
• 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。例如代码：Class.forName("edu.uestc.domain.Student")，如果系统还未初始化Student类，则这句代码会导致该Student被初始化，并返回Student类对应的java.lang.Class对象。
• 初始化某个类的子类。当初始化某个类的子类时，该子类的所有父类都会被初始化。
• 直接使用java.exec命令来运行某个主类。当运行某个主类时，程序会先初始化该主类

　　注：对于一个final型的类变量(static final)，如果该类变量的值在编译时就可以确定下来，那么这个类变量相当于"宏变量"。java编译器会在编译时直接把这个类变量出现的地方替换成它的值，因此即使程序使用该类变量，也不会导致该类的初始化。例如：public static  final doule PI = 3.1415。反之，如果final修饰的类变量的值不能在编译时确定下来，则必须等到运行时才可以确定该类变量的值，如果通过该类来访问它的类变量，则会导致该类被初始化。例如：public static final String MESSAGE = System.currentTimeMills() + "";当使用ClassLoader类的loadClass()方法来加载某个类时，该方法只是加载该类，并不会执行该类的初始化。使用Class.forName()方法才会导致强制初始化该类

二  类加载器

　　类加载器负责将.class文件加载到JVM虚拟机中，并为之生成对应的java.lang.Class对象。尽管在java开发中无须过分关心类加载机制，但所有的编程人员都应该了解其工作机制，明白如何做才能更好满足我们的需要。

　　类加载器负责加载所有的类，系统为所有被载入内存中的类生成一个java.lang.Class实例。一旦一个类被载入JVM中，同一个类就不会再次载入了。那么，怎么样算是“同一个类”呢？
　　正如一个对象有一个唯一的标识一样，一个载入JVM的类也有一个唯一的标识。在Java中，一个类用其全限定类名（包括包名和类名）作为标识；在JVM中，一个类用其全限定类名（包名.类名）和其类加载器作为唯一标识。所以一个类使用不同的类加载器分别加载JVM将视为两个不同的类，它们互不兼容。

　　当JVM启动时，会形成三个类加载器组成的初始类加载器层次结构。

• Bootstrap ClassLoader：引导类加载器

　　　　又称为根（也称为原始）类加载器。他负责加载Java核心类库。在执行java.exe指令时，使用-Xbootclasspath选项或使用-D选项指定sun.boot.class.path系统属性值可以指定加载附加的类。根类加载器非常特殊，并不继承自 java.lang.ClassLoader，而是由JVM自身实现的（采用C/C++实现）。jdk9以后负责加载启动时的基础模块类。

• Extension ClassLoader：扩展类加载器

　　　　这个类加载器负责加载JAVA_HOME\lib\ext目录或java.ext.dirs系统变量指定的路径中的所有类库，用来加载java的扩展库，JDK9时替换为平台类加载器（PlatformClassLoader）加载一些平台相关模块，如java.scripting、java.compiler*、 java.corba*。

• System ClassLoader：系统类加载器

　　　　也称为应用类加载器，它负责在JVM启动时加载来自Java命令的-classpath选项、java.class.path系统属性，或者CLASSPATH换将变量所指定的JAR包和类路径。程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器。如果没有特别指定，则用户自定义的类加载器都以此类加载器作为父加载器。JDK9以后：应用程序类加载器（AppClassLoader），用于加载应用级别的模块（jdk.compiler，jdk.jartool，dk.jartool）；责加载用户类路径(CLASSPATH)下的类库,一般我们编写的java类都是由这个类加载器加载

JVM类加载机制

　　JVM类加载机制主要有三种：

• 全盘负责：当类加载器加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负责载入，除非显式使用另外一个类加载器来载入。
• 父类委托：先让parent（父）类加载器视图加载该class，只有在父加载器无法加载该类时才尝试从自己的类路径中加载该类
• 缓存机制：会保证所有加载过的  Class都会被缓存，当程序中需要使用某个Class时，类加载器会先从缓存中搜寻该Class，只有当缓存中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换成Class对象，存入缓冲区中。这就是为什么修改了Class后，必须重新启动JVM，程序所做的修改才会生效的原因。

　　除了可以使用Java提供的类加载器外，开发者也可以实现自己的类加载器，自定义的类加载器通过继承ClassLoader来实现。JVM中这4种类加载器的层次结构如下图

 　　注：类加载器之间的父子关系并不是继承上的父子关系，这里的父子关系是类加载器实例之间的关系。

package edu.uestc.avatar;

import java.io.IOException;

public class ClassLoaderTest {
    public static void main(String[] args) throws IOException {
        //获取系统类加载器
        var systemLoader = ClassLoader.getSystemClassLoader();
        System.out.println("AppClassLoader:" + systemLoader);
        /*
         * 获取系统类加载器的加载路径————通常由CLASSPATH环境变量指定
         * 如果操作系统没有指定CLASSPATH环境变量，则默认以当前路径昨晚系统类加载器的加载路径
         */
        var em = systemLoader.getResources("");
        while(em.hasMoreElements())
            System.out.println(em.nextElement());
        //获取系统类加载器的父类加载器，得到扩展类加载器
        var extensionLoader = systemLoader.getParent();
        System.out.println("PlatformClassLoader:" + extensionLoader);
        
        System.out.println("PlatformClassLoader的parent:" + extensionLoader.getParent());
    }
}

　　运行结果：

 　　JVM的根类加载器并不是java实现的，而且由于程序通常无须访问根类加载器，因此访问扩展类加载器（平台类加载器）的父类加载器时返回null。

自定义类加载器

　　通过继承java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求。ClassLoader中包含了大量的protected方法，这些方法都可被子类重写。其中有如下两个关键方法：

• loadClass(String name, boolean resolve):该方法为ClassLoader的入口，根据指定名称来加载类，系统就是调用ClassLoader的该方法来获取指定类对应的Class对象。
• findClass(String name):根据指定名称来查找类

　　

package edu.uestc.avatar;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class AvatarClassLoader extends ClassLoader{
    /**
     * 读取一个文件的内容
     * @param filename 文件的全限定名称
     * @return 文件内容
     * @throws IOException 
     * @throws FileNotFoundException 
     */
    private byte[] getBytes(String filename) throws IOException {
        var file = new File(filename);
        var len = file.length();
        var raw = new byte[(int)len];
        try(var in = new BufferedInputStream(new FileInputStream(file))){
            int r = in.read(raw);//一次读取Class文件的全部二进制数据
            if(r != len) throw new IOException("无法读取全部文件:" + r + " != " + len);
        }
        return raw;
    }
    /**
     * 编译指定java文件
     * @param javaFile java文件
     * @return 是否编译成功
     */
    private boolean compile(String javaFile) throws IOException{
        System.out.println("AvatarClassLoader:正在编译" + javaFile);
        //调用系统的javac指令
        var process = Runtime.getRuntime().exec("javac " + javaFile);
        try {
            //其他线程等待这个指令完成
            process.waitFor();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //获取javac线程的退出值
        return process.exitValue() == 0;
    }
    /*
     * 重写findClass方法,可以避免覆盖默认类加载器的父类委托、缓存机制两种策略
     * 如果重写loadClass方法，则实现逻辑更为复杂
     */
  @Override
  protected Class<?> findClass(String name) throws ClassNotFoundException {
      Class<?> clazz = null;
      var fileStub = name.replace(".", "/");
      var javaFilename = fileStub + ".java";
      var classFilename = fileStub + ".class";
      var javaFile = new File(javaFilename);
      var classFile = new File(classFilename);
      
      if(javaFile.exists() && (!classFile.exists() || javaFile.lastModified() > classFile.lastModified())) {
          try {
            if(!compile(javaFilename) || !classFile.exists())
                  throw new ClassNotFoundException("ClassNotFoundException:" + javaFilename);
        } catch (ClassNotFoundException | IOException e) {
            e.printStackTrace();
        }
      }
      if(classFile.exists()) {
          try {
            var raw = getBytes(classFilename);
            //defineClass方法管理JVM的许多复杂的实现，它负责将字节码分析成运行时数据结构，并校验有效性等
            clazz = defineClass(name, raw, 0, raw.length);
        } catch (IOException e) {
            e.printStackTrace();
        }
      }
      
      if(clazz == null) throw new ClassNotFoundException(name);
      return clazz;
  }
}

　　定义主方法

package edu.uestc.avatar;

import java.lang.reflect.InvocationTargetException;

public class AvatarClassLoaderTest extends ClassLoader{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, 
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        if(args.length < 1) {
            System.out.println("缺少目标类，按以下格式运行Java源文件:");
            System.out.println("java AvatarClassLoader ClassName");
            return;
        }
        //第一个参数为需要运行的类
        var proClass = args[0];
        var proArgs = new String[args.length - 1];
        System.arraycopy(args, 0, proArgs, 0, proArgs.length);
        var loader = new AvatarClassLoader();
        var clazz = loader.findClass(proClass);
        var main = clazz.getMethod("main", new String[0].getClass());
        main.invoke(null, (Object[])proArgs);
    }
}

URLClassLoader类

　　既可以从本地文件系统获取二进制文件来加载类，也可以从远程主机获取二进制文件来加载类

三  反射

 　　JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的法的功能称为java语言的反射机制。

获取Class对象

　　前面已经介绍过，每个类被加载之后，都会为该类产生一个对应的Class对象，通过该Class对象就可以访问到JVM中的这个类。在java程序中获得Class对象通常有三种方式：

• 实例的getClass()方法。
• Class.forName(String className).
• 某个类的class属性。例如:Student.class。该种方式代码更安全且程序性能更好，因为无须调用方法

　　一旦获得了某个类的Class对象后，程序就可以通过调用Class对象的方法来获得该对象和该类的真实信息了。

从Class中获取信息

使用反射生成并操作对象

创建对象

调用方法

访问成员变量

操作数组

反射和泛型

　　从JDK1.5以后，java的Class类增加了泛型功能，从而允许使用泛型来限制Class类，例如String.class的类型实际上是Class<String>。如果Class对应的类暂时未知，则使用Class<?>。通过在反射中使用泛型，可以避免使用反射生成的对象需要强制类型转换。

　　1、泛型和Class类

　　2、使用反射获取泛型信息

使用反射生成JDK动态代理

动态代理和AOP

标签：反射,java,class,JVM,var,机制,Class,加载
From： https://www.cnblogs.com/adan-chiu/p/16152517.html