類載入器

在我心中類載入一直是很迷人的，主要的原因是覺得為何能夠這個過程是如何運作的。最近在總結自己以前學過的東西，所以也就總結一下類載入器這方面的東西。

對於為何將載入類這樣一個那麼重要的事放在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;
    }
}