java 详解类加载器的双亲委派及打破双亲委派
一般的场景中使用Java默认的类加载器即可,但有时为了达到某种目的又不得不实现自己的类加载器,例如为了达到类库的互相隔离,例如为了达到热部署重加载功能。这时就需要自己定义类加载器,每个类加载器加载各自的类库资源,以此达到资源隔离效果。在对资源的加载上可以沿用双亲委派机制,也可以打破双亲委派机制。
一、沿用双亲委派机制自定义类加载器很简单,只需继承ClassLoader类并重写findClass方法即可。如下例子:
①先定义一个待加载的类Test,它很简单,只是在构建函数中输出由哪个类加载器加载。
1
2
3
4
5
6
7
|
public class Test { public Test(){ System.out.println( this .getClass().getClassLoader().toString()); } } |
②定义一个TestClassLoader类继承ClassLoader,重写findClass方法,此方法要做的事情是读取Test.class字节流并传入父类的defineClass方法即可。然后就可以通过自定义累加载器TestClassLoader对Test.class进行加载,完成加载后会输出“TestLoader”。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
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(); } } } |
二、打破双亲委派机制则不仅要继承ClassLoader类,还要重写loadClass和findClass方法,如下例子:
①定义Test类。
1
2
3
4
5
|
public class Test { public Test(){ System.out.println( this .getClass().getClassLoader().toString()); } } |
②重新定义一个继承ClassLoader的TestClassLoaderN类,这个类与前面的TestClassLoader类很相似,但它除了重写findClass方法外还重写了loadClass方法,默认的loadClass方法是实现了双亲委派机制的逻辑,即会先让父类加载器加载,当无法加载时才由自己加载。这里为了破坏双亲委派机制必须重写loadClass方法,即这里先尝试交由System类加载器加载,加载失败才会由自己加载。它并没有优先交给父类加载器,这就打破了双亲委派机制。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
public class TestClassLoaderN extends ClassLoader { private String name; public TestClassLoaderN(ClassLoader parent, String name) { super (parent); this .name = name; } @Override public String toString() { return this .name; } @Override public Class<?> loadClass(String name) throws ClassNotFoundException { Class<?> clazz = null ; ClassLoader system = getSystemClassLoader(); try { clazz = system.loadClass(name); } catch (Exception e) { // ignore } if (clazz != null ) return clazz; clazz = findClass(name); return clazz; } @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) { TestClassLoaderN loader = new TestClassLoaderN( TestClassLoaderN. class .getClassLoader(), "TestLoaderN" ); Class clazz; try { clazz = loader.loadClass( "test.classloader.Test" ); Object object = clazz.newInstance(); } catch (Exception e) { e.printStackTrace(); } } } |
感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!