类加载器和双亲委派

关于类加载器的话题，我在class加载的过程中提到过，本质上就是用来确认到底从何处获取class，而jvm把权力交给了程序员，我们可以手动获取指定位置的class

需要注意的是，不同的类加载器加载的class对象是不同的，即使他们完全一致，方法区也会存在两个class对象（如下），这就要提到双亲委派了

public class TestClassLoader extends ClassLoader {
    public Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            String clazzName=name;
            name = "C:/" + name+ ".class";
            byte[] classBytes = new byte[1024*10];
            int i=new FileInputStream(name).read(classBytes);
            Class<?> clazz = defineClass(clazzName, classBytes, 0, i);
            if (clazz == null) {
                throw new ClassNotFoundException(name);
            }
            return clazz;
        } catch (IOException e) {
            e.printStackTrace();
            throw new ClassNotFoundException(name);
        }
    }

    public static void main(String[] args) throws Exception{
        Class clazz=new TestClassLoader().findClass("Test");
        Object t1=clazz.newInstance();
        Test t2=new Test();
        System.out.println(t1.getClass().getName());
        System.out.println(t2.getClass().getName());
        System.out.println(t1 instanceof Test);
    }
}

所谓双亲委派，是指类加载器会先找到父类，把加载工作交给父类，如果父类无法加载，子类才会尝试加载

而我们说的类加载器实际上可以分为三种，启动类加载器，扩展类加载器，应用程序类加载器

为什么要这样区分，而且还需要这样奇怪的从上至下调用呢，我们都知道Object是一切对象的父类，倘如我们也写一个叫Object的class文件

使用类加载器加载，很明显，Java运行的逻辑就无法得到保障，而启动类加载器就是用于保证类似于Object这样的对象被正确加载

在双亲委派的逻辑下，所有类加载器最终都会到达启动类加载器，而Object会被启动类加载器所加载，从而不会出现两个Object这种事情

但是这里还有一个问题，如果程序员直接通过Java程序控制启动类加载器加载自定义Object怎么办，所以启动类加载器设计之初就被设定为不能被Java程序直接控制

而扩展类加载器和应用程序加载器区别不大，均可以用Java程序进行控制，唯一的区别是扩展加载器负责用于加载java/lib/ext目录下的Java类，即，扩展启动类加载器

而我们平日写的Java类则是应用程序加载器负责加载的，而我们所自定义的类加载器，事实上可以理解为是他的子加载器

基本上所有的类加载都遵循双亲委派原则，但也有例外，比如osgi技术（即热加载技术，有兴趣可以了解一下）

回到上面，现在我们可以解释为什么加载同样对象会出现不同class对象了，如果我们使用自定义加载器加载Object

最终会被启动类加载器所加载，class对象相同，但是如果我们用不同加载器加载一个我们自己写的类，情况就不同了

显然，最终处理加载的并不是一个加载器对象，对于双亲委派机制，会为加载器设置命名空间，命名空间的可见性和继承类似，

子加载器中包含父加载器的命名空间，反之则不包含，而不同命名空间中的类是不可见的，所以可以存在全限定名完全相同的两个不同的类

在我们上面的例子中，t1是自定义加载器加载的，而t2是应用程序加载器加载的，所以t1是可见t2反之则不行

先观察自定义加载器的可见性

public class Test {
    public void test(xxx x){
    }
}
public static void main(String[] args) throws Exception{
        Class clazz=new TestClassLoader().findClass("Test");
        Object t1=clazz.newInstance();
        Method m =clazz.getDeclaredMethod("test",xxx.class);
        System.out.println(m);
        xxx xx=new xxx();
        m.invoke(t1,xx);
    }

然后我们将xxx用自定义加载器加载

public static void main(String[] args) throws Exception{
        Class clazz=new TestClassLoader().findClass("xxx");
        Object o=clazz.newInstance();
        Test t=new Test();
        t.test((xxx)o);
    }

删除xxx.class命令行运行