一. 类的加载，连接，初始化

1.1. JVM和类

当调用Java命令运行某个Java程序时，该命令将会启动一个Java虚拟机进程。不管Java程序多么复杂，启动多少个线程，它们都处于该Java虚拟机进程里，都是使用同一个Java进程内存区。

JVM程序终止的方式：

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

JVM进程结束，该进程所在内存中的状态将会丢失

1.2 类的加载

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

类的加载时将该类的class文件读入内存，并为之创建一个java.lang.Class对象，也就是说，当程序使用任何类时，系统都会为之建立一个java.lang.Class对象。

系统中所有的类实际上也是实例，它们都是java.lang.Class的实例

类的加载通过JVM提供的类加载器完成，类加载器时程序运行的基础，JVM提供的类加载器被称为系统类加载器。除此之外，开发者可以通过继承ClassLoader基类来创建自己的类加载器。

通过使用不同的类加载器，可以从不同来源加载类的二进制数据，通常有如下几种来源。

从本地文件系统加载class文件，这是前面绝大部分实例程序的类加载方式
从jar包加载class文件，这种方式也是很常见的，jdbc编程所用的驱动类就放在jar文件中，JVM可以直接从jar文件中加载该class文件。
通过网络加载class文件
把一个Java源文件动态编译，并执行加载

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

1.3 类的连接

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

验证：验证阶段用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
准备：类准备阶段则负责为类的类变量分配内存，并设置默认初始值
解释：将类的二进制数据中的变量进行符号引用替换成直接引用

1.4 类的初始化

再累舒适化阶段，虚拟机负责对类进行初始化，主要就是对类变量进行初始化。在Java类中对类变量指定初始值有两种方式：①声明类变量时指定初始值；②使用静态初始化块为类变量指定初始值。

JVM初始化一个类包含如下步骤

加载并连接该类
先初始化其直接父类
依次执行初始化语句

当执行第2步时，系统对直接父类的初始化也遵循1~3,以此类推

1.5 类初始化时机

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

创建类的实例。创建类的实例包括new操作符来创建实例，通过反射来创建实例，通过反射实例化创建实例
调用某个类的类方法（静态方法）
访问某个类或接口的类变量或为该类变量赋值
使用反射方式来强制来创建某个类或接口的java.lang.Class对象。例如代码“Class.forname("Person")”,如果系统还未初始化Person类，则这行代码会导致Person类被初始化，并返回person类的java.lang.Class对象
初始化某个类的子类
使用java.exe命令来运行某个主类。当运行某个主类时，程序会初始化该主类

二. 类加载器

2.1类加载器介绍

　　类加载器负责将.class文件加载到内存中，并为之生成对应的java.lang.Class对象。

一个载入JVM的类有一个唯一的标识。在Java中，一个类使用全限定类名（包括包名和类名）作为标识；但在JVM中，一个类使用全限定类名和其类加载器作为唯一标识。

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

Bootstrap ClassLoader：跟类加载器
Extension ClassLoader：扩展类加载器
System ClassLoader：系统类加载器

Bootrap ClassLoader被称为引导（也称为原始或跟）类加载器，它负责加载Java的核心类。跟类加载器不是java.lang.ClassLoader的子类，而是JVM自身实现的。

Extension ClassLoader负责加载JRE拓展目录中的JAR包的类，它的父类加载器是跟类加载器

System ClassLoader，它负责在JVM启动时加载来自Java命令的-classpath选项、java.class,path系统属性，或CLASSPATH指定的jar包和类历经。系统可通过ClassLoader的静态方法或区该系统类加载器。如果没有特别指定，则用户自定义的类加载器都已类加载器作为父加载器

2.2 类加载机制

JVM类加载机制主要有三种

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

类加载器加载Class大致经过8个步骤

检测此Class是否载入过（即缓存区中是否有此Class),如果有则直接进入第8步，否者接着第2步
如果父类加载器（父类 gt+ 加载器，要么Parent一定是跟类加载器，要么本身就是跟类加载器）不存在，则调到第4步执行
请求使用父类加载器载入目标类，如果成功载入调到第8步
请求使用跟类加载器来载入目标类
当前类加载器尝试寻找Class文件（从与此ClassLoader相关的类路径中寻找），如果找到则执行第6步，如果找不到执行第7步
从文件中载入Class，成功载入调到第8步
抛出ClassNotFoundException异常
返回对应的java.lang.Class对象

其中，第5、6步允许重写ClassLoader的findClass()方法来实现自己的载入策略，甚至重写loadClass()方法来实现自己的载入过程。

2.3 创建并使用自定义的类加载器

JVM除跟类加载器之外的所有类加载器都是ClassLoader子类的实例，开发者可以通过拓展ClassLoader的子类，并重写该ClassLoader所包含的方法实现自定义的类加载器。ClassLoader有如下两个关键方法。

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

如果需要是实现自定义的ClassLoader,则可以通过重写以上两个方法来实现，通常推荐重写findClass()方法而不是loadClass()方法。

classLoader()方法的执行步骤：

findLoadedClass():来检查是否加载类，如果加载直接返回。
父类加载器上调用loadClass()方法。如果父类加载器为null，则使用跟类加载器加载。
调用findClass(String)方法查找类

从上面看出，重写findClass()方法可以避免覆盖默认类加载器的父类委托，缓冲机制两种策略；如果重写loadClass()方法，则实现逻辑更为复杂。

ClassLoader的一些方法：

Class defineClass(String name,byte[] b,int off,int len)：负责将字节码分析成运行时数据结构，并检验有效性
findSystemClass(String name):从本地文件系统装入文件。
static getSystemClassLoader():返回系统类加载器
getParent():获取该类加载器的父类加载器
resolveClass(Class> c)：链接指定的类
findClassLoader(String name)：如果加载器加载了名为name的类，则返回该类对用的Class实例，否则返回null。该方法是类加载缓存机制的体现。

下面程序开发了一个自定义的ClassLoader。该classLoader通过重写findClass()方法来实现自定义的类加载机制。这个ClassLoader可以在加载类之前先编译该类的源文件，从而实现运行Java之前先编译该程序的目标，这样即可通过该classLoader运行Java源文件。

package com.gdut.basic;import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.lang.reflect.Method;public class CompileClassLoader extends ClassLoader {private byte[] getBytes(String fileName) {
    File file = new File(fileName);
    Long len = file.length();    byte[] raw = new byte[(int)len];
    
        FileInputStream fin = new FileInputStream(file);        //一次读取class文件的二进制数据
        int r = fin.read(raw);        if(r != len) {            throw new IOException("无法读取文件"+r+"!="+raw);        
    
    return null;
        }
}    private boolean compile(String javaFile) throws IOException {
        System.out.println("正在编译"+javaFile+"...");
        Process p = Runtime.getRuntime().exec("javac"+javaFile);        try {            //其他线程都等待这线程完成            p.waitFor();
        }catch(InterruptedException ie) {
            System.out.println(ie);
        }        int ret = p.exitValue();        return ret == 0;
    }
    @Override    protected Class> findClass(String name) throws ClassNotFoundException {
        Class clazz = null;
        String findStub = name.replace(".", "/");
        String javaFileName = findStub+".java";
        String classFileName = findStub+".class";
        File javaFile = new File(javaFileName);
        File classFile = new File(classFileName);        
        //但指定Java源文件存在，class文件不存在，或者Java源文件的修改时间比class文件修改的时间更晚时，重新编译
        if(javaFile.exists() && classFile.exists()                || javaFile.lastModified() > classFile.lastModified()) {            try {            if(!compile(javaFileName)|| !classFile.exists()) {                throw new ClassNotFoundException("ClassNotFoundExcetion"+javaFileName);
            }
            }catch(IOException ie) {
                ie.printStackTrace();
            }
        }        if(classFile.exists()) {            
                byte[] raw = getBytes(classFileName);
                
                clazz = defineClass(name,raw,0,raw.length);
        }        //如果clazz为null,表明加载失败，则抛出异常
        if(clazz == null) {            throw new ClassNotFoundException(name);
        }        return clazz;
    }    
    public static void main(String[] args) throws Exception {        //如果运行该程序时没有参数，即没有目标类
        if (args.length clazz = ccl.loadClass(progClass);        //获取运行时的类的主方法
        Method main = clazz.getMethod("main", (new String[0]).getClass());
        Object argsArray[] = {progArgs};
        main.invoke(null, argsArray);
        
    }
}

接下来可以提供任意一个简单的主类，该主类无需编译就可以使用上面的CompileClassLoader来运行他

package com.gdut.basic;public class Hello {    public static void main(String[] args) {        for(String arg:args) {
            System.out.println("运行Hello的参数："+arg);
        }

    }

}

无需编译该Hello.java,可以直接运行下面命令来运行该Hello.java程序

java CompileClassLoader hello 疯狂Java讲义

运行结果如下：

CompileClassLoader:正常编译 Hello.java...
运行hello的参数：疯狂Java讲义

使用自定义的类加载器，可以实现如下功能

执行代码前自动验证数字签名
根据用户提供的密码解密代码，从而可以实现代码混淆器来避免反编译*.class文件
根据应用需求把其他数据以字节码的形式加载到应用中。

2.4 URLClassLoader类

该类时系统类加载器和拓展类加载器的父类（此处的父类，是指类与类之间的的继承关系）。URLClassLoader功能比较强大，它可以从本地文件系统获取二进制文件来加载类，也可以从远程主机获取二进制文件加载类。

该类提供两个构造器

URLClassLoader(URL[] urls)：使用默认的父类加载器创建一个ClassLoader对象，该对象将从urls所指定的路径来查询并加载类
URLClassLoader(URL[] urls,ClassLoader prarent)：使用指定的父类加载器创建一个ClassLoader对象，该对象将从urls所指定的路径来查询并加载类。

下面程序示范了如何从文件系统中加载MySQL驱动，并使用该驱动获取数据库连接。通过这种方式来获取数据库连接，无需将MySQL驱动添加到CLASSPATH中。

package java.gdut;import java.net.URL;import java.net.URLClassLoader;import java.sql.Connection;import java.sql.Driver;import java.util.Properties;public class URLClassLoaderTest {    private static Connection conn;    public static Connection getConn(String url,String user,String pass)throws Exception{        if(conn == null){
            URL[] urls = {new URL("file:mysql-connection-java-5.1.46-bin.jar")};
            URLClassLoader myClassLoader = new URLClassLoader(urls);            //加载MySQL，并创建实例
            Driver driver = (Driver)myClassLoader.loadClass("com.mysql.jdbc.Driveer").newInstance();

            Properties properties = new Properties();
            properties.setProperty("user",user);
            properties.setProperty("pass",pass);            //调用driver的connect方法来取得数据库连接
            conn = driver.connect(url,properties);
        }        return conn;
    }    public static void main(String[] args) throws Exception {
        System.out.println(getConn("jdbc:mysql://localhost:3306/tb_test","sherman","a123"));
    }
}

本程序类加载器的加载路径是当前路径下的mysql-connection-java-5.1.46-bin.jar文件，将MySQL驱动复制到该路径下，这样保证ClassLoader可以正常加载到驱动类

三. 通过反射查看类信息

Java程序中的许多对象在运行时都会出现收到外部传入的一个对象，该对象编译时类型是Object，但程序又需要调用该对象运行时的方法。

第一种做法是假设编译时和运行时都知道该对象的的类型的具体信息，这种情况下，可以先用instanceof()运算符进行判断，再利用强制类型转换将其转换成运行时类型的变量即可
第二种做法是编译时根本无法知道该对象和类可能属于那些类，程序只依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射

3.1 获得class对象

每个类被加载后，系统会为该类生成一个对应的Class对象，通过该Class对象可以访问到JVM中的这个类。获得Class对象通常三种方式

使用Class类的forName(String clazz)静态方法。字符串参数传入全限定类名（必须添加包名），可能会抛出ClassNotFoundexception异常。
调用某个类的class属性来获取该类的的Class对象。
调用某个对象的getClass()方法，该方法是Object类的一个方法。

对于第一种方式，第二种的优势：

代码更安全。程序在编译阶段就可以检查需要访问的Class对象是否存在。
程序性能更好。这的种方式无需调用方法，所以性能更好。

3.2 从Class中获取信息

Class类提供了大量的实例方法获取该Class对象所对应类的详细信息

下面4个方法用于获取Class对象对应类的构造器

ConStructor getConStructor(Class> parameterTypes)：返回Class对象对应类的，带指定参数列表的public构造器
ConStructor>[] getConStructor()：返回此Class对象对应类的所有public构造器
ConStructor getDeclaredConStructor(Class>... parameterTypes)：返回此Class对象对应类的、带指定参数列表的构造器，与构造器的访问权限无关
ConStructor>[] getDeclaredConStructor()：返回此Class对象对应类的所有构造器，与构造器的访问权限无关

下面四个方法获取Class对象对应类所包含方法。

Method getMethod(String name,Class> parameterTypes)：返回Class对象对应类的,带指定形参列表的public方法
Method[] getMethods()：返回Class对象对应类的所有public方法
Method getDeclaredMethod(String name,Class> parameterTypes)：返回Class对象对应类的,带指定形参列表的方法,与访问权限无关
Method[] getDeclaredMethods()：返回Class对象对应类的所有全部方法，与方法的访问权限无关

下面四个方法获取Class对象对应类所包含的成员变量。

Field getField(String name)：返回Class对象对应类的,指定名称的public成员变量
Field[] getFIelds()：返回Class对象对应类的所有public成员变量
Field getDeclaredField(String name)：返回Class对象对应类的,指定名称的成员变量，与成员的访问权限无关
Field[] getFIelds()：返回Class对象对应类的所有成员变量,与成员的访问权限无关

如下几个方法用于访问Class对应类的上所包含的Annotation.

原文出处

ITPub博客

类加载机制与反射