Java教程

java中类加载器入门

本文主要是介绍java中类加载器入门,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

前言

顾名思义,类加载器就是负责类的加载的,从内存中,class文件中,jar包中等渠道加载,对于任意一个class,都需要由加载它的类加载器和这个类本身确定其在JVM中的唯一性。

java内置类加载器

java中内置了3种类加载器

根类加载器

又叫做Bootstrap类加载器,是最顶层的类加载器,没有父类加载器,是C++语言编写的,主要负责java中核心类库的加载,如java.lang包下所有类。

public class Test {

  public static void main(String[] args) {
    System.out.println(String.class.getClassLoader());
    String property = System.getProperty("sun.boot.class.path");
    for (String path : property.split(";")) {
      System.out.println(path);
    }
  }
}

输出为

null
D:\java\jdk\jdk1.8.0_181\jre\lib\resources.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\rt.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\sunrsasign.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\jsse.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\jce.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\charsets.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\jfr.jar
D:\java\jdk\jdk1.8.0_181\jre\classes

根类加载器获取不到引用,所以为null,常用的类如String都是在rt.jar这个jar中的。

扩展类加载器

由java语言实现,父类加载器为根类加载器,主要加载JAVA_HOME下jre\lib\ext下的目录

import jdk.nashorn.tools.Shell;

public class Test {

  public static void main(String[] args) {
    System.out.println(Shell.class.getClassLoader());
    String property = System.getProperty("java.ext.dirs");
    for (String path : property.split(";")) {
      System.out.println(path);
    }
  }
}

输出为

sun.misc.Launcher$ExtClassLoader@6d6f6e28
D:\java\jdk\jdk1.8.0_181\jre\lib\ext
C:\WINDOWS\Sun\Java\lib\ext

Shell类就是nashorn.jar中的一个类,类加载器确实为扩展类加载器。

static class ExtClassLoader extends URLClassLoader {
    private static volatile Launcher.ExtClassLoader instance;

    public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
      if (instance == null) {
        Class var0 = Launcher.ExtClassLoader.class;
        synchronized(Launcher.ExtClassLoader.class) {
          if (instance == null) {
            instance = createExtClassLoader();
          }
        }
      }

      return instance;
    }
private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {
      try {
        return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
          public Launcher.ExtClassLoader run() throws IOException {
            File[] var1 = Launcher.ExtClassLoader.getExtDirs();
            int var2 = var1.length;

            for(int var3 = 0; var3 < var2; ++var3) {
              MetaIndex.registerDirectory(var1[var3]);
            }

            return new Launcher.ExtClassLoader(var1);
          }
        });
      } catch (PrivilegedActionException var1) {
        throw (IOException)var1.getException();
      }
    }
private static File[] getExtDirs() {
      String var0 = System.getProperty("java.ext.dirs");
      File[] var1;
      if (var0 != null) {
        StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);
        int var3 = var2.countTokens();
        var1 = new File[var3];

        for(int var4 = 0; var4 < var3; ++var4) {
          var1[var4] = new File(var2.nextToken());
        }
      } else {
        var1 = new File[0];
      }

      return var1;
    }
}

扩展类加载器的定义如上,使用了双重锁判断的单例写法。

系统类加载器

也是java语言实现的,父类加载器为扩展类加载器,加载classpath下的类,如我们引入的第三方jar包和我们自己定义的类。

public class Test {

  public static void main(String[] args) {
    System.out.println(Test.class.getClassLoader());
    String property = System.getProperty("java.class.path");
    for (String path : property.split(";")) {
      System.out.println(path);
    }
  }
}

输出为

sun.misc.Launcher$AppClassLoader@18b4aac2
D:\java\jdk\jdk1.8.0_181\jre\lib\charsets.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\deploy.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\access-bridge-64.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\cldrdata.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\dnsns.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\jaccess.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\jfxrt.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\localedata.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\nashorn.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\sunec.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\sunjce_provider.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\sunmscapi.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\sunpkcs11.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\ext\zipfs.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\javaws.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\jce.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\jfr.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\jfxswt.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\jsse.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\management-agent.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\plugin.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\resources.jar
D:\java\jdk\jdk1.8.0_181\jre\lib\rt.jar
C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\lib\idea_rt.jar

系统类加载器的定义

public Launcher() {
    Launcher.ExtClassLoader var1;
    try {
      var1 = Launcher.ExtClassLoader.getExtClassLoader();
    } catch (IOException var10) {
      throw new InternalError("Could not create extension class loader", var10);
    }

    try {
      this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {
      throw new InternalError("Could not create application class loader", var9);
    }

    Thread.currentThread().setContextClassLoader(this.loader);
    String var2 = System.getProperty("java.security.manager");
    if (var2 != null) {
      SecurityManager var3 = null;
      if (!"".equals(var2) && !"default".equals(var2)) {
        try {
          var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
        } catch (IllegalAccessException var5) {
        } catch (InstantiationException var6) {
        } catch (ClassNotFoundException var7) {
        } catch (ClassCastException var8) {
        }
      } else {
        var3 = new SecurityManager();
      }

      if (var3 == null) {
        throw new InternalError("Could not create SecurityManager: " + var2);
      }

      System.setSecurityManager(var3);
    }

  }

先创建扩展类加载器,将扩展类加载器作为父类加载器创建系统类加载器,并设置到当前线程的上下文类加载器中。

static class AppClassLoader extends URLClassLoader {
    final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);

    public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
      final String var1 = System.getProperty("java.class.path");
      final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
      return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
        public Launcher.AppClassLoader run() {
          URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
          return new Launcher.AppClassLoader(var1x, var0);
        }
      });
    }

    AppClassLoader(URL[] var1, ClassLoader var2) {
      super(var1, var2, Launcher.factory);
      this.ucp.initLookupCache(this);
    }

类加载流程

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
  1. 首先检查该类是否已经加载过,如果是,直接返回已经加载过的类
  2. 父类加载器存在,委托父类加载器加载,不存在,委托根类加载器
  3. 都不能加载的话,由当前类加载器加载,重写findClass()方法
protected Class<?> findClass(final String name)
        throws ClassNotFoundException
    {
        final Class<?> result;
        try {
            result = AccessController.doPrivileged(
                new PrivilegedExceptionAction<Class<?>>() {
                    public Class<?> run() throws ClassNotFoundException {
                        String path = name.replace('.', '/').concat(".class");
                        Resource res = ucp.getResource(path, false);
                        if (res != null) {
                            try {
                                return defineClass(name, res);
                            } catch (IOException e) {
                                throw new ClassNotFoundException(name, e);
                            }
                        } else {
                            return null;
                        }
                    }
                }, acc);
        } catch (java.security.PrivilegedActionException pae) {
            throw (ClassNotFoundException) pae.getException();
        }
        if (result == null) {
            throw new ClassNotFoundException(name);
        }
        return result;
    }

URLClassLoader就是通过重写findClass()实现的。

打破双亲委派机制

双亲委派机制保证了越基础的类由越上层的类加载器加载,基础类之所以被称为“基础”,是因为它们总是作为被调用的API。但是,如果基础类要调用用户的代码,那该怎么办呢。一个典型的例子就是JDBC

jdk提供了所有相关的接口,这些接口都是由根类加载器加载的,而第三方驱动的实现是由系统类加载器加载的,按照双亲委派机制,根类加载器不可能加载得到第三方驱动的实现,为了解决这个困境,java引入了一种不太优雅的设计,线程上下文类加载器,这就变成了父类加载器委派子类加载器去加载,打破了双亲委派机制。java中所有涉及到SPI的动作基本上都是采用的这种方式。



参考

类加载器如何打破双亲委派加载机制(SPI原理)

这篇关于java中类加载器入门的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!