java学习之深入类加载器--ClassLoader

1.类加载器的原理
2.类加载器树状结构，双亲委托(代理)机制
3.自定义类加载器(文件，网络，加密)
4.线程上下文类加载器
5.服务器类加载原理和OSGI介绍

一、类加载器的作用

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口。

类缓存：

标准的java se类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持维持(缓存)一段时间。不过，JVM垃圾收集器可以回收这些Class对象.。

二、类加载器(java.class.ClassLoader)类介绍

1.作用：

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

2.相关方法：

• getParent() :                          返回该类加载器的父类加载器。
• loadClass(String name):    加载名称为name的类，返回的结果是java.lang.Class类的实例。
• findClass(String name):     查找名称为name的类，返回的结果是java.lang.Class类的实例
• findLoadedClass(String name): 查找名称为name的已经被加载过的类，返回的结果是java.lang.Class类的实例。
• defineClass(String name,byte[] b,int off,int len): 把字节数组b中的内容转换成java类，返回的结果是java.lang.Class类的实例，这个方法被声明成final的。
• resolveClass(Class<?> c):  链接指定的java类

对于以上给出的方法，表示类名称的name参数的值是类的二进制名称。需要注意的是内部类的表示，如com.example.Sample$1和com.example.Sameple$Inner等表示方式

三、类加载器的层次结构(树状结构)

1.引导类加载器(bootstrap class loader)

• 它用来加载java的核心库(JAVA_HOME/jre/lib/rt.jar,或sun.boot.class.path路径下的内容)是用原生代码来实现的()C++),并不继承java.lang.ClassLoader.
• 加载扩展类和应用程序类加载器，并指定他们的父类加载器

2.扩展类加载器(extensions class loader)

• 用来加载java的扩展库(JAVA_HOME/jre/ext/*.jar,或java.ext.dirs路径下的内容)。java虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载java类。
• 有sun.misc.Launcher$ExtClassLoader实现

3.应用程序类加载器(application class loader)

• 它根据java应用的类路径(classpaht,java.class.paht路径类)
• 一般来说，java应用的类都是又它来完成加载的。
• 有sun.misc.Launcher$AppClassLoader实现

4.自定义类加载器

• 开发人员可以通过继承java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求

引导类加载器是C++实现的，其他则由java实现。内容的继承关系是通过组合的形式实现的，就是内部定义parent类，而并不是直接继承实现。
图：自定义类加载器-->应用程序类加载器-->扩展类加载器-->引导类加载器

例子：

public class Demo01 {

	public static void main(String[] args) {
		System.out.println(ClassLoader.getSystemClassLoader());
		System.out.println(ClassLoader.getSystemClassLoader().getParent());
		System.out.println(ClassLoader.getSystemClassLoader().getParent().getParent());
		System.out.println(System.getProperty("java.class.path"));
	}	
}

四、类加载的代理模式以及顺序

1.代理模式

交给其他加载器来加载指定的类

2.双亲委托机制

• 就是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次追溯，直到最高的爷爷辈的，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。
• 双亲委托机制是为了保证JAVA核心库的类型安全。
• 这种机制就保证不会出现用户自己能定义java.lang.Object(和原始类库相同名称的类)的情况
• 类加载器除了用于加载类，也为了保证安全。

双亲委托机制是代理模式的一种

• 并不是所有的类加载器都采用双亲委托机制
• tomcat服务器类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序相反。

五、自定义类加载器：

1.自定义类加载器的流程：

1. 继承：java.lang.ClassLoader
2. 首先检查请求的类型是否已经被这个类加载器加载到命名空间了。如果已经加载，直接返回。
3. 委派类加载请求给父类加载器，如果父类加载器能够完成，则返回父类加载器加载的Class实例。
4. 调用本类加载器的findClass(...)方法，试图获取对应的字节码，如果获取到，则调用defineClass(...)导入类型到方法区；如果获取不到对应的字节码或者其他原因失败，返回异常给loadClass(...),转抛异常，终止加载过程。

注意：被两个类加载器加载的同一个类，JVM不认为是相同的类。

文件类加载器
网络类加载器
加密解密类加载器(取反操作，DES对称加密解密)

例：

文件类加载器:

public class FileSystemClassLoader extends ClassLoader {

	// com.test.TestClassLoader.Test -->
	// E:\workspace\images\com\test\TestClassLoader\Test.class
	private String rootDir;

	public FileSystemClassLoader(String rootDir) {
		this.rootDir = rootDir;
	}

	@Override
	public Class<?> findClass(String name) throws ClassNotFoundException {
		//先查询有没有加载过这个类，如果已经加载，直接返回。如果没有加载则按照加载顺序加载
		Class<?> cc = findLoadedClass(name);
		if (cc != null) {
			return cc;
		} else {
			try {
				ClassLoader parent = this.getParent();
				cc = parent.loadClass(name);// 委派给父类加载
			} catch (Exception ee) {
			}
			if (cc != null) {
				return cc;
			} else {
				byte[] byteclass = getByteClass(name);
				if (byteclass == null) {
					throw new ClassNotFoundException();
				} else {
					cc = defineClass(name, byteclass, 0, byteclass.length);//自己加载
				}
			}
		}
		return cc;
	}

	//获取字节码文件的字节
	private byte[] getByteClass(String classname) {
		String path = rootDir +"/"+ classname.replace(".", "/") + ".Class";
		InputStream is = null;
		ByteArrayOutputStream baos = null;
		try {
			is = new FileInputStream(path);
			baos = new ByteArrayOutputStream();
			byte[] arr = new byte[1024];
			int len = 0;
			while (-1 != (len = is.read(arr))) {
				baos.write(arr, 0, len);
			}
			return baos.toByteArray();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
				if (baos != null) {
					baos.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}
}

应用:

public class TestFileClassLoader {
	public static void main(String[] args) throws ClassNotFoundException {
		String dir = "E:/workspace/images";
		String classname = "com.test.TestClassLoader.Test";
		FileSystemClassLoader file = new FileSystemClassLoader(dir);
		FileSystemClassLoader file2 = new FileSystemClassLoader(dir);
		
		Class<?> c1 = file.findClass(classname);
		Class<?> c2 = file.findClass(classname);		
		Class<?> c3 = file2.findClass(classname);
		
		Class<?> c4 = file.findClass("java.lang.String");
		Class<?> c5 = file.findClass("bean.User");
		
		System.out.println(c1.hashCode());
		System.out.println(c2.hashCode());
		System.out.println(c3.hashCode());//同一个类被不同的加载器加载，JVM也认为是不同的类
		
		System.out.println(c4.getClassLoader());//引导类加载器
		System.out.println(c1.getClassLoader());//自定义类加载器
		System.out.println(c5.getClassLoader());//默认加载器		
	}
}

六、线程上下文类加载器

1.双亲委托机制以及类加载器的问题

• - 一般情况下，保证同一个类中所关联的其他类都是由当前类的类加载器所加载的。
• 比如，Classa本身在Ext下找到，那么它里面new除了的一些类也就只能用Ext去查找了(不会低一个级别)，所以有些明明API可以找到的，却找不到了。
• - JDBC API，它有是吸纳的dirven部分(mysql/sql server)，我们的JDBC API都是Boot或者Boot或者Ext来载入的，但是JDBC DIVER却是由Ext或者APP来载入，那么就有可能找不到diver了。 在java领域中，其实只要分成这种Api+SPI的，都会遇到此问题。
• - 常见的SPI有JDBC,JCE,JNDI,JAXP和JBI等。这些SPI的接口由Java核心库来提供，如JAXP的SPI接口定义包含在javax.xml.parsers包中。SPI的接口是java核心库的一部分，是由引导类加载器来加载的SPI实现的java类一般是由系统类加载器来加载的，引导类加载器是无法找到spi的实现类的，因为它只加载java的核心库。

通常当你需要动态加载资源的时候，你至少有三个ClassLoader可以选择：

• 1.系统类加载器或叫应用类加载器(system.classloader or application classloader)
• 2.当前类加载器
• 3.当前线程类加载器

2.线程类加载器是为了抛弃双亲委派加载链模式。

每个线程都有一个关联的上下文类加载器，如果你使用new Thread()方式生成新的线程，新线程将继承其父线程的上下文类加载器，如果程序对线程上下文类加载器没有任何改动的话，程序中所有的线程将都使用系统类加载器作为上下文类加载器。

• Thread.currentThread().getContextClassLoader();
• Thread.currentThread().setContextClassLoader();

七、Tomcat服务器的类加载机制

一切都是为了安全

1.Tomcat不能使用系统默认的类加载器

• 如果Tomcat跑你的web项目使用系统的类加载器那是相当危险的，你可以直接是无忌惮的操作系统的各个目录了。
• 对于运行在java ee容器中的Web应用来说，类加载器的实现方式与一般JAVA应用有所不同。
• 每隔Web应用都有一个对应的类加载器实例。该类加载器也使用代理模式(不同于前面说的双亲委派机制),所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的，但也是为了安全，这核心库就不在查询范围之内。

2.为了安全Tomcat需要实现自己的类加载器。

我可以限制你只能把类写在指定的地方，否则我不给你加载！

八、OSGN原理介绍

OSGI(Open server Gateway Initative）是面向Java的动态模块系统。它为开发人员提供了面向服务和基于组件的运行环境，并提供标准的方式用来管理软件的生命周期。
OSGI已经被实现和部署在很多产品上，在开源社区也得到了广泛的支持。Eclipse就是基于OSGI技术来构建的。

原理：
OSGI中的每个模块(bundle)都包含java包和类，模块可以声明它所依赖的需要导入(import）的其他模块的java包和类(import-Package）,也可以声明导出(export)自己的包和类，供其他模块使用（通过export-package),也就是说需要能够隐藏和共享一个模块中的某些java包和类。这就是通过OSGI特有的类加载器机制来实现的，OSGI中的每个模块都有对应的一个类加载器。它负责加载模块自己包含的java包和类。当它需要加载JAVA核心库类时(以java开头的包和类),它会代理给父类加载器(通常是启动类加载器)来完成。当它需要加载所导入的java类时，它会代理给导出此java类的模块来完成加载，模块也可以显示的生命某些java包和类，必须由父类加载器来加载。只需要设置系统属性, org.osgi.framework.bootdelegation的值即可