ClassLoader类加载机制

类加载流程

Class1,Class2-> MyClassLoader1, MyClassLoader2, MyThreadClassLoader1,MyThreadClassLoader2 -> AppClassLoader -> ExtClassLoader -> BootStrap

 

每个类加载器方法流程

loadClass-> findClass -> defineClass(C++)

 

名称	描述	实现
Bootstrap	JVM内核，加载Jre/lib/rt.jar	C++,BootStrap
Extension	加载Jre/lib/ext/*.jar	Java,ExtClassLoader
Application	加载classpath指定位置，系统或应用类加载	Java,AppClassLoader
Custom	自定义类的加载器，加载自定义位置class	Java
Custom Thread	自定义线程类加载器	Java

 

Launcher$ExtClassLoader和Launcher$AppClassLoader都是URLClassLoader的子类。

父类委托机制：一个类需要被加载的时候，JVM先会调用他的父类加载器进行加载（父类加载器，不一定他们之间是继承的关系，有可能仅仅是包装的关系）。如果父类加载器加载不了，再使用其子类进行加载。如果所有父类加载器都无法加载，再通过用户自定义的findClass方法进行加载。

JVM中类用全名和ClassLoader的实例作为唯一标识（包名,类名,ClassLoader实例名）.

注：不要重写loadClass方法，如果重写了loadClass方法，就会导致jvm使用MyClassLoader来加载Object、String等等一些类。

<例子>

Animal.java

package com.test;

public class Animal {

	public void say(){
        System.out.println("hello world 2~~~");
    }
	
}

ClassLoaderTest02.java

package com.test;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

public class ClassLoaderTest02 extends ClassLoader {

	private String path; // 加载类的路径
	private final String fileType = ".class"; // .class文件扩展名

	public ClassLoaderTest02(){
	}
	public ClassLoaderTest02(ClassLoader parent){
		super(parent);
	}
	public void setPath(String path) {
		this.path = path;
	}

	/**
	 * 读取class文件作为二进制流放入到byte数组中去
	 * 
	 * @param name
	 * @return
	 */
	private byte[] loadClassData(String name) {
		System.out.println("loadClassData~~~");
		InputStream in = null;
		byte[] data = null;
		ByteArrayOutputStream baos = null;

		try {
			name = name.replace(".", "\\");
			in = new BufferedInputStream(new FileInputStream(new File(path
					+ name + fileType)));
			baos = new ByteArrayOutputStream();
			int ch = 0;
			while (-1 != (ch = in.read())) {
				baos.write(ch);
			}
			data = baos.toByteArray();
		} catch (Exception e) {

			e.printStackTrace();
		} finally {
			try {
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				try {
					baos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return data;
	}

	/**
	 * 定义class对应的命名空间
	 */
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		System.out.println("findClass~~~");
		byte[] data = this.loadClassData(name);
		return this.defineClass(name, data, 0, data.length);
	}

	public static void main(String[] args) throws Exception {
		ClassLoaderTest02 loader1 = new ClassLoaderTest02();
		ClassLoaderTest02 loader2 = new ClassLoaderTest02(loader1);
		// test01(loader1);  // getParent~~~:com.test.AppClassLoader
		// test01(loader2);  // getParent~~~:com.test.ClassLoaderTest02
		// test02(loader1);  // 自定義, loadClass > findClass > defineClass
		// test03(loader1);  // 自定義, findClass > defineClass
		// test04(loader1);  // 加载不同版本同名jar包
		test05(loader1);  // web环境
	}

	/**
	 * 正常使用AppClassLoader
	 */
	public static void test01(ClassLoaderTest02 loader) throws Exception {
		loader.setPath("D://workspace//java//javaTest" + "//bin//");
		System.out.println("classLoader~~~:" + 
			ClassLoaderTest02.class.getClassLoader().getClass().getName());
		System.out.println("getParent~~~:" + 
			loader.getParent().getClass().getName());
		Class<?> clazz = loader.loadClass("com.test.Animal"); // AppClassLoader
		System.out.println("clazz~~~:"
				+ clazz.getClassLoader().getClass().getName());
		// System.out.println("Animal~~~:" + Animal.class.getClassLoader());
		// Animal animal=(Animal) clazz.newInstance();
		// animal.say();
		Object animalObj = clazz.newInstance();
		Method animalSay = clazz.getMethod("say");
		animalSay.invoke(animalObj);
	}
	
	/**
	 * 使用自定義ClassLoader
	 * 注：（1）需要先屏蔽classpath下的Animal.class（如重命名）；（2）copy .class到其它目錄（如D:\temp1）
	 */
	public static void test02(ClassLoaderTest02 loader) throws Exception {
		loader.setPath("D://temp1//");
		System.out.println("classLoader~~~:" + 
			ClassLoaderTest02.class.getClassLoader().getClass().getName());
		System.out.println("getParent~~~:" + 
			loader.getParent().getClass().getName());
		Class<?> clazz = loader.loadClass("com.test.Animal"); // ClassLoaderTest02
		System.out.println("clazz~~~:" + 
			clazz.getClassLoader().getClass().getName());
		Object animalObj = clazz.newInstance(); // classloader不一致, 通过reflect调用
		Method animalSay = clazz.getMethod("say");
		animalSay.invoke(animalObj);
	}
	
	/**
	 * 使用自定義ClassLoader
	 * 注：（1）不需要屏蔽classpath下的Animal.class；（2）copy .class到其它目錄（如D:\temp1）
	 */
	public static void test03(ClassLoaderTest02 loader) throws Exception {
		loader.setPath("D://temp1//");
		System.out.println("classLoader~~~:" + 
			ClassLoaderTest02.class.getClassLoader().getClass().getName());
		System.out.println("getParent~~~:" + 
			loader.getParent().getClass().getName());
		Class<?> clazz = loader.findClass("com.test.Animal"); // 直接调用
		System.out.println("clazz~~~:" + 
			clazz.getClassLoader().getClass().getName());
		Object animalObj = clazz.newInstance(); // classloader不一致, 通过reflect调用
		Method animalSay = clazz.getMethod("say");
		animalSay.invoke(animalObj);
	}
	
	/**
	 * 使用自定義ClassLoader，加载不同版本同名jar包
	 * 注：（1）需要先屏蔽classpath下的Animal.class（如重命名）；（2）copy .class到其它目錄（如\jar）
	 */
	public static void test04(ClassLoaderTest02 loader) throws Exception {
		URL url1 = new URL("file:D://workspace//jar//Animal-0.0.1.jar");  // 输出为"hello world 1！"
		URL url2 = new URL("file:D://workspace//jar//Animal-0.0.2.jar");  // 输出为"hello world 2~~~"
		URLClassLoader myClassLoader1  =   new  URLClassLoader( new  URL[]   { url1 } );
		URLClassLoader myClassLoader2  =   new  URLClassLoader( new  URL[]   { url2 } );
		System.out.println("myClassLoader1~~~" + myClassLoader1.getClass());
		Class<?> clazz1  =  myClassLoader1.loadClass("com.test.Animal");
		Class<?> clazz2  =  myClassLoader2.loadClass("com.test.Animal");
		Object animalObj1 = clazz1.newInstance();
		Object animalObj2 = clazz2.newInstance();
		Method animalSay1 = clazz1.getMethod("say");
		Method animalSay2 = clazz2.getMethod("say");
		animalSay1.invoke(animalObj1);
		animalSay2.invoke(animalObj2);
	}
	
	/**
	 * web环境
	 * JVM中类用全名和ClassLoader的实例作为唯一标识
	 * 参考：CSDN -> "Peter_K的专栏" -> "ClassLoader解决jar包冲突问题"
	 */
	public static void test05(ClassLoaderTest02 loader) throws Exception {
		URL url1 = new URL("file:D://workspace//jar//Animal-0.0.1.jar");
		System.out.println("ContextClassLoader~~~" + Thread.currentThread().getContextClassLoader());
		System.out.println("ContextClassLoader-getParent~~~" + 
			Thread.currentThread().getContextClassLoader().getParent()); 
		URLClassLoader myClassLoader1  =   new  URLClassLoader( new  URL[]   { url1 } , 
			Thread.currentThread().getContextClassLoader());  // 当前线程类加载器
		System.out.println("myClassLoader1~~~" + myClassLoader1.getClass());
		Class<?> clazz1  =  myClassLoader1.loadClass("com.test.Animal");
		Object animalObj1 = clazz1.newInstance();
		Method animalSay1 = clazz1.getMethod("say");
		animalSay1.invoke(animalObj1);
	}
	
	/*
	 * 更多参考：
	 * 1）ITEye -> "classloader 加载同名类问题"
	 * 2）http://blog.csdn.net/is_zhoufeng/article/details/26602689
	 */
}

文件位置