java加载机制整理
本文是根据李刚的《疯狂讲义》作的笔记，程序有的地方做了修改，特别是路径，一直在混淆，浪费了好多时间！！希望懂的同学能够指导本人，感激尽。。。。。。。。。。。。
1.jvm 和 类的关系
当调用 java命令运行一个java程序时，必会启动一个jvm即java虚拟机。(5.6.处有联系！！)
该java程序的所有线程，变量都处于jvm中，都使用该jvm的内存区
jvm终止的情况：
1.程序自然运行结束
2.遇到System.exit();Runtime.getRuntime.exit();
3.遇到未捕获异常或错误时
4.程序所在的平台强制结束了JVM进程
jvm终止，jvm内存中的数据全部丢失。
举例：
定义一个类，包含静态变量
class AClass{ public static int a = 1; }
使变量自加
public class ATest { public static void main(String[] args) { AClass.a++; System.out.println("a的值："+AClass.a);//输出：a的值：2 } }
另起一类，查看变量变化情况
public class ATest2 { public static void main(String[] args) { System.out.println("a的值："+AClass.a);//输出：a的值：1 } }
从输出对比可知，虽然ATest1自加，改变的类变量a的值，但是ATest1与ATest2处于不用的JVM中，当ATest1结束时，对a的修改都丢失了
2.类的加载
类的加载 又称为 类的初始化，实际上可细分为 类的 加载、连接、初始化。下面将讲述着三个阶段的过程!
类的加载 指.class文件读入内存，并为之创建一个 java.lang.Class对象
类加载，是通过类加载器来完成的，类加载器通常由JVM提供，通常称为系统类加载器（也可以是自己写的加载器，只要继承ClassLoader基类）。
类加载无须等到“首次使用该类”时加载，jvm允许预加载某些类。。。。
加载来源：
1.本地.class文件
2.jar包的.class文件
3.网络.class文件
4.把一个java源文件动态编译，加载
3.类的连接
负责把类的二进制数据合并到JRE（java运行环境）中
1.验证 检测被加载的类是否有正确的内部结构，并和其他类协调一致
2.准备 负责为类的类变量（非对象变量）分配内存，并设置默认初始值
3.解析 将类的二进制数据中的符号引用替换成直接引用。。(static final 好像跟这个有点关系？？？？5.6.处有联系）
4.类初始化
主要对类变量（而非对象变量）的初始化
声明类变量的初始值 = 静态初始化块 他们是相同的，等效的。都会被当成类的初始化语句，JVM会按照这些语句在程序中的顺序依次执行他们
public class Test { static int a = 5; //初始化时赋值 static int b; //初始化时赋值--静态块 static int c; //连接时赋默认值值 static{ b = 6; } public static void main(String[] args) { System.out.println(a); System.out.println(b); System.out.println(c); }
输出：
5
6
0
JVM初始化一个类包含如下几个步骤：
1.假设类还没有被加载和连接，那么先加载和连接该类
2.假设该类的父类还没被初始化，那么先初始化父类 ----jvm总是最先初始化java.lang.Object类
3.假设类中有初始化语句，则一次执行这些初始化语句
当程序主动使用任何一个类时，系统会保证该类以及所有父类（直接父类和间接父类）都会被初始化
5.类初始化的时机：
1.创建类的实例。new,反射，反序列化
2.使用某类的类方法--静态方法
3.访问某类的类变量，或赋值类变量
4.反射创建某类或接口的Class对象。Class.forName("Hello");---注意：loadClass调用ClassLoader.loadClass(name,false)方法,没有link，自然没有initialize
5.初始化某类的子类
6.直接使用java.exe来运行某个主类。即cmd java 程序会先初始化该类。
class Tester { public static int value = 10; public static String name; public static void method() { System.out.println("一个类方法"); } static { System.out.println("Tester的类的静态初始化。。。"); } } public class ClassLoadTest { static String classPath = "Chapter18.Tester"; public static void main(String[] args) throws ClassNotFoundException, Exception, IllegalAccessException { ClassLoader cl = ClassLoader.getSystemClassLoader(); Class<?> a = cl.loadClass(classPath); // 用到了 Tester类 加载一个类，并不会导致一个类的 初始化 /* 初始化的时机 */ // 调用newInstance()方法 a.newInstance(); // 输出：____________静态块加载 // 使用Class.forName方法 Class.forName(classPath); // 输出：____________静态块加载 // 调用类变量 int value = Tester.value; Tester.name = "jason"; // 输出：____________静态块加载 // 调用类方法 Tester.method(); // 输出：____________静态块加载 一个类方法 // new 实例化 Test t = new Test(); // 输出：____________静态块加载 } }
特殊情形：final 类型的类变量，如果在编译时（转成.class文件）就可以确定，那么这个类变量就相当于“宏变量”，编译时，直接替换成值。
所以，即使使用这个类变量，程序也不会导致该类的初始化！！----相当于直接使用 常量
public class Test { public static void main(String[] args) { System.out.println(aClass.A); } } class aClass{ static final int A = 111;//可以确定 static{ System.out.println("静态块初始化"); } }
输出：111
public class Test { public static void main(String[] args) { System.out.println(aClass.A); } } class aClass{ static final long A = System.currentTimeMillis();//在编译时无法确定 static{ System.out.println("静态块初始化"); } }
输出：
静态块初始化
1468309845203
使用ClassLoader类的 loadClass方法来加载类时，只是加载该类，而不会执行该类的初始化！！使用Class的forName()静态方法，才会导致强制初始化该类。
6.类加载器
类加载器 负责加载所有的类，为被加载如内存中的类生成一个java.lang.Class实例。一旦类被载入内存，同一个类就不会再加载第二次
如何判断是同一个类：
java中 一个类用其 全限定类名标示--包名+类名
jvm中 一个类用其 全限定类名+加载器标示---包名+类名+加载器名
加载器层次结构：
JVM启动时，姓曾的三个类加载器组成的机构
1.Bootstrap ClassLoader 根类 ------引导类加载器，加载java核心类。非java.lang.ClassLoader子类，而是JVM自身实现
2.Extension ClassLoader 扩展类-----加载JRE的扩展目录中的JAR包的类（%JAVA_HOME%/jre/lib/ext或java.ext.dirs系统属性指定的目录）
3.System ClassLoader 系统类-----加载cmd java -cp **,环境变量指定的jar包和类路径。ClassLoader.getSystemClassLoader获得 系统类加载器。
4.用户类加载器。。。
public class BootstrapTest { public static void main(String[] args) { // 获取根类加载器所加载的全部URL数组 URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs(); //无需理会警告 //遍历 输出根类加载器 加载的全部URL for (int i = 0; i < urls.length; i++) { System.out.println(urls[i].toExternalForm()); } } }
输出：
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/resources.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/rt.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/sunrsasign.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/jsse.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/jce.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/charsets.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/lib/jfr.jar
file:/C:/Program%20Files/Java/jre1.8.0_20/classes
7.类的加载机制：
1.全盘负责。某类以及其所依赖的所有类，都由一个加载器负责加载。除非显示使用另外一个加载器。
2.父类委托。先父类加载器加载改Class，不行后，才尝试从自己的类路径中加载该类
3.缓存机制。缓存机制将会保证所有加载过的Class都会被缓存。。当程序需要Class时，先从缓存区中寻找Class对象，没有的话，才加载该类的.class对象。
8.访问类加载器
public static void main(String[] args) throws IOException { ClassLoader systemLoader = ClassLoader.getSystemClassLoader();// get system loader 获得系统的类加载器 System.out.println("系统类加载器: "+systemLoader); /* * 获取 系统类加载器 的加载路径--通常由CLASSPATH 环境变量 指定， * 如果，操作系统 没有指定CLASSPATH环境变量， 则 默认以当前路径作为 系统类加载器 的家在路径 */ Enumeration<URL> eml = systemLoader.getResources(""); while(eml.hasMoreElements()){ System.out.println("SYSTEMClassLoader Route: "+eml.nextElement());//系统类加载器的加载路径 是程序运行的当前路径 } //获取 系统类加载器 的父类加载器，得到 扩展类加载器 ClassLoader extenionLoader = systemLoader.getParent(); System.out.println("扩展类加载器: "+extenionLoader); System.out.println("扩展类加载器的 路径: "+System.getProperty("java.ext.dirs")); ClassLoader baseLoader = extenionLoader.getParent(); System.out.println("扩展类加载器的 父类："+baseLoader);//The parent Classload is Bootstrap ClassLoader.BC is not use Java Language...So.. //根加载器 没有 继承ClassLoader抽象类。所以，返回的是Null //但实际上 扩展类加载器 的 父类加载器 是 根类加载器，只是，根类加载器 并不是 java实现的。 }
输出：
系统类加载器: sun.misc.Launcher$AppClassLoader@73d16e93
SYSTEMClassLoader Route: file:/D:/WorkSpace1/Java_Test/bin/
扩展类加载器: sun.misc.Launcher$ExtClassLoader@7f31245a
扩展类加载器的 路径: C:\Program Files\Java\jre1.8.0_20\lib\ext;C:\Windows\Sun\Java\lib\ext
扩展类加载器的 父类：null
系统类加载器是 AppClassLoader 的实例，扩展类加载器是 ExtClassLoader 的实例，这两个类都是 URLClassLoader 的实例
9，类加载器加载Class大致要经过9个步骤：
1.检测此Class 是否被载入过（即在缓存区中是否由此 Class），有，则进入第8步，否则执行第2步。
2.如果父类加载器不存在（要么parent 一定是根类加载器，要么本身就是根类加载器），则跳到第4步；如果父类加载器存在，则执行第3步。
3.请求使用父类加载器去载入目标类，如果成功则跳到第8步，否则执行第5步
4.请求使用 根类加载器 载入目标类，成功则跳到第8步，否则跳到第7步
5.当前类加载器 尝试寻找 Class文件（从与此ClassLoader相关的类路径中寻找），如果找到则执行第6步，否则跳到第7步。
6.从文件中载入Class，成功后跳到第8步。
7.抛出ClassNotFoundException异常。
8.返回对应的 java.lang.Class对象。
其中 第5,6步允许重写ClassLoader的findClass()方法来实现自己的载入策略，甚至重写loadClass()方法来实现自己 的载入过程
10.一个自定义的ClassLoader
由于是用eclipse编写程序，所以.java和.class文件分别放于不同的文件夹。写此程序的时候 要注意路径问题
本项目的包结构：
Java_Test|
|src |
|Chapter18|
| ClassloaderMineTest.java
| Test.java
项目路径：D:\WorkSpace1\Java_Test\bin; D:\WorkSpace1\Java_Test\src
/** * 读取一个文件 的 内容，返回byte[] * @param filename * @return * @throws IOException */ private byte[] getBytes(String filename) throws IOException { System.out.println("使用getBytes方法"); File file = new File(filename);//路径 bin/Chapter18/Test.class long len = file.length(); byte[] raw = new byte[(int)len]; try (FileInputStream fin = new FileInputStream(file)){ //一次读取Class文件的全部二进制数据 int r = fin.read(raw); if(r!=len) throw new IOException("无法读取全部文件："+r+"!="+len); return raw; } }
/** * 编译指定JAVA文件，返回编译的结果 * @param javaFile * @return * @throws IOException */ private boolean compile(String javaFile) throws IOException{ System.out.println("myClassLoader:正在编译"+javaFile+".........."); //调用系统的javac命令--指定了.class生成的路径，注意空格。此处为何不加上Chapter18呢？难道是java命名唯一性的缘故，包名+类名，已经知道了包名？？ Process p = Runtime.getRuntime().exec("javac -d d:/WorkSpace1/Java_Test/bin/ "+javaFile); try { //其他线程都等待这个线程完成 p.waitFor(); } catch (Exception e) { // TODO: handle exception System.out.println(e); } //获取javac线程的退出值 int ret = p.exitValue(); //返回编译是否成功 return res == 0; }
/** * 重写的findClass方法 */ @Override protected Class<?> findClass(String name) throws ClassNotFoundException {//name = Test Class clazz = null; String javaFilename = "src/Chapter18/"+fileStub+".java"; String classFilename = "bin/Chapter18/"+fileStub + ".class"; File javaFile = new File(javaFilename); //相对路径，相对于项目的跟路径：D:\WorkSpace1\Java_Test File classFile = new File(classFilename); //当指定Java源文件存在，且，Class文件不存在，或者Java源文件的修改时间比class文件的修改时间更晚时，重新编译if(javaFile.exists() && (!classFile.exists()||javaFile.lastModified()>classFile.lastModified())){ try { //如果编译失败，或者该class文件不存在 if(!compile(javaFilename)||!classFile.exists()){ throw new ClassNotFoundException("ClassNotFoundException:"+javaFilename+ " or "+classFile+" is not exists"); } } catch (Exception e) { // TODO: handle exception e.printStackTrace(); } } //如果class文件存在，系统负责将该文件转换成class对象 if(classFile.exists()){ try { //将class文件的二进制数据读入数组 byte[] raw = getBytes(classFilename); //调用ClassLoader的defineClass 方法将二进制数据转换成class对象 clazz = defineClass("Chapter18.Test",raw,0,raw.length);//路径 Chapter18.Test } catch (Exception e) { // TODO: handle exception e.printStackTrace(); } } //如果clazz为null，表明加载失败，则抛出异常 if(clazz == null){ throw new ClassNotFoundException(name); } return clazz; }
/** * main方法 * @param args * @throws Exception */ public static void main(String[] args) throws Exception { ClassloaderMineTest mc = new ClassloaderMineTest(); Class<?> clazz1 = mc.findLoadedClass("Chapter18.Test"); Class<?> clazz = mc.loadClass("Test",false); //路径 Test? Class<?> clazz2 = mc.findLoadedClass("Chapter18.Test"); //路径 Chapter18.Test？？,为什么又和loadClass的路径不一样呢 //得到Class对象后就可以反射了 Method main = clazz.getMethod("main", (new String[0].getClass())); String[] progArgs = {"Chapter18.Test"}; Object argsArray[] = {progArgs}; main.invoke(null, argsArray); }
11.URLClassLoader 类
java 为 ClassLoader 提供了一个 实现类 URLClassLoader ,该类 也是系统类加载器 和 扩展类加载器的 父类
URLClassLoader 的 两个构造器
URLClassLoader(URL[] urls)
URLClassLoader(URL[] urls, ClassLoader parent)
一旦 获得URLClassLoader对象后，就可以调用对象的 loadClass()方法 来加载指定的类。
下面展示的程序示范了如何直接从文件系统中加载MySQL驱动，并且使用该驱动来获取数据库连接。。通过这种方式，可以无须将MySQL驱动添加到CLASSPATH环境变量中
public class URLClassLoaderTest { private static Connection conn; private String url; private String driver; /** * 获得该用户下面的所有表 */ public static void getAllTableList(String schemaName,DatabaseMetaData dbMeta) { try { // table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM". String[] types = { "TABLE" }; ResultSet rs = dbMeta.getTables(null, schemaName, "%", types); while (rs.next()) { String tableName = rs.getString("TABLE_NAME"); //表名 String tableType = rs.getString("TABLE_TYPE"); //表类型 String remarks = rs.getString("REMARKS"); //表备注 System.out.println(tableName + "-" + tableType + "-" + remarks); } } catch (SQLException e) { e.printStackTrace(); } } //定义一个获取数据库 连接的方法 public static Connection getConn(String url,String user,String pass) throws Exception{ if(conn==null){ //file 表名是从 本地文件系统加载， //http:为前缀，表明从互联网通过HTTP来访问 //注意 URL 路径 // URLClassLoader loader = new URLClassLoader(new URL[]{new URL("file:D:/WorkSpaceMyEclipse/Meeting_Hall/WebRoot/WEB-INF/classes/")}); URL[] urls = {new URL("file:mysql-connector-java-5.1.30-bin.jar")};//从本地加载,jar包由外界导入，或者是放在项目的跟路径D:\WorkSpace1\Java_Test //以 默认的 ClassLoader 作为父 ClassLoader,创建 URLClassLoader URLClassLoader myClassLoader = new URLClassLoader(urls); //加载MYSQL的JDBC驱动， 并创建默认实例-------与 普通的通过 new 生成实例的方法 对比 Driver driver = (Driver)myClassLoader.loadClass("com.mysql.jdbc.Driver").newInstance(); //创建一个 设置JDBC连接属性的 Properties对象 Properties props = new Properties(); //至少需要为改对象传入 user和password两个属性 props.setProperty("user", user); props.setProperty("password", pass); //调用Driver 对象的 connect方法来取得数据库连接 conn = driver.connect(url, props); } return conn; } public static void main(String[] args) throws Exception { getConn("jdbc:mysql://localhost:3306/user_login", "root", "root"); DatabaseMetaData dbMeta = conn.getMetaData(); // 获取表中索引信息 getAllTableList(null, dbMeta); } }
输出：
affair-TABLE-
comment-TABLE-
sort-TABLE-
user-TABLE-
/** * 普通的 数据库连接方法 * @return */ public static Connection getDBConnection() { try { // 加载数据库 Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/user_login"; String user = "root"; String password = "root"; // 连接 conn = DriverManager.getConnection(url, user, password); } catch (Exception e) { e.printStackTrace(); } return conn; }
