怎么在java中自定義一個類加載器

本篇文章為大家展示了怎么在java中自定義一個類加載器，內(nèi)容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。

如果要使用自定義類加載器加載class文件，就需要繼承java.lang.ClassLoader類。

ClassLoader有幾個重要的方法：

protectedClassLoader(ClassLoaderparent)：使用指定的、用于委托操作的父類加載器創(chuàng)建新的類加載器。

protectedfinalClass<?>defineClass(Stringname,byte[]b,intoff,intlen)：將一個byte數(shù)組轉(zhuǎn)換為Class類的實例。

protectedClass<?>findClass(Stringname)：使用指定的二進制名稱查找類。

publicClass<?>loadClass(Stringname)：使用指定的二進制名稱來加載類。

protectedfinalClass<?>findLoadedClass(Stringname)：如果Java虛擬機已將此加載器記錄為具有給定二進制名稱的某個類的啟動加載器，則返回該二進制名稱的類。否則，返回null。

publicfinalClassLoadergetParent()：返回委托的父類加載器。

protectedfinalvoidresolveClass(Class<?>c)：鏈接指定的類。

如果要遵循雙親委派模型，則重寫findClass(Stringname)方法；如果不想遵循雙親委派模型，則直接重寫loadClass(Stringname)方法。

自定義遵循雙親委派模型的類加載器

ParentsDelegateClassLoader.java

package com.zzj.classloader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/** 
 * 雙親委派類加載器，重寫findClass(name)方法 
 * 
 * @author Administrator 
 * 
 */
public class ParentsDelegateClassLoader extends ClassLoader {
	private static final String EXT = ".class";
	private String path;
	public ParentsDelegateClassLoader() {
		path = this.getResource("").getPath();
	}
	public ParentsDelegateClassLoader(String path) {
		this.path = path;
	}
	@Override 
	  protected Class<?> findClass(String name) throws ClassNotFoundException {
		byte[] b = null;
		try {
			b = loadClassFile(name);
		}
		catch (IOException e) {
			e.printStackTrace();
		}
		return this.defineClass(name, b, 0, b.length);
	}
	private byte[] loadClassFile(String name) throws IOException {
		String classFile = getClassFile(name);
		System.out.println("即將加載class文件" + classFile);
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		InputStream input = new FileInputStream(classFile);
		int count;
		byte[] temp = new byte[1024];
		while ((count = input.read(temp)) > -1) {
			out.write(temp, 0, count);
		}
		out.close();
		input.close();
		return out.toByteArray();
	}
	private String getClassFile(String name) {
		String pathName = name.replace(".", File.separator);
		if (path.endsWith("/") || path.endsWith("\\")) {
			return path + pathName + EXT;
		}
		return path + File.separator + pathName + EXT;
	}
}

現(xiàn)在類路徑classpath下和F:\\ClassloaderTest\\bin目錄下都有一個類文件com\zzj\classloader\User.class，包名為com.zzj.classloader，使用類加載器ParentsDelegateClassLoader加載F:\\ClassloaderTest\\bin下的類。

package com.zzj.classloader;
public class App {
	private static final String path = "F:\\ClassloaderTest\\bin";
	private static final String classname = "com.zzj.classloader.User";
	public static void main(String[] args) throws Exception {
		ParentsDelegateClassLoader classLoader = new ParentsDelegateClassLoader(path);
		Class<?> clazz = classLoader.loadClass(classname);
		System.out.println(clazz);
		System.out.println(clazz.getClassLoader());
	}
}

輸出：

class com.zzj.classloader.User 
sun.misc.Launcher$AppClassLoader@19821f

User類的加載器是系統(tǒng)類加載器AppClassLoader，而不是我們自己定義的類加載。實際上被加載不是F:\\ClassloaderTest\\bin下的類，而是classpath下的類。這就是雙親委派模型：當(dāng)ParentsDelegateClassLoader加載器接收到加載請求后，會先委托給父類加載器，如果父類加載器加載成功，則返回一個Class對象。如果加載失敗，才會讓接收到加載請求的類加載器加載。

把classpath下的User類刪掉測試運行：

即將加載class文件F:\ClassloaderTest\bin\com\zzj\classloader\User.class 
class com.zzj.classloader.User 
com.zzj.classloader.ParentsDelegateClassLoader@61de33

此時User類的加載為ParentsDelegateClassLoader。

這一點可以從ClassLoader的源碼中得到驗證：

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

調(diào)用了重載方法：

protected synchronized Class<?> loadClass(String name, boolean resolve) 
  throws ClassNotFoundException 
  { 
  // 先判斷該類是否已被當(dāng)前的類加載器加載 
  Class c = findLoadedClass(name); 
  if (c == null) { 
    try { 
    if (parent != null) {// 如果存在父類加載器，則委派給父類加載 
      c = parent.loadClass(name, false); 
    } else {// 如果父類加載為空，則其父類加載器為引導(dǎo)類加載器 
      c = findBootstrapClass0(name); 
    } 
    } catch (ClassNotFoundException e) { 
      // 如果父類加載器加載失敗，則自己加載，調(diào)用的就是findClass方法！ 
      c = findClass(name); 
    } 
  } 
  if (resolve) { 
    resolveClass(c); 
  } 
  return c; 
  }

可見，如果想要破壞雙親委派模型，可以直接重寫loadClass(Stringname)方法。

自定義不遵循雙親委派模型的類加載器

NotParentsDelegateClassLoader.java

package com.zzj.classloader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
/** 
 * 非雙親委派類加載器，重寫loadClass(name)方法 
 * 
 * @author Administrator 
 * 
 */
public class NotParentsDelegateClassLoader extends ClassLoader {
	private static final String EXT = ".class";
	private String path;
	public NotParentsDelegateClassLoader() {
		path = this.getResource("").getPath();
	}
	public NotParentsDelegateClassLoader(String path) {
		this.path = path;
	}
	@Override 
	  public Class<?> loadClass(String name) throws ClassNotFoundException {
		byte[] b = null;
		try {
			b = loadClassFile(name);
		}
		catch (FileNotFoundException e) {
			System.err.println("加載器" + this.getClass().getName() 
			          + "沒有找到class文件" + name + "，將委派給父類加載器！");
			// 委派給父類加載器 
			return getClass().getClassLoader().loadClass(name);
		}
		catch (IOException e) {
			System.err.println("加載器" + this.getClass().getName() + "加載class文件" 
			          + name + "失敗，將委派給父類加載器！");
			// 委派給父類加載器 
			return getClass().getClassLoader().loadClass(name);
		}
		// 檢查該類是否被當(dāng)前類加載器加載過（只檢查當(dāng)前類加載器，不會檢查父類加載器） 
		Class<?> clazz = findLoadedClass(name);
		if (clazz != null) {
			System.out.println("類" + name + "已被加載過！");
			return clazz;
		} else {
			System.out.println("類" + name + "尚未被加載！");
		}
		return this.defineClass(name, b, 0, b.length);
	}
	private byte[] loadClassFile(String name) throws IOException, 
	      FileNotFoundException {
		String classFile = getClassFile(name);
		System.out.println("即將加載class文件" + classFile);
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		InputStream input = new FileInputStream(classFile);
		int count;
		byte[] temp = new byte[1024];
		while ((count = input.read(temp)) > -1) {
			out.write(temp, 0, count);
		}
		out.close();
		input.close();
		return out.toByteArray();
	}
	private String getClassFile(String name) {
		String pathName = name.replace(".", File.separator);
		if (path.endsWith("/") || path.endsWith("\\")) {
			return path + pathName + EXT;
		}
		return path + File.separator + pathName + EXT;
	}
}

現(xiàn)在類路徑classpath下有一個類文件com\zzj\classloader\User.class，包名為com.zzj.classloader，使用類加載器NotParentsDelegateClassLoader加載User類。

package com.zzj.classloader;
public class App2 {
	private static final String className = "com.zzj.classloader.User";
	public static void main(String[] args) throws Exception {
		NotParentsDelegateClassLoader classLoader = new NotParentsDelegateClassLoader();
		Class<?> clazz = classLoader.loadClass(className);
		System.out.println(clazz);
		System.out.println(clazz.getClassLoader());
	}
}

輸出：

即將加載class文件/E:/Myeclipse/zzjtest/WebRoot/WEB-INF/classes/com\zzj\classloader\User.class 
類com.zzj.classloader.User尚未被加載！ 
即將加載class文件/E:/Myeclipse/zzjtest/WebRoot/WEB-INF/classes/java\lang\Object.class 
class com.zzj.classloader.User 
com.zzj.classloader.NotParentsDelegateClassLoader@61de33 
加載器com.zzj.classloader.NotParentsDelegateClassLoader沒有找到class文件java.lang.Object，將委派給父類加載器！

此時User類的加載器是NotParentsDelegateClassLoader，沒有先委托給父類，只有加載失敗才會委托給父類加載器，正好跟雙親委派模型是反的。

當(dāng)然，即使加載失敗，也可以不委托給父類加載器，而指定其他的類加載器，從而可以構(gòu)建更加復(fù)雜的網(wǎng)狀模型的類加載機制

上述內(nèi)容就是怎么在java中自定義一個類加載器，你們學(xué)到知識或技能了嗎？如果還想學(xué)到更多技能或者豐富自己的知識儲備，歡迎關(guān)注億速云行業(yè)資訊頻道。