类加载器

在我心中类加载一直是很迷人的，主要的原因是觉得为何能够这个过程是如何运作的。最近在总结自己以前学过的东西，所以也就总结一下类加载器这方面的东西。

对于为何将加载类这样一个那么重要的事放在JVM外部在实现，我觉的最主要的原因是为了提供更好的扩展性吧，让程序员自己去决定如何加载一个类。根据书上的说法是这个类加载器最初是为了满足JAVA Applet为设计的，但是奈何我是newbie，没有经历过那个时期，也只能一年蒙蔽的看着老鸟们的讲解了。但是如今类加载的主要方向在类层次划分，OSGi,热部署，代码加密等领域有很好的发挥。

1.类与类加载器

 虽然在加载器只用于加载类得动作，但是起到的作用却并非如此，因为每个类加载器都有自己的类名称空间，也就是说，两个类只有来自同一个类加载器才有意义，不然的话，即使是同一个字节码来的，也是不会相同的，即使是用 instanceof关键字来进行判断。

package com.hotusm.classloader;

import java.io.InputStream;

import org.junit.Test;
/**
 * 
 * @author Hotusm  <br/>
 * @date 2016年10月29日   <br/>
 * @description
 */
public class ClassLoaderTest {
    
    @Test
    public void test() throws ClassNotFoundException{
        
        PathClassLoader classLoader=new PathClassLoader("D:/jeesite/ActOfJava/bin");
        Class<?> loadClass = classLoader.findClass("com.hotusm.classloader.ClassLoaderTest");
        System.out.println(loadClass);
    }
    
    @Test
    public void testClassPath(){
        
        ClassLoader classLoader=new ClassLoader() {
            
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                    if(!name.startsWith("com.hotusm"))
                        return super.loadClass(name);
                    
                    
                    String fileName=name.substring(name.lastIndexOf(".")+1)+".class";
                    try(InputStream is=getClass().getResourceAsStream(fileName)) {
                        
                        if(is==null){
                            super.loadClass(name);
                        }
                        byte[] b=new byte[is.available()];
                        
                        is.read(b);
                        
                        return defineClass(name, b, 0, b.length);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return null;
            }
        };
        
        try {
            Object obj = classLoader.loadClass("com.hotusm.classloader.ClassLoaderTest").newInstance();
            //Method method = obj.getClass().getMethod("testMethod");
            //method.invoke(obj);
            System.out.println(obj instanceof com.hotusm.classloader.ClassLoaderTest);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }
    
    public void testMethod(){
        System.out.println("method");
    }
}

 上面的输出就是false!!（注释的那些也就是一个代码加密的思路，将字节码文件进行加密，然后自定义类加载器，实现自己的解密，将字节码进行解密，最后反射调用）

2.双亲委派模型：

  双亲委派讲的是将职责一直向上委派，知道最顶层。如果最顶层不能解析，那么再往下委派，直到解析成功，

3.类加载器种类：

引导类加载器（bootstrap class loader）：

它用来加载 Java 的核心库(jre/lib/rt.jar)，是用原生C++代码来实现的，并不继承自java.lang.ClassLoader。

加载扩展类和应用程序类加载器，并指定他们的父类加载器，在java中获取不到。 

扩展类加载器（extensions class loader）：

它用来加载 Java 的扩展库(jre/ext/*.jar)。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。 

系统类加载器（system class loader）：

它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。

自定义类加载器（custom class loader）：

除了系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader类的方式实现自己的类加载器，以满足一些特殊的需求。

下面是自己定义的实现的类加载器：

package com.hotusm.classloader;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
 * 
 * @author Hotusm  <br/>
 * @date 2016年10月28日   <br/>
 * @description 类加载器
 * http://www.cnblogs.com/sunniest/p/4574080.html
 * 
 * JVM中类加载器的树状层次结构
 *         引导类加载器(bootstrap class loader)
 *         扩展类加载器(extensions class loader)
 *         系统类加载器(system class loader)
 *         自定义类加载器(custom class loader)
 * 
 */
public class PathClassLoader extends ClassLoader{
    
    private String classPath;
    private String packageNames="com.hotusm";
    
    private Map<String,Class<?>> cache=new ConcurrentHashMap<>();
    
    public PathClassLoader(String classPath){
        this.classPath=classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        
        if(name.startsWith(packageNames)){
            return cacheClass(name);
        }else{
            return super.findClass(name);
        }
        
    }
    
    private byte[] getData(String className){
        String path=classPath+File.separatorChar+className.replace('.', File.separatorChar)
                +".class";
        try(InputStream is=new FileInputStream(path)) {
            
            ByteArrayOutputStream stream=new ByteArrayOutputStream();
            byte[] buffer=new byte[2014];
            int num=0;
            while((num=is.read(buffer))!=-1){
                stream.write(buffer,0,num);
            }
            return stream.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    private Class<?> cacheClass(final String name) throws ClassNotFoundException{
        Class<?> clazz = cache.get(name);
            synchronized (name) {
                if(clazz==null){
                    byte[] classData = getData(name);
                    if(classData==null){
                        throw new ClassNotFoundException();
                    }else{
                        clazz = defineClass(name, classData, 0, classData.length);
                        cache.put(name, clazz);
                    }
                }
            }
        return clazz;
    }
}