JVM核心机制_类加载全过程_深入类加载器_线程上下文类加载器

最新推荐文章于 2024-04-15 11:02:05 发布
原创 最新推荐文章于 2024-04-15 11:02:05 发布 · 235 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入解析Java类加载全过程，包括类加载器的层次结构、双亲委托机制，以及如何自定义文件系统类加载器、网络类加载器和加密解密类加载器。

类加载全过程

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.bjsxt.test;

public class Demo01 {
	static{
		System.out.println("静态初始化Demo01");
	}
	
	
	public static void main(String[] args) throws Exception {
		System.out.println("Demo01的main方法！");
		System.out.println(System.getProperty("java.class.path"));
		
		//主动引用
//		new A();
//		System.out.println(A.width);
//		Class.forName("com.bjsxt.test.A");
		
		
		//被动引用
//		System.out.println(A.MAX);
//		A[] as = new A[10];
		System.out.println(B.width);
		
	}
}

class B  extends A {
	static {
		System.out.println("静态初始化B");
	}
}

class A extends A_Father {
	public static int width=100;   //静态变量，静态域    field
	public static final  int MAX=100; 
	
	static {
		System.out.println("静态初始化类A");
		width=300;
	}
	public A(){
		System.out.println("创建A类的对象");
	}
}

class A_Father extends Object {
	static {
		System.out.println("静态初始化A_Father");
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

深入类加载器

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

package com.bjsxt.test;

/**
 * 测试类加载器的层次结构、双亲委托机制
 * @author 尚学堂高淇  www.sxt.cn
 *
 */
public class Demo02 {
	public static void main(String[] args) {
		System.out.println(ClassLoader.getSystemClassLoader());  //目前使用的类加载器
		System.out.println(ClassLoader.getSystemClassLoader().getParent());
		System.out.println(ClassLoader.getSystemClassLoader().getParent().getParent());   //JAVA_HOME/jre/lib/rt.jar
		System.out.println(System.getProperty("java.class.path"));//目前使用的类加载器的工作路径
		
		System.out.println("################");
		String a = "gaogao";
		System.out.println(a.getClass().getClassLoader());
		System.out.println(a);
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package com.bjsxt.test;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 自定义文件系统类加载器
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class FileSystemClassLoader extends ClassLoader {
	
	//com.bjsxt.test.User   --> d:/myjava/  com/bjsxt/test/User.class      
	private String rootDir;
	
	public FileSystemClassLoader(String rootDir){
		this.rootDir = rootDir;
	}
	
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		
		Class<?> c = findLoadedClass(name);
		
		//应该要先查询有没有加载过这个类。如果已经加载，则直接返回加载好的类。如果没有，则加载新的类。
		if(c!=null){
			return c;
		}else{
			ClassLoader parent = this.getParent();
			try {
				c = parent.loadClass(name);	   //委派给父类加载
			} catch (Exception e) {
//				e.printStackTrace();
			}
			
			if(c!=null){
				return c;
			}else{
				byte[] classData = getClassData(name);
				if(classData==null){
					throw new ClassNotFoundException();
				}else{
					c = defineClass(name, classData, 0,classData.length);
				}
			}
			
		}
		
		return c;
		
	}
	
	private byte[] getClassData(String classname){   //com.bjsxt.test.User   d:/myjava/  com/bjsxt/test/User.class
		String path = rootDir +"/"+ classname.replace('.', '/')+".class";
		
//		IOUtils,可以使用它将流中的数据转成字节数组
		InputStream is = null;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try{
			is  = new FileInputStream(path);
			
			byte[] buffer = new byte[1024];
			int temp=0;
			while((temp=is.read(buffer))!=-1){
				baos.write(buffer, 0, temp);
			}
			
			return baos.toByteArray();
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}finally{
			try {
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(baos!=null){
					baos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
	
	
	
	
}

  package com.bjsxt.test;
    
    /**
     * 测试自定义的FileSystemClassLoader
     * @author 尚学堂高淇 www.sxt.cn
     *
     */
    public class Demo03 {
    	public static void main(String[] args) throws Exception{
    		FileSystemClassLoader loader = new FileSystemClassLoader("d:/myjava"); //d:/myjava下java文件需要调用cmd进行编译（见上）。
    		FileSystemClassLoader loader2 = new FileSystemClassLoader("d:/myjava");
    		
    		Class<?> c = loader.loadClass("com.bjsxt.gaoqi.HelloWorld");
    		Class<?> c2 = loader.loadClass("com.bjsxt.gaoqi.HelloWorld");
    		Class<?> c3 = loader2.loadClass("com.bjsxt.gaoqi.HelloWorld");
    
    		Class<?> c4 = loader2.loadClass("java.lang.String");
    		Class<?> c5 = loader2.loadClass("com.bjsxt.test.Demo01");
    		
    		
    		System.out.println(c.hashCode());
    		System.out.println(c2.hashCode()); //c和c2是相同的类
    		System.out.println(c3.hashCode());	//同一个类，被不同的加载器加载，JVM认为也是不相同的类
    		System.out.println(c4.hashCode());
    		System.out.println(c4.getClassLoader());	//引导类加载器
    		System.out.println(c3.getClassLoader());	//自定义的类加载器
    		System.out.println(c5.getClassLoader());	//系统默认的类加载器
    		
    	}
    }

在这里插入图片描述

package com.bjsxt.test;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

/**
 * 网络类加载器
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class NetClassLoader extends ClassLoader {
	
	//com.bjsxt.test.User   --> www.sxt.cn/myjava/  com/bjsxt/test/User.class      
	private String rootUrl;
	
	public NetClassLoader(String rootUrl){
		this.rootUrl = rootUrl;
	}
	
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		
		Class<?> c = findLoadedClass(name);
		
		//应该要先查询有没有加载过这个类。如果已经加载，则直接返回加载好的类。如果没有，则加载新的类。
		if(c!=null){
			return c;
		}else{
			ClassLoader parent = this.getParent();
			try {
				c = parent.loadClass(name);	   //委派给父类加载
			} catch (Exception e) {
//				e.printStackTrace();
			}
			
			if(c!=null){
				return c;
			}else{
				byte[] classData = getClassData(name);
				if(classData==null){
					throw new ClassNotFoundException();
				}else{
					c = defineClass(name, classData, 0,classData.length);
				}
			}
			
		}
		
		return c;
		
	}
	
	private byte[] getClassData(String classname){   //com.bjsxt.test.User   d:/myjava/  com/bjsxt/test/User.class
		String path = rootUrl +"/"+ classname.replace('.', '/')+".class";
		
//		IOUtils,可以使用它将流中的数据转成字节数组
		InputStream is = null;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try{
			URL url = new URL(path);
			is  = url.openStream();
			
			byte[] buffer = new byte[1024];
			int temp=0;
			while((temp=is.read(buffer))!=-1){
				baos.write(buffer, 0, temp);
			}
			
			return baos.toByteArray();
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}finally{
			try {
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(baos!=null){
					baos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
		
}

自定加密解密类加载器：

package com.bjsxt.test;

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

/**
 * 加密工具类
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class EncrptUtil {
	
	public static void main(String[] args) {
		encrpt("d:/myjava/HelloWorld.class", "d:/myjava/temp/HelloWorld.class");//把d:/myjava/HelloWorld.class加密到d:/myjava/temp/HelloWorld.class。
	}
	
	public static void encrpt(String src, String dest){
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		try {
			fis = new FileInputStream(src);
			fos = new FileOutputStream(dest);
			
			int temp = -1;
			while((temp=fis.read())!=-1){
				fos.write(temp^0xff);  //取反操作
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				if(fis!=null){
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(fos!=null){
					fos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
	
	
}

package com.bjsxt.test;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 加载文件系统中加密后的class字节码的类加载器
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class DecrptClassLoader  extends ClassLoader {
	
	//com.bjsxt.test.User   --> d:/myjava/  com/bjsxt/test/User.class      
	private String rootDir;
	
	public DecrptClassLoader(String rootDir){
		this.rootDir = rootDir;
	}
	
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		
		Class<?> c = findLoadedClass(name);
		
		//应该要先查询有没有加载过这个类。如果已经加载，则直接返回加载好的类。如果没有，则加载新的类。
		if(c!=null){
			return c;
		}else{
			ClassLoader parent = this.getParent();
			try {
				c = parent.loadClass(name);	   //委派给父类加载
			} catch (Exception e) {
//				e.printStackTrace();
			}
			
			if(c!=null){
				return c;
			}else{
				byte[] classData = getClassData(name);
				if(classData==null){
					throw new ClassNotFoundException();
				}else{
					c = defineClass(name, classData, 0,classData.length);
				}
			}
			
		}
		
		return c;
		
	}
	
	private byte[] getClassData(String classname){   //com.bjsxt.test.User   d:/myjava/  com/bjsxt/test/User.class
		String path = rootDir +"/"+ classname.replace('.', '/')+".class";
		
//		IOUtils,可以使用它将流中的数据转成字节数组
		InputStream is = null;
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		try{
			is  = new FileInputStream(path);
			
			
			
			int temp = -1;
			while((temp=is.read())!=-1){
				baos.write(temp^0xff);  //取反操作,相当于解密
			}
			
			return baos.toByteArray();
		}catch(Exception e){
			e.printStackTrace();
			return null;
		}finally{
			try {
				if(is!=null){
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				if(baos!=null){
					baos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
	
	
}

package com.bjsxt.test;

/**
 * 测试简单加密解密(取反)操作
 * @author 尚学堂高淇 www.sxt.cn
 *
 */
public class Demo04 {
	public static void main(String[] args) throws Exception {
		//测试取反操作
//		int a = 3; //0000011
//		System.out.println(Integer.toBinaryString(a^0xff));  ff是11111111，取异或
		
		//加密后的class文件，正常的类加载器无法加载，报classFormatError
//		FileSystemClassLoader loader = new FileSystemClassLoader("d:/myjava/temp");//此文件加密
//		Class<?> c = loader.loadClass("HelloWorld");
//		System.out.println(c);
		
		DecrptClassLoader loader = new DecrptClassLoader("d:/myjava/temp");
		Class<?> c = loader.loadClass("HelloWorld");
		System.out.println(c);
		
	}
}

在这里插入图片描述
在这里插入图片描述

线程上下文类加载器_web服务器类加载机制_OSGI技术模块开发原理介绍 （略）

JVM类加载理解（线程上下文类加载器、Tomcat类加载器）
July的博客
11-05 4027
类加载机制概念 Java虚拟机把描述类的class文件加载到内存，对其进行校验、转换解析、初始化等操作，最终得到可以被虚拟机直接使用的java类型，这就是虚拟机的加载机制。 加载 将class文件读入到内存中，并将其放在运行时数据区的方法区内，然后在堆中创建一个java.lang.Class对象，用来封装在方法区的数据结构。 在这个阶段，主要完成如下三件事： 通过一个类的全限定名获取此类的二进制字节流（Class文件）。而获取的方式可以通过jar、war、zip、网络等方式 将字节流静态存储结构转换为
JVM之类加载器(ClassLoader)、模块化系统（基于《深入理解Java虚拟机》之第七章类加载机制）(下)
置身于量子事业的软件开发爱好者
07-18 1047
ｗ
线程上下文类加载器
weixin_34152820的博客
08-04 251
此前我对线程上下文类加载器（ThreadContextLoader）的理解仅仅局限于下面这段话： Java提供了很多服务提供者接口（Service Provider Interface，SPI），允许第三方为这些接口提供实现。常见的 SPI 有 JDBC、JCE、JNDI、JAXP 和 JBI 等。 这些 SPI 的接口由 Java 核心库来提供，而...
线程上下文类加载器（Context ClassLoader）
mweibiao的博客
05-15 1万+
1.线程上下文类加载器是从jdk1.2开始引入的，类Thread中的getContextClassLoader()与setContextClassLoader(ClassLoader c1)，分别用来获取和设置类加载器如果没有通过setContextClassLoader方法进行设置的话，线程将继承其父线程的上下文加载器，java应用运行时的初始线程的上下文类加载器是系统类加载器（这里是由Laun...
深入理解Java类加载器(2)：线程上下文类加载器
热门推荐
Jack Zhou的专栏
07-06 4万+
线程上下文类加载器 线程上下文类加载器（context class loader）是从 JDK 1.2 开始引入的。类 java.lang.Thread中的方法 getContextClassLoader()和 setContextClassLoader(ClassLoader cl)用来获取和设置线程的上下文类加载器。如果没有通过 setContextClassLoader(ClassLo
java类加载器和类反射使用示例
09-04
`Thread.currentThread().getContextClassLoader()`返回当前线程的上下文类加载器（通常是AppClassLoader），`System.class.getClassLoader()`返回加载`System`类的类加载器（BootstrapClassLoader），而`...
java的深入探究JVM之类加载与双亲委派机制
qq_40902295的博客
04-15 1677
前言前面学习了虚拟机的内存结构、对象的分配和创建，但对象所对应的类是怎么加载到虚拟机中来的呢？加载过程中需要做些什么？什么是双亲委派机制以及为什么要打破双亲委派机制？类的生命周期类的生命周期包含了如上的7个阶段，其中验证准备解析统称为连接 ，类的加载主要是前五个阶段，每个阶段基本上保持如上顺序开始（仅仅是开始，实际上执行是交叉混合的），只有解析阶段不一定，在初始化后也有可能才开始执行解析，这是为了支持动态语言。加载加载就是将字节码的二进制流转化为方法区。
JVM系列1——类加载机制
xiaodigua1024的博客
04-18 693
使用java命令运行某个类的main函数启动程序时，首选需要通过类加载器把主类加载到JVM。类加载过程为加载->验证->准备->解析->初始化->使用->卸载七个阶段。
介绍一下JVM的运行过程，着重解释类加载器
最新发布
08-05
- 使用线程上下文类加载器（`Thread.currentThread().getContextClassLoader()`） 2. **热部署**需求 - 每个模块使用独立类加载器（如Tomcat） 3. **OSGi**动态模块系统 - 网状结构的类加载模型
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值