类加载机制与反射
类的加载、连接和初始化
系统可能在第一次使用某个类时加载该类，也可能采用预加载机制来加载某个类.
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++; } }
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
