java自定义类加载器代码示例

如果要使用自定义类加载器加载class文件，就需要继承java.lang.classloader类。

classloader有几个重要的方法：

protectedclassloader(classloaderparent)：使用指定的、用于委托操作的父类加载器创建新的类加载器。

protectedfinalclass<?>defineclass(stringname,byte[]b,intoff,intlen)：将一个byte数组转换为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;
	}
}

现在类路径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类的加载器是系统类加载器appclassloader，而不是我们自己定义的类加载。实际上被加载不是f:\\classloadertest\\bin下的类，而是classpath下的类。这就是双亲委派模型：当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); 
  } 

调用了重载方法：

protected synchronized class<?> loadclass(string name, boolean resolve) 
  throws classnotfoundexception 
  { 
  // 先判断该类是否已被当前的类加载器加载 
  class c = findloadedclass(name); 
  if (c == null) { 
    try { 
    if (parent != null) {// 如果存在父类加载器，则委派给父类加载 
      c = parent.loadclass(name, false); 
    } else {// 如果父类加载为空，则其父类加载器为引导类加载器 
      c = findbootstrapclass0(name); 
    } 
    } catch (classnotfoundexception e) { 
      // 如果父类加载器加载失败，则自己加载，调用的就是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);
		}
		// 检查该类是否被当前类加载器加载过（只检查当前类加载器，不会检查父类加载器） 
		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;
	}
}

现在类路径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，没有先委托给父类，只有加载失败才会委托给父类加载器，正好跟双亲委派模型是反的。

当然，即使加载失败，也可以不委托给父类加载器，而指定其他的类加载器，从而可以构建更加复杂的网状模型的类加载机制

总结

以上就是本文关于java自定义类加载器代码示例的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！