类的加载机制

类的加载机制

  类加载器的作用

     Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader

  类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap。

     Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。

     BootStrap : 在jvm中,不是java类,用于加载JRE/lib/rt.jar中的jar包

     ExtClassLoader : 用于加载JRE/lib/ext/*.jar中的jar包

     AppClassLoader: 加载CLASSPATH指定的所有jar或目录

    将class文件放到ext中就会由ExtClassLoader加载

public class ClassLoaderTest {
	public static void main(String[] args) {
		System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());
		//<span style="font-family:宋体;">BootStrap 非Java类所以打印null</span>
		System.out.println(System.class.getClassLoader());
		
		//打印所有父类加载器
		ClassLoader loader = ClassLoaderTest.class.getClassLoader();
		while(loader != null){
			System.out.println(loader.getClass().getName());
			loader = loader.getParent();
		}
		System.out.println(loader);
		
	}
}

结果为

sun.misc.Launcher$AppClassLoader
null
sun.misc.Launcher$AppClassLoader
sun.misc.Launcher$ExtClassLoader
null     

  类加载器的委托机制

  每个ClassLoader本身只能分别加载特定位置和目录中的类，但它们可以委托其他的类装载器去加载类，这就是类加载器的委托模式。类装载器一级级委托到BootStrap类加载器，当BootStrap无法加载当前所要加载的类时，然后才一级级回退到子孙类装载器去进行真正的加载。当回退到最初的类装载器时，如果它自己也不能完成类的装载，那就应报告ClassNotFoundException异常。

  首先当前线程的类加载器去加载线程中的第一个类。

  如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。

  还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

     当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子

 

   编写类加载器

  class文件加密

  原理:class文件由二级制文件组成,将二级制文件异或1,将class文件打乱,在异或1恢复.   

  异或原理 : a ^ b ^ b == a

 

public class MyClassLoader{

	public static void main(String[] args) throws IOException {
		String srcPath = args[0];
		String destDir = args[1];
		FileInputStream fis = new FileInputStream(new File(srcPath));
		
		String destName = srcPath.substring(srcPath.lastIndexOf("\\"));
		String destPath = destDir + File.separator + destName;
		FileOutputStream fos = new FileOutputStream(new File(destPath));
		cypher(fis, fos);
	}

	public static void cypher(InputStream src, OutputStream dest) throws IOException {
		int i;
		while((i = src.read()) != -1){
			dest.write(i ^ 0xff);
		}
	}
}

  被加密的类

import java.util.Date;

//因为加密后的class文件是一个乱码的class文件,无法当做对象的引用,所以必须有一个父类去引用他
public class ClassLoaderAttachment extends Date{
	public String toString(){
		return "hi, friends";
	}

    类加载器的编写

   自定义的类加载器的必须继承ClassLoader

      loadClass方法与findClass方法

      defineClass方法

          在自己写的加载其中不用重新loadClass,只要见findClass重写,并且在findClass中调用defineClass就可以了

         这是使用可 模板设计模式, 将所有相同的方法放在一个方法中,将与父类不同的方法放在另一个方法中,在相同的方法里调用与父类不同的方法.只要将与父类不同的方法重写,就可以完成.

public class MyClassLoader extends ClassLoader{

	public static void main(String[] args) throws IOException {
		String srcPath = args[0];
		String destDir = args[1];
		FileInputStream fis = new FileInputStream(new File(srcPath));
		
		String destName = srcPath.substring(srcPath.lastIndexOf("\\"));
		String destPath = destDir + File.separator + destName;
		FileOutputStream fos = new FileOutputStream(new File(destPath));
		cypher(fis, fos);
		
		fis.close();
		fos.close();
		
	}

	public static void cypher(InputStream src, OutputStream dest) throws IOException {
		int i;
		while((i = src.read()) != -1){
			dest.write(i ^ 0xff);
		}
	}
	
	String pathName; 
	
	public MyClassLoader(){
		
	}
	
	public MyClassLoader(String pathName){
		this.pathName = pathName;
	}
	
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		try {
			String path = pathName + "\\" + name + ".class";
			//System.out.println(path);
			FileInputStream fis = new FileInputStream(new File(path));
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			
			cypher(fis, bos);
			byte[] b = bos.toByteArray();
			
			return defineClass(b, 0, b.length);
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return super.findClass(name);
	}
}

    调用方法

MyClassLoader mc = new MyClassLoader("E:\\EclipseWorkSpace\\classLoader\\cypherlib");
		Class clazz = mc.loadClass("ClassLoaderAttachment");
		//这里不能使用ClassLoaderAttachment做引用,因为他是乱码的,只能用他的父类做引用
		Date cla = (Date) clazz.newInstance();
		System.out.println(cla);

 类加载器的高级问题分析

   编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MyServlet，正常发布后，看到打印结果为WebAppClassloader。

   把MyServlet.class文件打jar包，放到ext目录中，重启tomcat，发现找不到HttpServlet的错误。

   把servlet.jar也放到ext目录中，问题解决了，打印的结果是ExtclassLoader。

   父级类加载器加载的类无法引用只能被子级类加载器加载的类

   

   这个问题其实是一个类委托机制的问题,一个类中的所有类都是由第一个加载此类的类加载器去加载,当将jar包放到ext目录下的时候,他会直接有ExtClassLoader去加载,而后在这个类的所有类都会有ExtClassLoader去加载,类加载器都会向上找,而不能向下找,当这个类中有一个有他子类加载器加载的类时,他就会报异常,因为他找不到这个类,要将这个类中需要加载的类都放在Ext目录下才能正常加载.