`
huangcanqin
  • 浏览: 28799 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

java 的classloader机制

阅读更多
JVM在加载类的时候,都是通过ClassLoader的loadClass()方法来加载class的,loadClass(String name)方法:
使用的是双亲委托模式:
jvm启动时,会启动jre/rt.jar里的类加载器:bootstrap classloader,用来加载java核心api;然后启动扩展类加载器ExtClassLoader加载扩展类,并加载用户程序加载器AppClassLoader,并指定ExtClassLoader为他的父类;
当类被加载时,会先检查在内存中是否已经被加载,如果是,则不再加载,如果没有,再由AppClassLoader来加载,先从jar包里找,没有再从classpath里找;
如果自定义loader类,就会存在这命名空间的情况,不同的加载器加载同一个类时,产生的实例其实是不同的;

Java代码
public Class<?> loadClass(String name) throws ClassNotFoundException {  
return loadClass(name, false);  
   } 

public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
    }

loadClass(String name)方法再调用loadClass(String name, boolean resolve)方法:
     - name - 类的二进制名称
     - resolve - 如果该参数为 true,则分析这个类
Java代码
protected synchronized Class<?> loadClass(String name, boolean resolve)  
    throws ClassNotFoundException  
    {  
    // First, check if the class has already been loaded  
    //JVM 规范规定ClassLoader可以在缓存保留它所加载的Class,如果一个Class已经被加载过,则直接从缓存中获取  
    Class c = findLoadedClass(name);  
    if (c == null) {  
        try {  
        if (parent != null) {  
            c = parent.loadClass(name, false);  
        } else {  
            c = findBootstrapClass0(name);  
        }  
        } catch (ClassNotFoundException e) {  
            // If still not found, then invoke findClass in order  
            // to find the class.  
            c = findClass(name);  
        }  
    }  
    if (resolve) {  
        resolveClass(c);  
    }  
    return c;  


protected synchronized Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
    {
// First, check if the class has already been loaded
//JVM 规范规定ClassLoader可以在缓存保留它所加载的Class,如果一个Class已经被加载过,则直接从缓存中获取
Class c = findLoadedClass(name);
if (c == null) {
    try {
if (parent != null) {
    c = parent.loadClass(name, false);
} else {
    c = findBootstrapClass0(name);
}
    } catch (ClassNotFoundException e) {
        // If still not found, then invoke findClass in order
        // to find the class.
        c = findClass(name);
    }
}
if (resolve) {
    resolveClass(c);
}
return c;
}

如果ClassLoader并没有加载这个class,则调用findBootstrapClass0:
Java代码
private Class findBootstrapClass0(String name)  
    throws ClassNotFoundException  
    {  
    check();  
    if (!checkName(name))  
        throw new ClassNotFoundException(name);  
    return findBootstrapClass(name);  
    } 

private Class findBootstrapClass0(String name)
throws ClassNotFoundException
    {
check();
if (!checkName(name))
    throw new ClassNotFoundException(name);
return findBootstrapClass(name);
    }

该方法会调用check()方法来判断这个类是否已经初始化,并且通过checkName(name)来判断由name指定的这个类是否存在
最后调用findBootstrapClass(name):
Java代码
private native Class findBootstrapClass(String name)  
    throws ClassNotFoundException; 

private native Class findBootstrapClass(String name)
throws ClassNotFoundException;

而这个findBootstrapClass方法是一个native方法,这是我们的root loader,这个载入方法并非是由JAVA所写,而是C++写的,它会最终调用JVM中的原生findBootstrapClass方法来完成类的加载。

如果上面两个都找不到,则使用findClass(name)来查找指定类名的Class:
Java代码
protected Class<?> findClass(String name) throws ClassNotFoundException {  
    throw new ClassNotFoundException(name);  


protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}

JDK5.0中的说明:
使用指定的二进制名称查找类。此方法应该被类加载器的实现重写,该实现按照委托模型来加载类。在通过父类加载器检查所请求的类后,此方法将被 loadClass 方法调用。默认实现抛出一个 ClassNotFoundException。
所以,我们在自定义类中,只需要重写findClass()即可。
MyClassLoader类:
Java代码
public class MyClassLoader extends ClassLoader {  
    private String fileName;  
 
    public MyClassLoader(String fileName) {  
        this.fileName = fileName;  
    }  
 
    protected Class<?> findClass(String className) throws ClassNotFoundException {  
        Class clazz = this.findLoadedClass(className);  
        if (null == clazz) {  
            try {  
                String classFile = getClassFile(className);  
                FileInputStream fis = new FileInputStream(classFile);  
                FileChannel fileC = fis.getChannel();  
                ByteArrayOutputStream baos = new 
                        ByteArrayOutputStream();  
                WritableByteChannel outC = Channels.newChannel(baos);  
                ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
                while (true) {  
                    int i = fileC.read(buffer);  
                    if (i == 0 || i == -1) {  
                        break;  
                    }  
                    buffer.flip();  
                    outC.write(buffer);  
                    buffer.clear();  
                }  
                fis.close();  
                byte[] bytes = baos.toByteArray();  
 
                clazz = defineClass(className, bytes, 0, bytes.length);  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
        return clazz;  
    }  
    private byte[] loadClassBytes(String className) throws 
            ClassNotFoundException {  
        try {  
            String classFile = getClassFile(className);  
            FileInputStream fis = new FileInputStream(classFile);  
            FileChannel fileC = fis.getChannel();  
            ByteArrayOutputStream baos = new 
                    ByteArrayOutputStream();  
            WritableByteChannel outC = Channels.newChannel(baos);  
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
            while (true) {  
                int i = fileC.read(buffer);  
                if (i == 0 || i == -1) {  
                    break;  
                }  
                buffer.flip();  
                outC.write(buffer);  
                buffer.clear();  
            }  
            fis.close();  
            return baos.toByteArray();  
        } catch (IOException fnfe) {  
            throw new ClassNotFoundException(className);  
        }  
    }  
    private String getClassFile(String name) {  
        StringBuffer sb = new StringBuffer(fileName);  
        name = name.replace('.', File.separatorChar) + ".class";  
        sb.append(File.separator + name);  
        return sb.toString();  
    }  


public class MyClassLoader extends ClassLoader {
    private String fileName;

    public MyClassLoader(String fileName) {
        this.fileName = fileName;
    }

    protected Class<?> findClass(String className) throws ClassNotFoundException {
        Class clazz = this.findLoadedClass(className);
        if (null == clazz) {
            try {
                String classFile = getClassFile(className);
                FileInputStream fis = new FileInputStream(classFile);
                FileChannel fileC = fis.getChannel();
                ByteArrayOutputStream baos = new
                        ByteArrayOutputStream();
                WritableByteChannel outC = Channels.newChannel(baos);
                ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
                while (true) {
                    int i = fileC.read(buffer);
                    if (i == 0 || i == -1) {
                        break;
                    }
                    buffer.flip();
                    outC.write(buffer);
                    buffer.clear();
                }
                fis.close();
                byte[] bytes = baos.toByteArray();

                clazz = defineClass(className, bytes, 0, bytes.length);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return clazz;
    }
    private byte[] loadClassBytes(String className) throws
            ClassNotFoundException {
        try {
            String classFile = getClassFile(className);
            FileInputStream fis = new FileInputStream(classFile);
            FileChannel fileC = fis.getChannel();
            ByteArrayOutputStream baos = new
                    ByteArrayOutputStream();
            WritableByteChannel outC = Channels.newChannel(baos);
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            while (true) {
                int i = fileC.read(buffer);
                if (i == 0 || i == -1) {
                    break;
                }
                buffer.flip();
                outC.write(buffer);
                buffer.clear();
            }
            fis.close();
            return baos.toByteArray();
        } catch (IOException fnfe) {
            throw new ClassNotFoundException(className);
        }
    }
    private String getClassFile(String name) {
        StringBuffer sb = new StringBuffer(fileName);
        name = name.replace('.', File.separatorChar) + ".class";
        sb.append(File.separator + name);
        return sb.toString();
    }
}

该类中通过调用defineClass(String name, byte[] b, int off, int len)方法来定义一个类:
Java代码
protected final Class<?> defineClass(String name, byte[] b, int off, int len)  
throws ClassFormatError  
   {  
return defineClass(name, b, off, len, null);  
   } 

protected final Class<?> defineClass(String name, byte[] b, int off, int len)
throws ClassFormatError
    {
return defineClass(name, b, off, len, null);
    }

注:MyClassLoader加载类时有一个局限,必需指定.class文件,而不能指定.jar文件。该类中的大部分代码是从网上搜索到的,是出自一牛人之笔,只是不知道原帖在哪,希望不会被隐藏。
MainClassLoader类:
Java代码
public class MainClassLoader {  
    public static void main(String[] args) {  
        try {  
            MyClassLoader tc = new MyClassLoader("F:\\OpenLib\\");  
            Class c = tc.findClass("Test");  
            c.newInstance();  
        } catch (ClassNotFoundException e) {  
            e.printStackTrace();   
        } catch (IllegalAccessException e) {  
            e.printStackTrace();  
        } catch (InstantiationException e) {  
            e.printStackTrace();   
        }  
    }  


public class MainClassLoader {
    public static void main(String[] args) {
        try {
            MyClassLoader tc = new MyClassLoader("F:\\OpenLib\\");
            Class c = tc.findClass("Test");
            c.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

最后是一个简单的Test测试类:
Java代码
public class Test  
{  
    public Test() {  
        System.out.println("Test");  
    }  
    public static void main(String[] args) {  
        System.out.println("Hello World");  
    }  


分享到:
评论

相关推荐

    理解Java ClassLoader机制

    Java ClassLoader机制是Java运行时环境中的核心组件之一,它负责加载类到JVM(Java虚拟机)中,使得程序能够执行。理解ClassLoader的工作原理对于优化应用性能、处理类加载问题以及实现自定义加载器至关重要。 首先...

    java ClassLoader机制及其在OSGi中的应用

    Java ClassLoader机制是Java虚拟机(JVM)中一个至关重要的组成部分,它的主要任务是将类的.class文件加载到JVM中,使得程序能够运行。ClassLoader不仅负责类的加载,还涉及类的验证、初始化等一系列过程。理解...

    Java Classloader机制用法代码解析

    Java Classloader 机制用法代码解析 Java Classloader 机制用法代码解析是 Java 编程语言中的一种机制,负责加载 Java 类文件到 Java 虚拟机中。本文将对 Java Classloader 机制进行详细的解析,包括 JDK 默认的 ...

    Java ClassLoader定制实例

    理解ClassLoader的工作原理以及如何定制它,对于深入学习Java的运行机制和进行高级应用开发具有重要意义。本篇文章将深入探讨Java ClassLoader的内部工作,并通过一个具体的实例来展示如何定制自己的ClassLoader。 ...

    java ClassLoader机制详细讲解

    Java的ClassLoader机制是Java运行时环境的核心组成部分,它负责加载.class文件到JVM(Java Virtual Machine)中,以便程序能够使用这些类。ClassLoader的主要任务是将类的二进制数据转换为可执行的Java对象。它使得...

    ClassLoader机制详解

    Java ClassLoader机制是Java虚拟机(JVM)中至关重要的组成部分,它负责加载类到内存中以便执行。ClassLoader的工作方式和层次结构对于理解和调试Java应用程序尤其是涉及到类动态加载的场景至关重要。 首先,...

    java classloader

    `CH_05.package与import机制.pdf`可能讲解了与ClassLoader相关的包和导入机制,因为它们与类的组织和加载密切相关。 `CH_03.Java与MS Office.pdf`、`CH_04.用Visual Studio.net来操控Java虚拟机.pdf`、`CH_06.Ant....

    java classloader classpath 张孝祥

    ### Java ClassLoader与ClassPath详解 #### 一、概述 在Java编程中,类加载机制是十分关键的一个环节。类加载器(`ClassLoader`)负责将编译后的`.class`文件加载到Java虚拟机(JVM)中执行,而类路径(`ClassPath...

    Java ClassLoader原理

    ### Java ClassLoader原理详解 #### 摘要 本文探讨了Java虚拟机(JVM)中的一个重要特性:动态类加载(Dynamic Class Loading)。这一机制为Java平台提供了强大的能力,允许在运行时安装软件组件,例如从网络下载...

    Java ClassLoader学习总结

    Java 类加载机制是一个非常复杂的机制,它涉及到多个 ClassLoader 的交互和协作。了解 Java 类加载机制可以帮助我们更好地理解 Java 的运行机制,并且可以帮助我们更好地编写 Java 程序。 知识点总结: * Java 类...

    Understanding the Java ClassLoader

    ### Java ClassLoader理解详解 #### 一、引言 在商业流行的编程语言中,Java以其独特的运行机制脱颖而出:它在Java虚拟机(JVM)上运行。这意味着编译后的程序采用一种特殊的、与平台无关的格式,而不是针对特定...

    Java ClassLoader Tutorial.zip

    3. 双亲委派模型:Java的类加载机制遵循双亲委派模型,即当一个类加载器接收到加载类的请求时,它首先会委托父类加载器去尝试加载,只有当父类加载器无法加载时,当前类加载器才会尝试自己加载。 二、ClassLoader ...

    ClassLoader运行机制 自己写的

    理解ClassLoader的工作机制对于深入掌握Java应用程序的运行至关重要。这里我们将详细讨论ClassLoader的运行机制,特别是自定义ClassLoader的设计与实现。 ClassLoader的基本职责是根据类名动态加载对应的类文件。在...

    java classloader讲义-淘宝网

    通过对Java ClassLoader的深入了解,我们可以更好地理解Java类的加载机制以及如何通过自定义ClassLoader来满足特定的应用需求。淘宝网的成功实践为我们提供了宝贵的参考案例,展示了ClassLoaders在实际项目中的重要...

    java classLoader 的全面讲解

    Java 类加载器(ClassLoader)是Java虚拟机(JVM)中的一个重要组成部分,它负责加载类的字节码文件,使得程序能够运行。深入理解ClassLoader对于优化应用性能、处理类加载问题以及实现自定义加载策略至关重要。 一...

    classloader-playground, 一个简单的java依赖隔离容器类.zip

    总的来说,"classloader-playground"是一个实践和研究Java类加载机制的实用工具。通过这个项目,开发者不仅可以深入了解Java虚拟机的工作原理,还能掌握如何定制类加载器以满足特定场景的需求,提升系统的灵活性和可...

    了解Java ClassLoader

    下面将详细介绍Java ClassLoader的基本概念、工作流程、类加载机制以及自定义ClassLoader。 1. **ClassLoader基本概念** - ClassLoader是一个Java类,用于动态加载Java类到JVM中。Java程序中的每个类都由某个...

Global site tag (gtag.js) - Google Analytics