Java打破双亲委派机制

1.自定义加载器

沿用双亲委派机制自定义类加载器很简单，只需继承ClassLoader类并重写findClass方法即可。
①先定义一个待加载的类Test，它很简单，只是在构建函数中输出由哪个类加载器加载。

public class Test {
	  public Test(){
	    System.out.println(this.getClass().getClassLoader().toString());
	  }
}

②定义一个TestClassLoader类继承ClassLoader，重写findClass方法，此方法要做的事情是读取Test.class字节流并传入父类的defineClass方法即可。然后就可以通过自定义累加载器TestClassLoader对Test.class进行加载,完成加载后会输出“TestLoader”。

public class TestClassLoader extends ClassLoader {
  private String name;
 
  public TestClassLoader(ClassLoader parent, String name) {
    super(parent);
    this.name = name;
  }
 
  @Override
  public String toString() {
    return this.name;
  }
 
  @Override
  public Class<?> findClass(String name) {
 
    InputStream is = null;
    byte[] data = null;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try {
      is = new FileInputStream(new File("d:/Test.class"));
      int c = 0;
      while (-1 != (c = is.read())) {
        baos.write(c);
      }
      data = baos.toByteArray();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        is.close();
        baos.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    return this.defineClass(name, data, 0, data.length);
  }
 
  public static void main(String[] args) {
    TestClassLoader loader = new TestClassLoader(
        TestClassLoader.class.getClassLoader(), "TestLoader");
    Class clazz;
    try {
      clazz = loader.loadClass("test.classloader.Test");
      Object object = clazz.newInstance();
    } catch (Exception e) {
      e.printStackTrace();
    } 
  }
 
}

2.打破双亲委派机制则不仅要继承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
                }
				...
        }
    }

①定义Test类。

public class Test {
  public Test(){
    System.out.println(this.getClass().getClassLoader().toString());
  }
}

②重新定义一个继承ClassLoader的TestClassLoaderN类，这个类与前面的TestClassLoader类很相似，重写了loadClass方法，默认的loadClass方法是实现了双亲委派机制的逻辑，即会先让父类加载器加载，当无法加载时才由自己加载。这里为了破坏双亲委派机制必须重写loadClass方法，自己实现的方法中没有双亲委派的逻辑。

public class TestClassLoaderN extends ClassLoader {
 
  @SneakyThrows
  @Override
  public Class<?> loadClass(String name){
    String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
            InputStream is = getClass().getResourceAsStream(fileName);
            if(is == null) {
                return super.loadClass(name);
            }
            byte[] b = new byte[is.available()];
            is.read(b);
            return defineClass(name, b, 0, b.length);
  }
 
  public static void main(String[] args) {
      TestClassLoaderN loader = new TestClassLoaderN();
      Class clazz;
      try {
          clazz = loader.loadClass("com.boot.myself.TestClassLoaderN");
          Object object = clazz.newInstance();
          System.out.println(object.getClass());
          System.out.println(object instanceof com.boot.myself.TestClassLoaderN);
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
 
}

//结果  
class com.boot.myself.TestClassLoaderN
false // 虽然类名一致，但是加载类的加载器不同，结果是false