java模块热插拔/热加载原理

本文详细阐述了Java类加载器的工作原理,包括类的加载、验证、解析和初始化过程,以及类加载器的局限性和如何通过自定义ClassLoader实现热部署。作者还通过示例展示了如何利用MyClassLoader动态替换类文件以实现实时更新。
摘要由CSDN通过智能技术生成

类加载器


类加载器概述

Java类的加载是由虚拟机来完成的,虚拟机把描述类的Class文件加载到内存,并对数据进行校验,解析和初始化,最终形成能被Java虚拟机直接使用的Java类型,这就是虚拟机的类加载机制.JVM中用来完成上述功能的具体实现就是类加载器.类加载器读取.class字节码文件将其转换成java.lang.Class类的一个实例.每个实例用来表示一个java类.通过该实例的newInstance()方法可以创建出一个该类的对象.

 类加载

类加载机制的核心:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区中的运行时数据结构,在堆中生成一个代表这个类的java.lang.Class对象,作为方法区类数据的访问入口,这个过程需要类加载器参与。

  • 当系统运行时,类加载器将.class文件的二进制数据从外部存储器(如光盘,硬盘)调入内存中,CPU再从内存中读取指令和数据进行运算,并将运算结果存入内存中。内存在该过程中充当着"二传手"的作用,通俗的讲,如果没有内存,类加载器从外部存储设备调入.class文件二进制数据直接给CPU处理,而由于CPU的处理速度远远大于调入数据的速度,容易造成数据的脱节,所以需要内存起缓冲作用。
  • 类将class文件加载至运行时的方法区后,会在堆中创建一个Java.lang.Class对象,用来封装类位于方法区内的数据结构,该Class对象是在加载类的过程中创建的,每个类都对应有一个Class类型的对象,Class类的构造方法是私有的,只有JVM能够创建。因此Class对象是反射的入口,使用该对象就可以获得目标类所关联的.class文件中具体的数据结构。
  • 类加载的最终产物就是位于堆中的Class对象(注意不是目标类对象),该对象封装了类在方法区中的数据结构,并且向用户提供了访问方法区数据结构的接口,即Java反射的接口。

链接过程 

将java类的二进制代码合并到JVM的运行状态之中的过程

  • 验证:确保加载的类信息符合JVM规范,没有安全方面的问题
  • 准备:正式为类变量(static变量)分配内存并设置类变量初始值的阶段,这些内存都将在方法区中进行分配
  • 解析:虚拟机常量池的符号引用替换为字节引用过程 

初始化 

初始化阶段是执行类构造器()方法的过程。类构造器()方法是由编译器自动收藏类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生,代码从上往下执行。

  • 当初始化一个类的时候,如果发现其父类还没有进行过初始化,则需要先触发其父类的初始化
  • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步
  • 当范围一个Java类的静态域时,只有真正声名这个域的类才会被初始化

下面写段代码简单描述一下初始化里面的一些常见的问题

说明:这种情况下加载是先加载静态代码块再加载构造方法.

说明:这个代码和上面那个代码就只是初始化交换了位置.这里"类构造器()方法是由编译器自动收藏类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生,代码从上往下执行。"简单来说类变量的初始化和static语句块是合并产生的,代码是重上往下执行.

这段代码实质上相当于:

private static int age=0;
	static {
		age=60;
		System.out.println("2.这是TestStatic类的静态代码块");
	}
	private static int age=50;
	public TestStatic() {
	System.out.println("1.这是TestStatic类的构造方法");
	}

还有一种情景:

说明:静态变量只初始化一次!

至于类加载机制暂时就说这么多.我记得在我谈反射的文章里也谈过类加载器.在这里就不做个重点介绍了.

接下来就谈谈如何实现热部署-? 讲一下我知道的吧,肯定还有其他的热部署方式,我们从原理上来刨一刨!再简单的用代码来实现一下热部署.

热部署


热部署概述

对于Java应用程序来说,热部署就是在运行时更新Java类文件。也就是不重启服务器的情况下实现java类文件的替换修改等.后面如果有时间学习一下SpringBoot的话 他就可以很优雅的实现一个应用的热部署,大家有兴趣可以去了解一下.

热部署有什么用

可以不重启应用的情况下,更新应用。举个例子,就像电脑可以在不重启的情况下,更换U盘。
OSGI也正是因为它的模块化和热部署,才显得热门。

热部署的原理是什么

简单一句话让JVM重新加载新的class文件!

这个时候问题就来了,如果我们希望将java类卸载,并且替换更新版本的java类,该怎么做呢?

既然在类加载器中,java类只能被加载一次,并且无法卸载。那是不是可以直接把类加载器给换了?答案是可以的,我们可以自定义类加载器,并重写ClassLoader的findClass方法。想要实现热部署可以分以下三个步骤:

  1. 销毁该自定义ClassLoader
  2. 更新class类文件
  3. 创建新的ClassLoader去加载更新后的class类文件。

我们以实现一个基础的自动的热部署代码.来解开热部署的真面目~下面是我代码实现后的效果,对原GirlFrend类的add方法实现了一个动态的替换.敢肯定的是实现热部署的方式不止这一种,欢迎大家交流分享

package com.xianglei.hot;

public class GirlFrend {
	
	public void add () {
		System.out.println("1.這是熱部署1.0版本.");
	}

}



package com.xianglei.hot;

import java.io.IOException;
import java.io.InputStream;

/**
 * 实现热部署的核心代码:主要是对类加载器的自定义,通过类加载器来创建新的对象进行JVM的加载操作
 * 
 * @author Xianglei @version1.0
 *
 */
public class MyClassLoader extends ClassLoader {
	/*
	 * 实现热部署核心路子: 0.继承ClassLoder 1.获取文件名你 2.读取文件流 3.读取字节 4.数据给JVM识别Class对象
	 */
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {

		try {
			// 文件名称
			String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
			// 读取文件流
			InputStream is = this.getClass().getResourceAsStream(fileName);
			// 读取字节
			byte[] b = new byte[is.available()];
			is.read(b);
			//数据给JVM识别Class对象
			return defineClass(name,b, 0, b.length);
		} catch (IOException e) {
			throw new ClassNotFoundException();
		}
		
	}

}


package com.xianglei.hot;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MainTest {

	public static void main(String[] args) throws InterruptedException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
	
		System.out.println("下面执行的是原来的版本");
		loadUser();
		System.gc();
		//通过File实现文件的替换从而实现一个自动化的热部署
		File oldFile = new File("D:\\JavaM\\Hot\\target\\classes\\com\\xianglei\\hot\\GirlFrend.class");
		oldFile.delete();
		File newFile = new File("C:\\Users\\Administrator\\Desktop\\GirlFrend.class");
		
		//实现新老class文件的替换
		boolean isRenameTo = newFile.renameTo(oldFile);
		if(!isRenameTo) {
			System.out.println("热部署失败!");
		}
		else {
			System.out.println("下面执行的是现在的版本");
			loadUser();
		}
		
	}

	// 通过反射机制创建对象
	public static void loadUser() throws ClassNotFoundException, InstantiationException, IllegalAccessException,
			NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		MyClassLoader myLoader = new MyClassLoader();
		Class<?> class1 = myLoader.findClass("com.xianglei.hot.GirlFrend");
		Object obj1 = class1.newInstance();
		Method method = class1.getMethod("add");
		method.invoke(obj1);
		System.out.println(obj1.getClass());
		System.out.println(obj1.getClass().getClassLoader());
	}
}

总结


关于热部署的知识我暂时就了解了这么多,在牺牲了一个冬日温暖的午后,终于让我熟悉了热部署的原理以及手动实现一个基础的热部署

-----------------------------------
java模块热插拔 java热加载原理
https://blog.51cto.com/u_13633/7575040

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Java SPI(Service Provider Interface)是一种针对接口编程的机制,允许第三方为接口提供实现,实现类可以动态地被替换,从而实现的效果。 责任链模式是一种行为型设计模式,它将请求的发送者和接收者解耦,使多个对象都有机会处理该请求。在责任链模式中,每个处理类都有一个后继处理类,如果当前处理类无法处理该请求,就将其转发给后继处理类。 利用Java SPI机制实现责任链模式中的处理类的过程如下: 1. 定义一个接口,作为责任链中每个处理类的基类。 ```java public interface Handler { void handle(Request request, Response response, HandlerChain chain); } ``` 2. 实现接口的具体处理类,每个处理类都有一个后继处理类。 ```java public class AuthenticationHandler implements Handler { @Override public void handle(Request request, Response response, HandlerChain chain) { // 处理请求 if (request.isAuthenticated()) { // 如果已认证,就将请求转发给下一个处理类 chain.next(request, response); } else { // 否则,直接返回未认证错误 response.setError("401 Unauthorized"); } } } public class AuthorizationHandler implements Handler { @Override public void handle(Request request, Response response, HandlerChain chain) { // 处理请求 if (request.isAuthorized()) { // 如果已授权,就将请求转发给下一个处理类 chain.next(request, response); } else { // 否则,直接返回未授权错误 response.setError("403 Forbidden"); } } } public class RateLimitHandler implements Handler { @Override public void handle(Request request, Response response, HandlerChain chain) { // 处理请求 if (request.isWithinRateLimit()) { // 如果未超过限制,就将请求转发给下一个处理类 chain.next(request, response); } else { // 否则,直接返回超过限制错误 response.setError("429 Too Many Requests"); } } } ``` 3. 定义一个HandlerChain类,用来维护责任链中的处理类,以及处理请求的方法。 ```java public class HandlerChain { private List<Handler> handlers; private int index; public HandlerChain() { handlers = new ArrayList<>(); index = 0; } public void addHandler(Handler handler) { handlers.add(handler); } public void next(Request request, Response response) { // 如果还有后继处理类,就将请求转发给它 if (index < handlers.size()) { Handler handler = handlers.get(index++); handler.handle(request, response, this); } } public void handle(Request request, Response response) { // 将请求转发给第一个处理类 if (handlers.size() > 0) { Handler handler = handlers.get(0); handler.handle(request, response, this); } } } ``` 4. 在META-INF/services目录下创建一个文件,文件名为接口的全限定名,文件内容为实现类的全限定名,多个实现类用换行符分隔。 ``` com.example.Handler com.example.AuthenticationHandler com.example.AuthorizationHandler com.example.RateLimitHandler ``` 5. 在客户端代码中,通过ServiceLoader所有实现类,并添到HandlerChain中。 ```java HandlerChain chain = new HandlerChain(); ServiceLoader<Handler> loader = ServiceLoader.load(Handler.class); for (Handler handler : loader) { chain.addHandler(handler); } Request request = new Request(); Response response = new Response(); chain.handle(request, response); ``` 这样,就可以实现对责任链模式中的处理类进行了。如果需要添或替换某个处理类,只需要将新的实现类打包成jar包,并将jar包放到classpath中,就可以实现动态。 ### 回答2: Java SPI(Service Provider Interface)是一种标准的服务发现机制。通过SPI机制,可以动态地和替换代码中的某些模块,实现了的功能。 责任链模式是一种行为型设计模式,它允许通过一系列的处理对象来逐步处理请求,并且每个处理对象都有机会处理请求或将其传递给下一个处理对象。SPI机制可以很好地与责任链模式结合,实现处理类的。 在Java SPI中,首先需要定义一个接口,该接口定义了一系列的处理方法。然后,在代码中使用SPI机制实现了该接口的具体处理类。通过SPI机制,可以在运行时动态地不同的处理类,实现责任链模式中处理类的。 具体实现步骤如下: 1. 定义一个接口,例如"Handler",该接口包含一系列处理方法。 2. 创建不同的实现类,例如"HandlerA"、"HandlerB"、"HandlerC"等,这些实现类分别实现了"Handler"接口。 3. 在项目的resources目录下创建一个"META-INF/services"文件夹。 4. 在"META-INF/services"文件夹下创建一个以"Handler"接口全限定名命名的文件,例如"com.example.Handler"。 5. 在该文件中,将实现了"Handler"接口的具体类的全限定名逐行添进去,例如"com.example.HandlerA"、"com.example.HandlerB"、"com.example.HandlerC"。 6. 通过SPI机制,可以通过以下代码获取到实现了"Handler"接口的具体类实例: ```java ServiceLoader<Handler> handlers = ServiceLoader.load(Handler.class); ``` 7. 遍历handlers即可得到实现了"Handler"接口的具体类的实例,可以根据需要调用不同的处理方法。 通过SPI机制实现责任链模式中的处理类,可以使系统更灵活和可扩展。通过配置不同的实现类,可以实现动态地修改和扩展处理类的功能,而无需修改和重新编译源代码。同时,SPI机制还符合开闭原则,提高了代码的可维护性和可扩展性。 ### 回答3: Java SPI(Service Provider Interface)是Java提供的一种服务提供者接口,它可以实现在运行时动态地和替换实现类的功能。而责任链模式是一种设计模式,它通过将一个请求经过一系列处理对象的处理,直到找到合适的处理者为止。 利用Java SPI机制实现责任链模式中的处理类,可以通过以下步骤完成: 1. 定义接口:首先需要定义一个处理请求的接口,该接口包含一个处理方法,用于处理具体的请求。 2. 实现接口:根据需求,实现多个处理类,每个类都实现上述定义的接口,并编写相应的处理逻辑。 3. 创建配置文件:在资源目录下创建一个META-INF/services文件夹,并在其中创建一个以接口全限定名为名称的文件,文件内容为实现类的全限定名,每个实现类占据一行。 4. 实现类:在代码中通过调用ServiceLoader.load()方法,指定接口的所有实现类。这样,就可以动态地获取到所有实现类的实例。 5. 构建责任链:根据到的实现类实例,按照需要的顺序构建责任链。责任链的每个节点都是一个实现类的实例。 6. 处理请求:将请求传递给责任链的第一个节点,由节点依次处理请求,直到找到合适的处理者或责任链结束。 通过上述步骤,就可以实现在运行时动态地添、删除或替换处理类,从而实现责任链模式中处理类的。 利用Java SPI机制实现责任链模式中的处理类的好处是可以在不修改现有代码的情况下,通过添或删除实现类来实现不同的业务逻辑处理。这种解耦的设计模式可以提高代码的可维护性和扩展性。同时,由于Java SPI机制利用了类器来实现类,可以方便地实现实现类的动态和替换,使得代码更灵活和可配置。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值