精华内容
下载资源
问答
  • 获得classLoader的途径

    2019-06-21 16:35:15
    获得当前类的ClassLoader clazz.getClassLoader(); 获得当前线程上下文的ClassLoader Thread.currentThread().getContextClassLoader(); 获得系统的ClassLoader ClassLoader.getSystemClassLoader(); 获得调用者的...

    获得当前类的ClassLoader

    clazz.getClassLoader();

    获得当前线程上下文的ClassLoader

    Thread.currentThread().getContextClassLoader();

    获得系统的ClassLoader

    ClassLoader.getSystemClassLoader();

    获得调用者的ClassLoader

    DriverManager.getCallerClassLoader();

    展开全文
  • 获得当前类的ClassLoader clazz.getClassLoader() 获得当前线程上下文的ClassLoader Thread.currentThread().getContextClassLoader(); 获得系统的ClassLoader ClassLoader.getSystemClassLoader(...

    获得ClassLoader的途径

    • 获得当前类的ClassLoader
      • clazz.getClassLoader()
    • 获得当前线程上下文的ClassLoader
      • Thread.currentThread().getContextClassLoader();
    • 获得系统的ClassLoader
      • ClassLoader.getSystemClassLoader()
    • 获得调用者的ClassLoader
      • DriverManager.getCallerClassLoader

    ClassLoader源码解析

    概述

    类加载器是用于加载类的对象,ClassLoader是一个抽象类。如果我们给定了一个类的二进制名称,类加载器应尝试去定位或生成构成定义类的数据。一种典型的策略是将给定的二进制名称转换为文件名,然后去文件系统中读取这个文件名所对应的class文件。

    每个Class对象都会包含一个定义它的ClassLoader的一个引用。

    数组类的Class对象,不是由类加载器去创建的,而是在Java运行期JVM根据需要自动创建的。对于数组类的类加载器来说,是通过Class.getClassLoader()返回的,与数组当中元素类型的类加载器是一样的;如果数组当中的元素类型是一个原生类型,数组类是没有类加载器的【代码一】。

    应用实现了ClassLoader的子类是为了扩展JVM动态加载类的方式。

    类加载器典型情况下时可以被安全管理器所使用去标识安全域问题。

    ClassLoader类使用了委托模型来寻找类和资源,ClassLoader的每一个实例都会有一个与之关联的父ClassLoader,当ClassLoader被要求寻找一个类或者资源的时候,ClassLoader实例在自身尝试寻找类或者资源之前会委托它的父类加载器去完成。虚拟机内建的类加载器,称之为启动类加载器,是没有父加载器的,但是可以作为一个类加载器的父类加载器【双亲委托机制】。

    支持并发类加载的类加载器叫做并行类加载器,要求在初始化期间通过ClassLoader.registerAsParallelCapable 方法注册自身,ClassLoader类默认被注册为可以并行,但是如果它的子类也是并行加载的话需要单独去注册子类。

    在委托模型不是严格的层次化的环境下,类加载器需要并行,否则类加载会导致死锁,因为加载器的锁在类加载过程中是一直被持有的。

    通常情况下,Java虚拟机以平台相关的形式从本地的文件系统中加载类,比如在UNIX系统,虚拟机从CLASSPATH环境所定义的目录加载类。
    然而,有些类并不是来自于文件;它们是从其它来源得到的,比如网络,或者是由应用本身构建【动态代理】。定义类(defineClass )方法会将字节数组转换为Class的实例,这个新定义类的实例可以由Class.newInstance创建。

    由类加载器创建的对象的方法和构造方法可能引用其它的类,为了确定被引用的类,Java虚拟机会调用最初创建类的类加载器的loadClass方法。

    二进制名称:以字符串参数的形式向CalssLoader提供的任意一个类名,必须是一个二进制的名称,包含以下四种情况

    • "java.lang.String" 正常类
    • "javax.swing.JSpinner$DefaultEditor" 内部类
    • "java.security.KeyStore\(Builder\)FileBuilder$1" KeyStore的内部类Builder的内部类FileBuilder的第一个匿名内部类
    • "java.net.URLClassLoader$3$1" URLClassLoader类的第三个匿名内部类的第一个匿名内部类

    代码一:

    public class Test12 {
        public static void main(String[] args) {
            String[] strings = new String[6];
            System.out.println(strings.getClass().getClassLoader());
            // 运行结果:null
    
            Test12[] test12s = new Test12[1];
            System.out.println(test12s.getClass().getClassLoader());
            // 运行结果:sun.misc.Launcher$AppClassLoader@18b4aac2
    
            int[] ints = new int[2];
            System.out.println(ints.getClass().getClassLoader());
            // 运行结果:null
        }
    }

    loadClass方法

    loadClass的源码如下, loadClass方法加载拥有指定的二进制名称的Class,默认按照如下顺序寻找类:

    • 调用findLoadedClass(String)检查这个类是否被加载
    • 调用父类加载器的loadClass方法,如果父类加载器为null,就会调用启动类加载器
    • 调用findClass(String)方法寻找

    使用上述步骤如果类被找到且resolve为true,就会去调用resolveClass(Class)方法

    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;
      }
    }

    findClass方法

    findClass的源码如下,findClass寻找拥有指定二进制名称的类,JVM鼓励我们重写此方法,需要自定义加载器遵循双亲委托机制,该方法会在检查完父类加载器之后被loadClass方法调用,默认返回ClassNotFoundException异常。

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

    defineClass方法

    defineClass的源码如下,defineClass方法将一个字节数组转换为Class的实例。

    protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                         ProtectionDomain protectionDomain)
        throws ClassFormatError
    {
        protectionDomain = preDefineClass(name, protectionDomain);
        String source = defineClassSourceLocation(protectionDomain);
        Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
        postDefineClass(c, protectionDomain);
        return c;
    }

    自定义类加载器

    /**
     * 继承了ClassLoader,这是一个自定义的类加载器
     * @author 夜的那种黑丶
     */
    public class ClassLoaderTest extends ClassLoader {
        public static void main(String[] args) throws Exception {
            ClassLoaderTest loader = new ClassLoaderTest("loader");
           Class<?> clazz = loader.loadClass("classloader.Test01");
            Object object = clazz.newInstance();
            System.out.println(object);
            System.out.println(object.getClass().getClassLoader());
        }
        //------------------------------以上为测试代码---------------------------------
    
        /**
         * 类加载器名称,标识作用
         */
        private String classLoaderName;
    
        /**
         * 从磁盘读物字节码文件的扩展名
         */
        private String fileExtension = ".class";
    
        /**
         * 创建一个类加载器对象,将系统类加载器当做该类加载器的父加载器
         * @param classLoaderName 类加载器名称
         */
        private ClassLoaderTest(String classLoaderName) {
            // 将系统类加载器当做该类加载器的父加载器
            super();
            this.classLoaderName = classLoaderName;
        }
    
        /**
         * 创建一个类加载器对象,显示指定该类加载器的父加载器
         * 前提是需要有一个类加载器作为父加载器
         * @param parent 父加载器
         * @param classLoaderName 类加载器名称
         */
        private ClassLoaderTest(ClassLoader parent, String classLoaderName) {
            // 显示指定该类加载器的父加载器
            super(parent);
            this.classLoaderName = classLoaderName;
        }
    
        /**
         * 寻找拥有指定二进制名称的类,重写ClassLoader类的同名方法,需要自定义加载器遵循双亲委托机制
         * 该方法会在检查完父类加载器之后被loadClass方法调用
         * 默认返回ClassNotFoundException异常
         * @param className 类名
         * @return Class的实例
         * @throws ClassNotFoundException 如果类不能被找到,抛出此异常
         */
        @Override
        protected Class<?> findClass(String className) throws ClassNotFoundException {
            byte[] data = this.loadClassData(className);
            /*
             * 通过defineClass方法将字节数组转换为Class
             * defineClass:将一个字节数组转换为Class的实例,在使用这个Class之前必须要被解析
             */
            return this.defineClass(className, data, 0 , data.length);
        }
    
        /**
         * io操作,根据类名找到对应文件,返回class文件的二进制信息
         * @param className 类名
         * @return class文件的二进制信息
         * @throws ClassNotFoundException 如果类不能被找到,抛出此异常
         */
        private byte[] loadClassData(String className) throws ClassNotFoundException {
            InputStream inputStream = null;
            byte[] data;
            ByteArrayOutputStream byteArrayOutputStream = null;
    
            try {
                this.classLoaderName = this.classLoaderName.replace(".", "/");
                inputStream = new FileInputStream(new File(className + this.fileExtension));
                byteArrayOutputStream = new ByteArrayOutputStream();
    
                int ch;
                while (-1 != (ch = inputStream.read())) {
                    byteArrayOutputStream.write(ch);
                }
    
                data = byteArrayOutputStream.toByteArray();
            } catch (Exception e) {
                throw new ClassNotFoundException();
            } finally {
                try {
                    if (inputStream != null) {
                        inputStream.close();
                    }
                    if (byteArrayOutputStream != null) {
                        byteArrayOutputStream.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return data;
        }
    }

    以上是一段自定义类加载器的代码,我们执行这段代码

    classloader.Test01@7f31245a
    sun.misc.Launcher$AppClassLoader@18b4aac2

    可以看见,这段代码中进行类加载的类加载器还是系统类加载器(AppClassLoader)。这是因为jvm的双亲委托机制造成的,private ClassLoaderTest(String classLoaderName)将系统类加载器当做我们自定义类加载器的父加载器,jvm的双亲委托机制使自定义类加载器委托系统类加载器完成加载。

    改造以下代码,添加一个path属性用来指定类加载位置:

    public class ClassLoaderTest extends ClassLoader {
        public static void main(String[] args) throws Exception {
            ClassLoaderTest loader = new ClassLoaderTest("loader");
            loader.setPath("/home/fanxuan/Study/java/jvmStudy/out/production/jvmStudy/");
            Class<?> clazz = loader.loadClass("classloader.Test01");
            System.out.println("class:" + clazz);
    
            Object object = clazz.newInstance();
            System.out.println(object);
            System.out.println(object.getClass().getClassLoader());
        }
        //------------------------------以上为测试代码---------------------------------
    
        /**
         * 从指定路径加载
         */
        private String path;
    
        ......
        
        /**
         * io操作,根据类名找到对应文件,返回class文件的二进制信息
         * @param className 类名
         * @return class文件的二进制信息
         * @throws ClassNotFoundException 如果类不能被找到,抛出此异常
         */
        private byte[] loadClassData(String className) throws ClassNotFoundException {
            InputStream inputStream = null;
            byte[] data;
            ByteArrayOutputStream byteArrayOutputStream = null;
    
            className = className.replace(".", "/");
    
            try {
                this.classLoaderName = this.classLoaderName.replace(".", "/");
                inputStream = new FileInputStream(new File(this.path + className + this.fileExtension));
                byteArrayOutputStream = new ByteArrayOutputStream();
    
                int ch;
                while (-1 != (ch = inputStream.read())) {
                    byteArrayOutputStream.write(ch);
                }
    
                data = byteArrayOutputStream.toByteArray();
            } catch (Exception e) {
                throw new ClassNotFoundException();
            } finally {
                try {
                    if (inputStream != null) {
                        inputStream.close();
                    }
                    if (byteArrayOutputStream != null) {
                        byteArrayOutputStream.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return data;
        }
    
        public void setPath(String path) {
            this.path = path;
        }
    }

    运行一下

    class:class classloader.Test01
    classloader.Test01@7f31245a
    sun.misc.Launcher$AppClassLoader@18b4aac2

    修改一下测试代码,并删除工程下的Test01.class文件

    public static void main(String[] args) throws Exception {
        ClassLoaderTest loader = new ClassLoaderTest("loader");
       loader.setPath("/home/fanxuan/桌面/");
        Class<?> clazz = loader.loadClass("classloader.Test01");
        System.out.println("class:" + clazz);
    
        Object object = clazz.newInstance();
        System.out.println(object);
        System.out.println(object.getClass().getClassLoader());
    }

    运行一下

    class:class classloader.Test01
    classloader.Test01@135fbaa4
    classloader.ClassLoaderTest@7f31245a

    分析

    改造后的两块代码,第一块代码中加载类的是系统类加载器AppClassLoader,第二块代码中加载类的是自定义类加载器ClassLoaderTest。是因为ClassLoaderTest会委托他的父加载器AppClassLoader加载class,第一块代码的path直接是工程下,AppClassLoader可以加载到,而第二块代码的path在桌面目录下,所以AppClassLoader无法加载到,然后ClassLoaderTest自身尝试加载并成功加载到。如果第二块代码工程目录下的Test01.class文件没有被删除,那么依然是AppClassLoader加载。

    再来测试一块代码

    public static void main(String[] args) throws Exception {
        ClassLoaderTest loader = new ClassLoaderTest("loader");
        loader.setPath("/home/fanxuan/Study/java/jvmStudy/out/production/jvmStudy/");
        Class<?> clazz = loader.loadClass("classloader.Test01");
        System.out.println("class:" + clazz.hashCode());
    
        Object object = clazz.newInstance();
        System.out.println(object.getClass().getClassLoader());
    
        ClassLoaderTest loader2 = new ClassLoaderTest("loader");
        loader2.setPath("/home/fanxuan/Study/java/jvmStudy/out/production/jvmStudy/");
        Class<?> clazz2 = loader2.loadClass("classloader.Test01");
        System.out.println("class:" + clazz2.hashCode());
    
        Object object2 = clazz2.newInstance();
        System.out.println(object2.getClass().getClassLoader());
    }

    结果显而易见,类由系统类加载器加载,并且clazz和clazz2是相同的。

    class:2133927002
    sun.misc.Launcher$AppClassLoader@18b4aac2
    class:2133927002
    sun.misc.Launcher$AppClassLoader@18b4aac2

    在改造一下

    public static void main(String[] args) throws Exception {
        ClassLoaderTest loader = new ClassLoaderTest("loader");
        loader.setPath("/home/fanxuan/桌面/");
        Class<?> clazz = loader.loadClass("classloader.Test01");
        System.out.println("class:" + clazz.hashCode());
    
        Object object = clazz.newInstance();
        System.out.println(object.getClass().getClassLoader());
    
        ClassLoaderTest loader2 = new ClassLoaderTest("loader2");
        loader2.setPath("/home/fanxuan/桌面/");
        Class<?> clazz2 = loader2.loadClass("classloader.Test01");
        System.out.println("class:" + clazz2.hashCode());
    
        Object object2 = clazz2.newInstance();
        System.out.println(object2.getClass().getClassLoader());
    }

    运行结果

    class:325040804
    classloader.ClassLoaderTest@7f31245a
    class:621009875
    classloader.ClassLoaderTest@45ee12a7

    ClassLoaderTest是显而易见,但是clazz和clazz2是不同的,这是因为类加载器的命名空间的原因。

    我们可以通过设置父类加载器来让loader和loader2处于同一命名空间

    public static void main(String[] args) throws Exception {
        ClassLoaderTest loader = new ClassLoaderTest("loader");
        loader.setPath("/home/fanxuan/桌面/");
        Class<?> clazz = loader.loadClass("classloader.Test01");
        System.out.println("class:" + clazz.hashCode());
    
        Object object = clazz.newInstance();
        System.out.println(object.getClass().getClassLoader());
    
        ClassLoaderTest loader2 = new ClassLoaderTest(loader, "loader2");
        loader2.setPath("/home/fanxuan/桌面/");
        Class<?> clazz2 = loader2.loadClass("classloader.Test01");
        System.out.println("class:" + clazz2.hashCode());
    
        Object object2 = clazz2.newInstance();
        System.out.println(object2.getClass().getClassLoader());
    }

    运行结果

    class:325040804
    classloader.ClassLoaderTest@7f31245a
    class:325040804
    classloader.ClassLoaderTest@7f31245a

    扩展:命名空间

    • 每个类加载器都有自己的命名空间,命名空间由该加载器及所有的父加载器所加载的类组成
    • 在同一命名空间中,不会出现类的完整名字(包括类的包名)相同的两个类
    • 在不同的命名空间中,有可能会出现类的完整名字(包括类的包名)相同的两个类
    展开全文
  • 加载机制之ContextClassLoader

    千次阅读 2017-09-16 16:20:19
    基础知识点 知识点1: 每个ClassLoader都只能加载自己所绑定目录下的资源; 知识点2: 加载资源时的ClassLoader可以有多种选择: ... 当前ClassLoader:加载了当前类的ClassLoader;  3. 线程...

    基础知识点

    知识点1: 每个ClassLoader都只能加载自己所绑定目录下的资源;
    知识点2: 加载资源时的ClassLoader可以有多种选择:
       1. 系统类加载器SystemClassLoader,可通过ClassLoader.getSystemClassLoader()获得;
       2. 当前ClassLoader:加载了当前类的ClassLoader;
       3. 线程上下文类加载器ContextClassLoader:Thread.currentThread().getContextClassLoader();
       4. 自定义类加载器;

    ContextClassLoader作用

      加载类或资源的手段之一,只不过在一些场景下成为了唯一可选手段,从而显得特别重要,比如在JDK的SPI接口中加载SPI实现类,插件的加载等,下面以JDBC驱动的加载过程为例进行说明。

    JDBC驱动的加载过程

    应用程序加载驱动的方式如下:
    这里写图片描述

    1. 调用Class.forName()加载mysql的驱动,由于调用类SpiTest在classpath路径上,因此使用使用SystemClassLoader加载类”com.mysql.jdbc.Driver”;
    2. 加载过程中会执行static语句块,将驱动实例注册到DriverManager中,此时会涉及到DriverManager类的加载,如下图所示:
      这里写图片描述
    3. DriverManager类的加载也会执行static语句块,逻辑是使用ServiceLoader机制加载各种JDBC驱动,如下图所示:
      这里写图片描述
    4. 最终调用ServiceLoader.load()方法加载驱动,此时就只能使用ContextClassLoader进行加载,如下图所示:
      这里写图片描述
      原因是:当前类加载器(DriverManager类的加载器)为启动类加载器,只能加载JDK核心类,当然也无法在JDK中创建自定义的ClassLoader,因此可选的ClassLoader只有两种,即SystemClassLoader和ContextClassLoader。但是SystemClassLoader只能加载classpath路径下的驱动,有局限性。ContextClassLoader没有局限性,可以在应用程序中将其设为任意ClassLoader,加载任意目录下的类和资源,如下图所示:
      这里写图片描述
    展开全文
  • 获取ClassLoader的方法

    2019-10-06 02:26:43
    对于一般的java类如下两种方法获得的ClassLoader通常都是同一个 ...//使用当前类的ClassLoader 2. Thread.currentThread().getContextClassLoader();//使用当前线程的ClassLoader 3. ClassLoader.getS...

    对于一般的java类如下两种方法获得的ClassLoader通常都是同一个

      1. this.getClass.getClassLoader(); // 使用当前类的ClassLoader  
      2. Thread.currentThread().getContextClassLoader(); // 使用当前线程的ClassLoader  
      3. ClassLoader.getSystemClassLoader(); // 使用系统ClassLoader,即系统的入口点所使用的ClassLoader。

    (注意,system ClassLoader与根ClassLoader并不一样。JVM下system ClassLoader通常为App ClassLoader)  

    转载于:https://www.cnblogs.com/alisonGavin/p/6881900.html

    展开全文
  • 获得当前类的ClassLoader :clazz.getClassLoader() 获得当前线程上下文的ClassLoader:Thread.currentThread().getContextClassLoader(); 获得系统的ClassLoader:ClassLoader.getSystemClassLoader() 获得调用者的...
  • 1、类加载器层级显示 以下代码可以展示加载器的层级 public class MyTest14 { public static void main... // 获得当前类的classloader ClassLoader classLoader = ClassLoader.getSystemClassLoader(); S...
  • 获得ClassLoader的几种方法可以通过如下3种方法得到ClassLoader  ... // 使用当前类的ClassLoader  Thread.currentThread().getContextClassLoader(); // 使用当前线程的ClassLoader  ClassLoader.getSystemCla
  • Java获得当前类class所在路径

    千次阅读 2018-07-25 22:22:03
    public static String getAppPath(Class cls){ //检查用户传入参数是否为空 if(cls==null){ throw new java.lang.IllegalArgumentException("参数不能为空!... ClassLoader loader=...
  • 获得当前类的ClassLoader clazz.getClassLoader() 获得当前线程上下文的ClassLoader Thread.currentThread().getContextClassLoader() 获得系统的ClassLoader ClassLoader.getSystemClassLoader() 获...
  • ClassLoader

    2021-02-02 17:48:39
    // 使用当前类的ClassLoader  2. Thread.currentThread().getContextClassLoader(); // 使用当前线程的ClassLoader  3. ClassLoader.getSystemClassLoader(); // 使用系统ClassLoader,即系统的入口点所使用
  • ClassLoader加载资源

    千次阅读 2005-03-15 20:55:00
    比如ClassLoader.getSystemResource("xxx")返回当前类路径下的某个资源的URL。用法有很多,也可以是ClassLoader.getSystemClassLoader().getResource();也可以用自定义的ClassLoader来实现从其他位置加载资源,即用U
  • 类的加载器下篇

    2020-12-28 19:40:13
    获取当前类的 ClassLoader clazz.getClassLoader(); 获得当前线程上下文的 ClassLoader Thread.currentThread().getContextClassLoader(); 获得系统的 ClassLoader ClassLoader.getSystemClassLoader(); 说明: ...
  • 反射在很多时候要用,尤其自己编写框架时,那么如何获得当前项目下所有呢!以下是本人封装一个比较简洁方法: 【功能代码】 //通过loader加载所有 private List<Class> loadClassByLoader...
  • 1使用new  new className()  2 使用 Class.forName("classPath") 3 使用classLoader ...1 使用new 只能加载当前classPath 中的类 使用一种静态加载方式 2 使用Class.forName() 动...
  • java获取当前路径几种方法

    千次阅读 2017-10-25 18:36:51
    使用idea 进行junit test调试,如果用System.getProperty(“user.dir”)得到目录是项目目录,而此时配置文件实在“user.dir” /target/test-classes/ 这个目录下,因此好用,classloader获得类路径,这样还可以...
  • 反射与加载器

    2020-07-14 22:27:13
    ClassLoader:在JVM启动过程中,把模板加载到内存中工具。就是将一个存在与系统文件中.class文件,加载到当前JVM内存中,变成java能识别Class类型。 启动项加载器:由C语言完成,当JV
  • spring加载xml

    2016-04-12 17:44:00
    加载文件顺序 情形一:使用classpath加载且不含通配符 这是最简单的情形,Spring默认会使用当前线程的ClassLoader的getResource方法获取资源的URL,如果无法获得当前线程的ClassLoader,Spring将使用加载org....
  • Spring加载XML机制

    2015-11-06 11:47:04
    这是最简单的情形,Spring默认会使用当前线程的ClassLoader的getResource方法获取资源的URL,如果无法获得当前线程的ClassLoader,Spring将使用加载org.springframework.util.ClassUtils的ClassLoader。...
  • spring 加载xml机制

    2014-02-27 21:00:45
    这是最简单的情形,Spring默认会使用当前线程的ClassLoader的getResource方法获取资源的URL,如果无法获得当前线程的ClassLoader,Spring将使用加载org.springframework.util.ClassUtils的ClassLoader。...
  • JVM MAT使用分析详解

    千次阅读 2018-04-17 15:11:19
    在进行内存分析时,只要获得了反映当前设备内存映像hprof文件,通过MAT打开就可以直观地看到当前的内存信息。一般说来,这些内存信息包含:所有对象信息,包括对象实例、成员变量、存储于栈中基本类型值和存储...
  • Spring加载XML机制(转)

    千次阅读 2013-11-20 21:49:07
    Spring加载XML机制(转) ...这是最简单的情形,Spring默认会使用当前线程的ClassLoader的getResource方法获取资源的URL,如果无法获得当前线程的ClassLoader,Spring将使用加载org.springfra
  • // 取得配置文件中的数值 public static String getStrname(String prpertiesname, String key) throws IOException {// 配置类的声明 ...//利用当前类的加载获得配置文件名称 p.load(ClassLoader.getSystemReso
  • 说来动态加载资源时,往往需要从三种类加载器里选择:系统或说程序类加载器、当前类加载器、以及当前线程上下文类加载器。在程序中应该使用何种类加载器呢? 系统类加载器通常不会使用。此类加载器处理...
  • wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。 17、...
  • 在进行内存分析时,只要获得了反映当前设备内存映像hprof文件,通过MAT打开就可以直观地看到当前的内存信息。一般说来,这些内存信息包含: 所有对象信息,包括对象实例、成员变量、存储于栈中基本类型值和...
  • 安全管理器让java代码访问外部资源时候受到一层过滤。就像classloader和class文件检验器是检测java文件一样,从...要获得当前的安全管理器,可以使用方法getSecurityManager。 java.lang.SecurityManager包含了很多
  • java安全管理器

    2014-06-16 09:42:52
    为什么要有安全管理器? 安全管理器让java代码访问外部资源时候受到一层过滤。就像classloader和class文件检验器是检测java文件...要获得当前的安全管理器,可以使用方法getSecurityManager。  java.lang.Security

空空如也

空空如也

1 2
收藏数 35
精华内容 14
关键字:

获得当前类的classloader