[java加载机制整理]
本文转载自jasonstorm的博客
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("静态块初始化");
}
}
输出:11
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
A
p
p
C
l
a
s
s
L
o
a
d
e
r
@
73
d
16
e
93
S
Y
S
T
E
M
C
l
a
s
s
L
o
a
d
e
r
R
o
u
t
e
:
f
i
l
e
:
/
D
:
/
W
o
r
k
S
p
a
c
e
1
/
J
a
v
a
T
e
s
t
/
b
i
n
/
扩
展
类
加
载
器
:
s
u
n
.
m
i
s
c
.
L
a
u
n
c
h
e
r
AppClassLoader@73d16e93 SYSTEMClassLoader Route: file:/D:/WorkSpace1/Java_Test/bin/ 扩展类加载器: sun.misc.Launcher
AppClassLoader@73d16e93SYSTEMClassLoaderRoute:file:/D:/WorkSpace1/JavaTest/bin/扩展类加载器:sun.misc.LauncherExtClassLoader@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;
}