Java 之 类加载器对象—ClassLoader

一、获取 ClassLoader 对象

　　获取某个类的类加载对象需要两步：

　　① 获取某个类的 Class  对象；

　　② 通过 Class 对象调用 getClassLoader() 方法获取类加载器对象

二、java.lang.ClassLoader 对象

　　ClassLoader 类是一个抽象类，学习一下 ClassLoader 的相关方法：

public final ClassLoader getParent()：返回委托的父类加载器。一些实现可能使用 null 来表示引导类加载器；
public static ClassLoader getSystemClassLoader()：返回委托的系统类加载器；
public Class<?> loadClass(String name)：使用指定的二进制名称（类的全限定名）来加载类。
　　　　例如：java.lang.String，注意内部类的名称：匿名内部类（外部类的全限定名$编号）、局部内部类（外部类的全限定名$编号+类名）、成员/静态内部类（外部类的全限定名$+类名）;
protected Class<?> findClass(String name)：使用指定的二进制名称（类的全限定名）来查找类。此方法应该被类加载器的实现重写，该实现按照委托模型来加载类。
　　　　　　　　　　　　　　　　　　　　　　　　　　在通过父类加载器检查所请求的类后，此方法将被 loadClass 方法调用;
protected final Class<?> findLoadedClass(String name)：返回Class 对象，如果类没有被加载，则返回 null;
protected final Class<?> defineClass(String name,byte[] b,int off,int len)：将一个 byte 数组转换为 Class 类的实例;

　　

 　　Demo：自定义类加载器示例

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class FileClassLoader extends ClassLoader{
    private String rootDir;//指定加载路径
    
    public FileClassLoader(String rootDir){
        this.rootDir = rootDir;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //首先检查请求的类型是否已经被这个类装载器装载到命名空间中了，如果已经被装载，直接返回；
        Class<?> c = findLoadedClass(name);
        
        if(c ==null){
            //委派类加载器请求给父类加载器，如果父类加载器能够完成，则返回父类加载器加载的Class实例；
            ClassLoader parent = this.getParent();
            try {
                c = parent.loadClass(name);
                //加异常处理，父类加载不到，然后自己加载
            } catch (Exception e) {
            }
            
            //调用本类加载器的findClass()方法，试图获取对应的字节码，如果获取的到，则调用defineClass()导入类型到方法区；
            //如果获取不到对应的字节码或其他原因失败，则异常，终止加载过程
            if(c == null){
                byte[] classData = getClassData(name);
                if(classData == null){
                    throw new ClassNotFoundException();
                }else{
                    c = defineClass(name, classData, 0, classData.length);
                }
            }
        }
        return c;
    }
    
    //把.class文件的内容读取到一个字节数组中
    //为什么要读取的字节数组中，因为protected final Class<?> defineClass(String name,byte[] b,int off,int len)
    private byte[] getClassData(String name) {
        String path = rootDir + File.separator + name.replace(".", File.separator)+".class";
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            is = new FileInputStream(path);
            baos =new ByteArrayOutputStream(); 
            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer))!=-1){
                baos.write(buffer, 0, len);
            }
            return baos.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(is!=null){
                    is.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

public class TestFileClassLoader {

    public static void main(String[] args) throws ClassNotFoundException {
        FileClassLoader fsc = new FileClassLoader("D:/java/code");
        Class<?> uc = fsc.loadClass("com.ks.UserManager");
        System.out.println(uc);
        
        Class<?> sc = fsc.loadClass("java.lang.String");
        System.out.println(sc);
        System.out.println(sc.getClassLoader());//null,因为委托给父类加载器...一直到引导类加载器
    }

}

三、类加载器加载资源文件

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

　　案例一：加载类路径（如：src 下）jdbc.properties 资源文件

　　　　　　扩展：SourceFolder：源代码文件夹，一般会单独用一个config这种SourceFolder来装配置文件、等价于src，不同于普通的 Folder

　　　　　   代码示例：

username=root
password=123456
url=jdbc:mysql://localhost:3306/test

package com.atguigu.loader;

import java.io.IOException;
import java.util.Properties;

public class TestLoaderProperties {
    public static void main(String[] args) {
        Properties pro = new Properties();
        try {
            pro.load(ClassLoader.getSystemResourceAsStream("jdbc.properties"));
            System.out.println(pro);
        } catch (IOException e) {
            e.printStackTrace();
        }
                System.out.println(pro);
        System.out.println(pro.getProperty("username"));
    }
}
        

　　案例二：获取存放在“com.ks.reflect” 包下面的 demo.properties 文件

　　　　　　代码示例：

　　@Test
    public void test() throws IOException{
        Properties pro = new Properties();//集合,map,key=value
        
        Class clazz = Test.class;   //获取本类的 Class 对象
        ClassLoader loader = clazz.getClassLoader();  //获取类加载器
        InputStream in = loader.getResourceAsStream("com/ks/reflect/demo.properties");
        
        pro.load(in);
        
        System.out.println(pro);
        System.out.println(pro.getProperty("name"));
    }

　　案例三：获取当前项目下的 out.properties 文件，不在 src 下面（这个文件没有在编译目录下，不需要使用类加载器）

　　　　　　代码示例：

　　 @Test
    public void test() throws IOException{
        Properties pro = new Properties(); 4         
        //在项目的根路径下，不在src里面
        pro.load(new FileInputStream("out.properties"));
        
        System.out.println(pro);
        System.out.println(pro.getProperty("out"));
    }