java基础-JVM类加载的机制

类加载的过程

• 为什么要了解类加载全过程？

  • 有助于了解JVM运行过程
  • 更深入了解java动态性，（热部署、动态加载），提高程序的灵活性。

• 类加载机制

  • JVM把class文件加载到内存中，并对数据进行检验、解析和初始化，最终形成JVM可以直接使用的java类型的过程。

  • 加载:

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

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

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

  • 初始化

    • 初始化阶段是执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是有编译器自动收集类中的所有类变量的赋值动作和静态语句块(static块)中的语句合并产生的。
    • 当初始化一个类的时候，如果发现其父类还没有进行初始化、则需要先触发其父类的初始化。
    • 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。
    • 当访问一个Java类的静态域时，只有真正声明这个域的类才会初始化。

  • 类的主动引用（一定会发生类的初始化）

    • new一个类的对象
    • 调用类的静态成员（除了final常量）和静态方法
    • 使用java.lang.reflct包的方法对类进行反射作用
    • 当虚拟机启动，java Hello，则一定会初始化Hello类，说白了就是先启动main方法所在的类
    • 当初始化一个雷，如果其父类没有被初始化，则会先初始化它的父类。

  • 类的被动引用（不会发生类的初始化）

    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化
      • 通过子类引用父类的静态变量，不会导致子类初始化。
    • 通过数组定义类引用，不会触发此类的初始化。
    • 引用常量不会触发此类的初始化（常量在编译阶段就存入调用类的常量池中了）。

深入类加载器

内容大纲

1. 类加载器的原理
2. 类加载器树状结构，双亲委托代理机制
3. 自定义类加载器（文件、网络、加密）
4. 线程上下文类加载器
5. 服务器类加载器原理和OSGI介绍

1. 类加载器

• 类加载器的作用

  • 将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，在堆中生成一个代表这个类的java.lang.Class对象，最为方法区类数据的访问入口。

• 类缓存

  • 标准的Java SE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过，JVM垃圾收集器可以回收这些Class对象。

1.1 java.class.ClassLoader 类介绍

• 作用：

  • java.lang.ClassLoader类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些代码中定义出一个 Java 类，即 java.lang.Class 类的一个实例。
  • 除此以外，ClassLoader 还负责加载 Java 应用所需的资源，如图像文件和配置文件等。

• 相关方法

  • getParent() 返回该类加载器的父类加载器

    loadClass(String name) 加载名为 name 的类，返回的结果是 java.lang.Class 类的实例。

    • 此方法负责加载指定名字的类，首先会从已加载的类中去寻找，如果没有找到；从 parent ClassLoader[ExtClassLoader] 中加载；如果没有加载到，则从 Bootstrap ClassLoader中尝试加载(findBootstrapClassOrNull方法)；如果还是加载失败，则自己加载。如果还不能加载，则抛出异常ClassNotFoundException。
    • 如果要改变类的加载顺序可以覆盖此方法。

    findCLass(String name) 查找名称为 name 的类，返回的结果是 java.langClass 类的实例。

    findLoaderClass(String name)查找名称为 name 的已经被加载过的类，返回的结果是 java.lang.Class 类的实例。

    defineClass(String name, byte[] b, int off, int len) 把字节数组 b 中的内容转换成 Java 类，返回的结果是 java.lang.Class 类的实例。这个方法被声明为 final 的。

    resolveClass(Class<?> c) 连接指定的 Java 类。

  • 对于以上给出的方法，表示类名称的 name 参数的值是类的二进制名称。需要注意的是内部类的表示，如 com.example.Simple$1 和 com.example.Sample$Inner 等表示方法。

2. 类加载器的层次结构（树状结构）

• 引导类加载器（bootstrap class loader）

  • 它用来加载 Java 的核心库（JAVA_HOME/jre/lib/rt.jar或sun.boot.class.path路径下的内容），是用原生代码来实现的，并不是继承自 java.lang.ClassLoader。
  • 加载扩展类和应用程序类加载器。并制定他们的父类加载器。

• 扩展类加载器（extensions class loader）

  • 用来加载 Java 的扩展库（JAVV_HOME/jre/ext/*.jar，或 java.ext.dirs 路径下的内容）。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。
  • 由 sun.misc.Launcher$ExtClassLoader 实现。

• 应用程序类加载器（application class loader）

  • 它根据 Java 应用的类路径（classpath，java.class.path 路径）类。一般来说，Java应用类都是由它来完成加载的。
  • 由 sun.misc.Launcher$AppClassLoader实现。

• 自定义类加载器

  • 开发人员可以通过继承 java.lang.ClassLoader 类的方式实现自己的类加载器，以满足一些特殊的需求。

2.1 类加载器的代理模式

• 代理模式
  • 交给其他加载器来加载器指定的类
• 双亲委托机制
  • 就是某个特定的类加载器在接到加载器的请求时，首先将加载器任务委托给父类加载器，依次追溯，知道最高的爷爷辈的，如果父类家爱妻可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。
  • 双亲委托机制是为了保证 Java 核心库的类型安全。
    • 这种机制就保证不会出现用户自己能定义 java.lang.Object 类的情况.
  • 类加载器除了用于加载类，也是安全的最基本的屏障。
• 双亲委托机制也是代理模式的一种
  • 并不是所有的类加载器都采用双亲委托机制。
  • tomcat 服务器类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。

3. 自定义类加载器

• 自定义类加载器的流程：

  • 继承：java.lang.ClassLoader
  • 首先检查请求的类型是否已经被这个类装载器庄仔倒命名空间中了，如果已经装在，直接返回；
  • 委派类加载请求给父类加载器，如果父类加载器能够完成，则返回父类加载器加载的Class实例；
  • 调用本类加载器的 findClass(...) 方法，视图获取对应的字节码，试图获取对应的字节码，如果获取的到，则调用 defineClass(...) 导入类型到方法区；如果获取不到对应的自己吗或者其他原因失败，返回异常给 loadClass(...)，loadClass(...) 转抛异常，终止加载过程。
  • 注意：被两个类加载器加载的同一个类，JVM 不认为是相同的类。

• 自定义类加载器代码：

  package com.selflearning.classloader;
  
  import java.io.*;
  
  /**
   * 自定义文件系统加载器
   */
  public class FileSystemClassLoader extends ClassLoader{
  
      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 (ClassNotFoundException  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) {
          String path = rootDir + "/" + className.replace('.', '/') + ".class";
          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) {
              throw new RuntimeException(e);
          } finally {
              try {
                  if (is != null) {
                      is.close();
                  }
                  if (baos != null) {
                      baos.close();
                  }
              }catch (IOException e) {
                  e.printStackTrace();
              }
          }
  
      }
  }
  

• 自定义网络加载器

  package com.selflearning.classloader;
  
  import java.io.ByteArrayOutputStream;
  import java.io.InputStream;
  import java.net.URL;
  
  /**
   * 自定义网络类加载器
   */
  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)l;
              } catch (Exception e) {
  
              }
              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) {
          String path = rootUrl + "/" + classname.replace('.', '/')+ ".class";
  
          // IOUtils, 可以使用它将流中的数据转成字节数组
          InputStream in = null;
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          try {
              URL url = new URL(path);
              in = url.openStream();
              byte[] buffer = new  byte[1024];
              int temp = 0;
              while ((temp=in.read(buffer)) != -1) {
                  baos.write(buffer, 0, temp);
              }
              return baos.toByteArray();
          } catch (Exception e) {
              e.printStackTrace();
              return null;
          } finally {
              try {
                  if (in != null) {
                      in.close();
                  }
                  if (baos != null) {
                      baos.close();
                  }
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
      }
  }
  
  

• 自定义加密解密加载器

  实现加密时，需要一个加密类加载器和一个解密类加载器。使用加密类加载器时，将类加载后使用某种算法将该类的字节码加密；只有通过对应的解密类加载器解密后，才能够正常使用。

  • 加密操作类：

    package com.selflearning.classloader;
    
    import java.io.*;
    
    /**
     * 加密工具类
     */
    public class EncrptUtil {
    
        public static void encrpt(String src, String dest) {
            FileInputStream fis = null;
            FileOutputStream fs = null;
    
            try {
                fis = new FileInputStream(src);
                fs = new FileOutputStream(dest);
                // 读取文件并且取反。
                int temp = -1;
                while((temp = fis.read()) != -1) {
                    fs.write(temp^0xff); // 取反操作
    
                }
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (fis != null) {
                        fis.close();
                    }
                    if(fs != null) {
                        fs.close();
                    }
                }catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
            encrpt("d:/myjava/Hi.class", "d:/myjava/temp/Hi.class");
        }
    }
    
    

  • 解密类加载器：

    package com.selflearning.classloader;
    
    import java.io.ByteArrayOutputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    
    /**
     * 加载文件系统中加密后的class字节码的类加载器
     */
    public class DecrptClassLoader extends ClassLoader{
    
        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 (ClassNotFoundException e) {
    
                }
                if(c !=null) {
                    return c;
                } else {
                    byte[] classData = getClassData(name);
                    if(classData == null) {
                        throw new ClassNotFoundException();
                    } else {
                        return this.defineClass(name, classData, 0, classData.length);
                    }
                }
            }
        }
    
        private byte[] getClassData(String classname) {
            String path = rootDir + "/" + classname.replace(".", "/") + ".class";
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            InputStream in = null;
            try {
                in = new FileInputStream(path);
                int temp = -1;
                while((temp = in.read()) != -1) {
                    baos.write(temp^0xff);
                }
                return baos.toByteArray();
            } catch(Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    if (in != null) {
                        in.close();
                    }
                    if (baos != null) {
                        baos.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return null;
        }
    }
    

4. 线程上下文类加载器

• 双亲委托机制以及类加载器的问题

  • 一般情况下，保证一个类中所关联的其他类都是由当前某类的类加载器所加载的。

    比如，Class本身在Ext下找到，那么它里面 new 出来的一些类也就只能用 Ext 去查找了（不会低一个等级），所以有些明明App可以找到，却也找不到。

  • JDBC API，它有实现的 driven 部分（mysql/sql server），我们的JDBC API 都是都 Boot 或者 Ext 来载入的，但是 JDBC driver 却是由 Ext 或者 App 来载入的，那么就有可能找不到 driver。在 Java 领域中，其实只要分成这种 Api + SPI (Service Provide Interface，特定厂商提供的)的，都会遇到次问题。

  • 常见的 SPI 有 JDBC、JCE、JNDI、JAXP 和 JBI 等。这些 SPI 的接口由 Java 核心类库来提供，如 JAXP 的 SPI 接口定义包含在 javax.xml.parsers 包中。SPI的接口是 Java 核心库的一部分，是由引导类加载器来加载的；SPI 实现额 Java 类一般是由系统类加载器来加载的。引导类加载器是无法找到 SPI 实现类的，因为它只加载 Java 的核心库。

• 通常当你遇到动态加载资源的时候，你至少有三个 ClassLoader 可以选择：

  • 1. 系统类加载器或叫做应用加载器（system classloader or application classloader)
  • 2. 当前类加载器
  • 3. 当前线程加载器

• 线程类加载器时为了抛弃双亲委派加载链模式。

  • 每个线程都有一个关联的上下文类加载器。如果你也使用 new Thread() 方式生成新的线程，线程将继承父线程的上下文类加载器，如果程序对线程上下文加载器没有任何改动的话，程序中所有的线程豆浆使用系统加载器作为上下文类加载器。

• Thread.currentThread().getContextClassLoader()

• Thread.currentThread().setContextClassLoader()

5. TOMCAT 服务器的类加载器机制

• 一切都是为了安全！
  • TOMCAT 不能使用默认的类加载器。
    • 如果TOMCAT跑你的WEB项目使用系统的类加载器那是相当危险的，你可以直接是肆无忌惮地操作系统的各个目录了。
    • 对于运行在 Java EE ^TM容器中的 Web 应用来说，类加载器的实现方式与一般的 Java 应用有所不同。
    • 每个 Web 应用都有一个对应的类加载器实例。该类加载器也使用代理模式（不同于前面说的双亲委托机制），所不同的是它是受限尝试去加载某个类，如果找不到再代理给父类加载。这与一般类加载器的顺序是相反的。但也是为了保证安全，这样核心库就不在查询范围之内。
• 为了安全TOMCAT需要实现自己的类加载器
  • 我可以限制你只能把类写在指定的地方，否则我不给你加载!

5.1 OSGI 原理介绍

• OSGI^TM（Open Service Gateway Initative)是 Java 上的动态模块系统。它为开发人员提供了面向服务和基于组件的运行环境，并提供标准的方式用来管理软件的生命周期。

• OSGI 已经被实现和部署在很多产品上，在开源社区也得到了广泛的支持。Eclipse 就是基于 OSGI 技术来构建的。

• 原理

  • OSGI 中的每个模块（bundle）都包含 Java 包和类。模块可以声明它所依赖的需要导入（import）的其他模块的 Java 包和类（通过Import-Package），也可以声明导出（export）自己的包和类，供其他模块使用（通过Export-Package）。也就是说需要能够隐藏和共享一个模块中的某些 Java 包和类。这就是**通过 OSGI 特有的类加载器机制来实现的。OSGI 中的每个模块都有对应的一个类加载器。它负责加载模块自己包含的 Java 包和类。**当它需要加载 Java 核心库的类时，（以 java 开头的包和类），它会代理给父类加载器（通常是启动类加载器）来完成。当它需要加载所导入的 Java 类时，他会代理给导出此 Java 类的模块来完成加载。模块也可以显示的声明某些 Java 包和类，必须由父类加载器来加载，只需要设置系统属性 org.osgo.framework.bootdelegation 的值即可。

• Equinox OSGI 的一个实现