一：加载过程

大致的流程

类加载的几个步骤
加载—>验证—>准备—> 解析—> 初始化—> 使用—>卸载

加载：把字节码读取进内存，加载的时机有：调用main,new Demo(), 会生成一个java.lang.Class的对象
作为方法去这个类的各种数据的访问入库，注意：单纯申明变量是不会加载的，如：Demo demo = null;
验证：校验字节码的正确性
准备：给类的静态变量分配内存，赋默认值
解析：符号引用替换为直接引用，就是将完成，变量、对象，与内存地址完成映射（静态链接）
动态链接是在程序运行期间，完成符号引用的
初始化：对类的静态变量初始化为代码声明的值，执行静态代码；

注意：加载是懒加载的方式

二：类加载器

引导加载器 bootstrapLoader ：加载JRE lib下的jar
扩展加载器 extClassloader ：加载JRE lib 下的ext 包中的jar
应用程序加载器 appClassLoader ： classPath下的类包，就是用户开发的jar
自定义加载器：用户可以自己定义加载自定义包下的jar

三：双亲委派

为什么双亲委派：
1：沙箱安全：核心类防止为篡改
2：唯一性，保证加载类的唯一性
3：绝大部分的代码是由应用程序类加载器加载
全盘委托机制
双亲委派的代码

//ClassLoader的loadClass方法，里面实现了双亲委派机制 
protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
检查当前类加载器是否已经加载了该类
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
             //如果当前加载器父加载器不为空则委托父加载器加载该类 
                    c = parent.loadClass(name, false);
                } else {
            //如果当前加载器父加载器为空则委托引导类加载器加载该类
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
        // 调用 URLClassLoader的findClass在加载器的类路径中查找并加载该类
                c = findClass(name);
                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

四：自定义加载器

1：继承 java.lang.ClassLoader
2：重写 findClass方法

自定义类加载器code

public class MyClassLoaderTest {
static class MyClassLoader extends ClassLoader {
private String classPath;   
public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }
    private byte[] loadByte(String name) throws Exception {
        name = name.replaceAll("\\.", "/");
        FileInputStream fis = new FileInputStream(classPath + "/" + name
                + ".class");
        int len = fis.available();
        byte[] data = new byte[len];
        fis.read(data);
        fis.close();
        return data;
    }
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = loadByte(name);
            //defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }
}
public static void main(String args[]) throws Exception {
    //初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoader
    MyClassLoader classLoader = new MyClassLoader("D:/test");
    //D盘创建 test/com/tuling/jvm 几级目录，将User类的复制类User1.class丢入该目录
    Class clazz = classLoader.loadClass("com.tuling.jvm.User1");
    Object obj = clazz.newInstance();
    Method method = clazz.getDeclaredMethod("sout", null);
    method.invoke(obj, null);
    System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

打破双亲委派机制需要注意每个bean的父类都是Object的加载情况

public class MyClassLoaderTest {
static class MyClassLoader extends ClassLoader {
private String classPath;    
public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }
    private byte[] loadByte(String name) throws Exception {
        name = name.replaceAll("\\.", "/");
        FileInputStream fis = new FileInputStream(classPath + "/" + name
                + ".class");
        int len = fis.available();
        byte[] data = new byte[len];
        fis.read(data);
        fis.close();
        return data;
    }
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = loadByte(name);
            return defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }
    /**
     * 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载
     * @param name
     * @param resolve
     * @return
     * @throws ClassNotFoundException
     */
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                  if(!name.startsWith("就是如果加载到父类，就用原来的类加载器")){
                  c = this.getParent.loadClass(name);
                }else{
                    c = findClass(name);
                }
                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
}
public static void main(String args[]) throws Exception {
    MyClassLoader classLoader = new MyClassLoader("D:/test");
    //尝试用自己改写类加载机制去加载自己写的java.lang.String.class
    Class clazz = classLoader.loadClass("java.lang.String");
    Object obj = clazz.newInstance();
    Method method= clazz.getDeclaredMethod("sout", null);
    method.invoke(obj, null);
    System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

五：Tomcat打破双亲委派

原因：

web下可能为部署两个应用程序，依赖同一个jar 的不同版本，保证隔离
同一个web容器的相同类库可以共享
web依赖的库，不能与应用的库混淆
web容器支持jsp修改，不用重启

Java 进阶

JVM类加载机制

一：加载过程

二：类加载器

三：双亲委派

四：自定义加载器

五：Tomcat打破双亲委派