java自定义类加载器如何实现类隔离

目录
  • 自定义类加载器
    • 准备
    • 通过URLClassLoader来实现【推荐】
    • 通过继承ClassLoader实现

网上java自定义类加载器很多容易找到,但是都是加载的单个类,如果被加载的类,有引用了其他类怎么办呢?接下来看一下如何来处理这种情况

有时候一个项目中可能会引用不同版本的第三方依赖,比如笔者在升级hbase系统时,代理层就同时用到了1.X和2.X版本的hbase-client的jar包。

当时是使用的阿里的SOFAArk来实现的。

它的本质就是是哟个类加载来实现的,接下来就通过一个小例子来通过自定义类加载器实现类隔离。

下面实例实现了在同一个应用里加载了两个类名报名完全相同的Hello 和Dog类:

自定义类加载器

准备

准备工作,在D盘的a,b两个目录下准备Hello.class 和 Dog.class 两个文件,可以使用javac编译。

//a文件夹:
public class Hello {
    private String name;

    public Hello(String name) {
        this.name = name;
    }

    public void sayHello() {
		Dog d =new Dog();
		d.hi();
        System.out.println("a hello " + name + "  "+ this.getClass().getClassLoader());
    }
}

public class Dog {

    public void hi() {
        System.out.println("a hi ...  "+ this.getClass().getClassLoader());
    }
}

//b文件夹
public class Hello {
    private String name;

    public Hello(String name) {
        this.name = name;
    }

    public void sayHello() {
		Dog d =new Dog();
		d.hi();
        System.out.println("b hello " + name + "  "+ this.getClass().getClassLoader());
    }
}

public class Dog {

    public void hi() {
        System.out.println("b hi ...  "+ this.getClass().getClassLoader());
    }
}

通过URLClassLoader来实现【推荐】

类加载器会主动加载被引用的类。比如类A依赖引用了类B ,则只需要主动加载类A即可,类B会自动加载,而且加载类B的类加载器与类A相同。

/**
 * URLClassLoader
 * 推荐此方法
 */
@Test
public void test0() {
    try {
        System.out.println( this.getClass().getClassLoader());

        URLClassLoader diskLoader = new URLClassLoader(new URL[]{new URL("file:/D:/liubenlong/a/")});//最后面的斜杠需要添加
        URLClassLoader diskLoader1 = new URLClassLoader(new URL[]{new URL("file:/D:/liubenlong/b/")});

        //加载class文件
        Class clz = diskLoader.loadClass("Hello");
        Constructor constructor = clz.getConstructor(String.class);
        Object obj = constructor.newInstance("tom");

        /**
         * 类Hello引用了类Dog,类加载器会主动加载被引用的类。
         * 注意一般是我们使用 URLClassLoader 实现自定义的类加载器。如果使用classLoader,则需要重写findClass方法来实现类字节码的加载
         */
        Method method = clz.getMethod("sayHello", null);
        //通过反射调用Test类的say方法
        method.invoke(obj, null);

        Class clz1 = diskLoader1.loadClass("Hello");
        Constructor constructor1 = clz1.getConstructor(String.class);
        Object obj1 = constructor1.newInstance("cat");

        Method method1 = clz1.getMethod("sayHello", null);
        //通过反射调用Test类的say方法
        method1.invoke(obj1, null);

    } catch (Exception e) {
        e.printStackTrace();
    }
}

输出

jdk.internal.loader.ClassLoaders$AppClassLoader@1f89ab83
a hi ...  java.net.URLClassLoader@3891771e
a hello tom  java.net.URLClassLoader@3891771e
b hi ...  java.net.URLClassLoader@78ac1102
b hello cat  java.net.URLClassLoader@78ac1102

通过继承ClassLoader实现

网上说可以自定义类加载器实现,接下来我们看一下(jdk11直接忽略,因为编译不通过,下面是在jdk8版本测试)。

package 自定义类加载器;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;

/**
 * 自定义ClassLoader
 */
public class MyClassLoader extends ClassLoader {
    protected Class<?> findClass(String path, String name) {
        try {
            FileInputStream in = new FileInputStream(path + name + ".class");
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buf = new byte[1024];
            int len = -1;
            while ((len = in.read(buf)) != -1) {
                baos.write(buf, 0, len);
            }
            in.close();
            byte[] classBytes = baos.toByteArray();
            return defineClass(name, classBytes, 0, classBytes.length);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

编写测试类

package 自定义类加载器;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ClassLoaderTest {

    /**
     * 集成ClassLoader,重写findClass实现自定义类加载器
     */
    @Test
    public void test1() {
        try {
            MyClassLoader diskLoader = new MyClassLoader();
            MyClassLoader diskLoader1 = new MyClassLoader();

            //依赖的类需要提前加载,不是应该自动加载的吗?
            diskLoader.findClass("D:\\liubenlong\\a\\", "Dog");
            diskLoader1.findClass("D:\\liubenlong\\b\\", "Dog");

            //加载class文件
            Class clz = diskLoader.findClass("D:\\liubenlong\\a\\", "Hello");
            Constructor constructor = clz.getConstructor(String.class);
            Object obj = constructor.newInstance("tom");

            Method method = clz.getMethod("sayHello", null);
            //通过反射调用Test类的say方法
            method.invoke(obj, null);

            Class clz1 = diskLoader1.findClass("D:\\liubenlong\\b\\", "Hello");
            Constructor constructor1 = clz1.getConstructor(String.class);
            Object obj1 = constructor1.newInstance("cat");

            Method method1 = clz1.getMethod("sayHello", null);
            //通过反射调用Test类的say方法
            method1.invoke(obj1, null);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果:

a hi ...
a hello tom
b hi ...
b hello cat

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Java中线程上下文类加载器超详细讲解使用

    目录 一.什么是线程上下文类加载器 1.1.重要性 1.2.使用场景 二.ServiceLoader简单介绍 三.案例 3.1.使用ServiceLoader加载mysql驱动 3.2.Class.forName加载Mysql驱动 3.2.1.com.mysql.jdbc.Driver 3.2.2.java.sql.DriverManager初始化 3.2.3.调用DriverManager的registerDriver方法 3.2.4.执行DriverManager.getConnection

  • Java通过自定义类加载器实现类隔离

    目录 前言 类隔离是什么 使用场景 解决方案 重写findClass 重写loadClass 总结 前言 由于微服务的快速迭代.持续集成等特性,越来越多的团队更倾向于它.但是也体现出了一些问题,比如在基础设施建设过程中,需要把通用功能下沉,把现有大而全的基础设施按领域拆分,考虑需要兼容现有生产服务,会产生不同的依赖版本,有时不注意就可以引发问题.比如本文遇到的依赖包版本冲突问题,以及如何利用类隔离技术解决的分析. 类隔离是什么 类隔离是一种通过类加载器实现加载所需类的实现方式,使得不同版本类间隔

  • Java类加载器与双亲委派机制和线程上下文类加载器专项解读分析

    目录 一.类加载器 1.启动类加载器 2.拓展类加载器 3.应用类加载器 4.类的命名空间 二.双亲委派机制 1.类加载机制流程 2.类加载器加载顺序 3.双亲委派机制流程 4.源码分析 5.双亲委派机制优缺点 三.线程上下文类加载器 1.线程上下文类加载器(Context Classloader) 2.ServiceLoader 四.自定义类加载器 一.类加载器 类加载器就是根据类的二进制名(binary name)读取java编译器编译好的字节码文件(.class文件),并且转化生成一个ja

  • Java类加载器ClassLoader的使用详解

    目录 BootstrapClassLoader ExtClassLoader AppClassLoader 类加载器的具体实现在哪里 类加载器的初始化时机 如何进行的类加载 Loader.getResource(resourceName) 调用获取资源方法的一些常见问题 BootstrapClassLoader 加载范围(根据系统参数): System.getProperty("sun.boot.class.path"); 负责加载核心类库,以我的本地的环境来展示获取的内容: D:\d

  • Java中如何自定义一个类加载器

    目录 如何自定义加载器? 示例:读取某文件的下的某class文件 类加载器的使用及自定义类加载器 如何自定义加载器? 1.创建一个自定义加载器类 继承 ClassLoader 类 2.重写 findClass 方法. 主要是实现从那个路径读取 jar包或者.class文件,将读取到的文件用字节数组来存储,然后可以使用父类的 defineClass 来转换成字节码. 如果想破坏双亲委派的话,就重写 loadClass 方法, 否则不用重写 注意: 1.ClassLoader提供的 protecte

  • Java类加载器ClassLoader源码层面分析讲解

    目录 Launcher 源码 AppClassLoader 源码 ExtClassLoader 源码 ClassLoader 源码 总结 最终总结一下 Launcher 源码 sun.misc.Launcher类是java 虚拟机的入口,在启动 java应用 的时候会首先创建Launcher.在初始化Launcher对象的时候会创建一个ExtClassLoader拓展程序加载器 和 AppClassLoader应用程序类加载器(这俩鬼东西好像只是加载类的路径不一样而已),然后由这俩类加载器去加载

  • java自定义类加载器如何实现类隔离

    目录 自定义类加载器 准备 通过URLClassLoader来实现[推荐] 通过继承ClassLoader实现 网上java自定义类加载器很多容易找到,但是都是加载的单个类,如果被加载的类,有引用了其他类怎么办呢?接下来看一下如何来处理这种情况 有时候一个项目中可能会引用不同版本的第三方依赖,比如笔者在升级hbase系统时,代理层就同时用到了1.X和2.X版本的hbase-client的jar包. 当时是使用的阿里的SOFAArk来实现的. 它的本质就是是哟个类加载来实现的,接下来就通过一个小例

  • java自定义类加载器代码示例

    如果要使用自定义类加载器加载class文件,就需要继承java.lang.ClassLoader类. ClassLoader有几个重要的方法: protectedClassLoader(ClassLoaderparent):使用指定的.用于委托操作的父类加载器创建新的类加载器. protectedfinalClass<?>defineClass(Stringname,byte[]b,intoff,intlen):将一个byte数组转换为Class类的实例. protectedClass<

  • 浅谈Java自定义类加载器及JVM自带的类加载器之间的交互关系

    JVM自带的类加载器: 其关系如下: 其中,类加载器在加载类的时候是使用了所谓的"父委托"机制.其中,除了根类加载器以外,其他的类加载器都有且只有一个父类加载器. 关于父委托机制的说明: 当生成 一个自定义的类加载器实例时,如果没有指定它的父加载器,那么系统类加载器将成为该类加载器的父类加载器 下面,自定义类加载器.自定义的类加载器必须继承java.lang.ClassLoader类 import java.io.*; public class MyClassLoader extend

  • Java语言中的自定义类加载器实例解析

    本文研究的主要是Java语言中的自定义类加载器实例解析的相关内容,具体如下. 自己写的类加载器 需要注意的是:如果想要对这个实例进行测试的话,首先需要在c盘建立一个c://myjava的目录.然后将相应的java文件放在这个目录中.并将产生的.clas文件放在c://myjava/com/lg.test目录下,否则是找不到的.这是要注意的.. class FileClassLoader : package com.lg.test; import java.io.ByteArrayOutputSt

  • Java基础之自定义类加载器

    一.类加载器关系 自定义类加载器 创建一个类继承ClassLoader类,同时重写findClass方法,用于判断当前类的class文件是否已被加载 二.基于本地class文件的自定义类加载器 本地class文件路径 自定义类加载器: //创建自定义加载器类继承ClassLoader类 public class MyClassLoader extends ClassLoader{ // 包路径 private String Path; // 构造方法,用于初始化Path属性 public MyC

  • java 类加载与自定义类加载器详解

    类加载 所有类加载器,都是ClassLoader的子类. 类加载器永远以.class运行的目录为准. 读取classpath根目录下的文件有以下几种方式: 1 在Java项目中可以通过以下方式获取classspath下的文件: public void abc(){ //每一种读取方法,使用某个类获取Appclassloader ClassLoader cl = ReadFile.class.getClassLoader(); URL url = cl.getResource("a.txt&quo

  • Java实现的自定义类加载器示例

    本文实例讲述了Java实现的自定义类加载器.分享给大家供大家参考,具体如下: 一 点睛 1 ClassLoader类有如下两个关键方法: loadClass(String name, boolean resolve):该方法为ClassLoader的入口点,根据指定的二进制名称来加载类,系统就是调用ClassLoader的该方法来获取指定类对应的Class对象. findClass(String name):根据二进制名称来查找类. 如果需要实现自定义的ClassLoader,可以通过重写以上两

  • Java基于自定义类加载器实现热部署过程解析

    热部署: 热部署就是在不重启应用的情况下,当类的定义即字节码文件修改后,能够替换该Class创建的对象.一般情况下,类的加载都是由系统自带的类加载器完成,且对于同一个全限定名的java类,只能被加载一次,而且无法被卸载.可以使用自定义的 ClassLoader 替换系统的加载器,创建一个新的 ClassLoader,再用它加载 Class,得到的 Class 对象就是新的(因为不是同一个类加载器),再用该 Class 对象创建一个实例,从而实现动态更新.如:修改 JSP 文件即生效,就是利用自定

  • java类加载机制、类加载器、自定义类加载器的案例

    类加载机制 java类从被加载到JVM到卸载出JVM,整个生命周期包括:加载(Loading).验证(Verification).准备(Preparation).解析(Resolution).初始化(Initialization).使用(using).和卸载(Unloading)七个阶段. 其中验证.准备和解析三个部分统称为连接(Linking). 1.加载 加载指的是将类的.class文件中的二进制数据读入到内存中,将其放在运行时数据区的方法区内,然后在堆区创建一个java.lang.Clas

随机推荐