显式加载和隐式加载。 显式加载指的是在代码中通过调用ClassLoader加载Class对象，如直接使用Class.forName(name)或this.getClass().getClassLoader().loadClass()加载Class对象。 隐式加载则是不直接在代码中调用ClassLoader的方法加载Class对象，而是通过虚拟机自动加载到内存中，如在加载某个类的Class文件时，该类的Class文件中引用了另外一个类的对象，此时额外引用的类将通过JVM自动加载到内存中。
public class ClassLoaderTest {
public static void main ( String [ ] args) {
User user = new User ( ) ;
try {
Class clazz1 = Class . forName ( "com.itan.middle.day5.User" ) ;
Class clazz2 = ClassLoader . getSystemClassLoader ( ) . loadClass ( "com.itan.middle.day5.User" ) ;
} catch ( ClassNotFoundException e) {
e. printStackTrace ( ) ;
}
}
}
class User {
private int num;
}
都需要由加载它的类加载器和这个类本身一同确认其在Java虚拟机中的唯一性。每一个类加载器，都拥有一个独立的类名称空间：比较两个类是否相等，只有在这两个类是由同一个类加载器加载的前提下才有意义。否则，即使这两个类源自同一个Class文件，被同一个虚拟机加载，只要加载他们的类加载器不同，那这两个类就必定不相等。
与数组当中元素类型的类加载器是一样的；如果数组当中的元素类型是基本数据类型，数组类是没有类加载器的。
public class ClassLoaderTest1 {
public static void main ( String [ ] args) {
String [ ] strArr = new String [ 10 ] ;
System . out. println ( strArr. getClass ( ) . getClassLoader ( ) ) ;
ClassLoaderTest1 [ ] classArr = new ClassLoaderTest1 [ 10 ] ;
System . out. println ( classArr. getClass ( ) . getClassLoader ( ) ) ;
int [ ] intArr = new int [ 10 ] ;
System . out. println ( intArr. getClass ( ) . getClassLoader ( ) ) ;
}
}
public final ClassLoader getParent()：返回该类加载器的父类加载器。public Class<?> loadClass(String name) throws ClassNotFoundException：加载名称为name的类，返回结果为java.lang.Class类的实例。如果找不到类，则抛出ClassNotFoundException异常。该方法中的逻辑就是双亲委派模式的实现。loadClass方法的具体代码如下：
ClassLoader . getSystemClassLoader ( ) . loadClass ( "com.itan.middle.day5.User" ) ;
public Class < ? > loadClass ( String name) throws ClassNotFoundException {
return loadClass ( name, false ) ;
}
protected Class < ? > loadClass ( String name, boolean resolve) throws ClassNotFoundException {
synchronized ( getClassLoadingLock ( name) ) {
Class < ? > = 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) {
}
if ( c == null ) {
long t1 = System . nanoTime ( ) ;
c = findClass ( name) ;
sun. misc. PerfCounter. getParentDelegationTime ( ) . addTime ( t1 - t0) ;
sun. misc. PerfCounter. getFindClassTime ( ) . addElapsedTimeFrom ( t1) ;
sun. misc. PerfCounter. getFindClasses ( ) . increment ( ) ;
}
}
if ( resolve) {
resolveClass ( c) ;
}
return c;
}
}
protected Class<?> findClass(String name) throws ClassNotFoundException：查找二进制名称为name的类，返回结果为java.lang.Class类的实例。这是一个受保护的方法，JVM鼓励我们重写此方法，需要自定义加载器遵循双亲委托机制，该方法会在检查完父类加载器之后被loadClass方法调用。 一般情况下，在自定义类加载器时，会直接覆盖ClassLoader的findClass方法并编写加载规则，取得要加载类的字节码后转换成流，然后调用defineClass方法生成类的Class对象。 protected final Class<?> defineClass(byte[] b, int off, int len)：根据给定的字节数组b转换为Class的实例，off和len参数表示实际Class信息在byte数组中的位置和长度，其中byte数组b是ClassLoader从外部获取的。这是受保护的方法，只有在自定义ClassLoader子类中可以使用。 defineClass方法通常与findClass方法一起使用，一般情况下，在自定义类加载器时，会直接覆盖ClassLoader的findClass方法并编写加载规则，取得要加载类的字节码后转换成流，然后调用defineClass方法生成类的Class对象。 protected final void resolveClass(Class<?> c)：链接指定的一个Java类。使用该方法可以使用类的Class对象创建完成的同时也被解析（即加载的同时也进行解析）。链接阶段主要是对字节码进行验证，为类变量分配内存并设置初始值同时将字节码文件中的符号引用转换为直接引用。protected final Class<?> findLoadedClass(String name)：查找名称为name的已经被加载过的类，返回结果为java.lang.Class类的实例。这个方法是final方法，无法被修改。private final ClassLoader parent：它也是一个ClassLoader的实例，这个字段所表示的ClassLoader也称为这个ClassLoader的双亲。在类加载的过程中，ClassLoader可能会将某些请求交予自己的双亲处理。
在编写自定义类加载器时，如果没有太过于复杂的需求，可以直接继承URLClassLoader类，这样就可以避免自己去编写findClass()方法及其获取字节码流的方式，使自定义类加载器编写更加简洁。
Java类随着它的类加载器一起具备了一种带有优先级的层次关系，通过这种层级关系可以避免类的重复加载，当父类已经加载了该类时，就没有必要子ClassLoader再加载一次。
答案是否定的！因为JDK还为核心类库提供了一层保护机制。不管是自定义的类加载器，还是系统类加载器还是扩展类加载器，最终都必须调用java.lang.classLoader.defineClass(String,byte[], int, int, ProtectionDomain)方法，而该方法会执行preDefineClass()方法，该方法中提供了对JDK核心类库的保护。
应用类访问系统类自然是没有问题，但是系统类访问应用类就会出现问题。比如在系统类中提供了一个接口，该接口需要在应用类中得以实现，该接口还绑定一个工厂方法，用于创建该接口的实例，而接口和工厂方法都在启动类加载器中。这时，就会出现该工厂方法无法创建由应用类加载器加载的应用实例的问题。由于Java虚拟机规范并没有明确要求类加载器的加载机制一定要使用双亲委派模型，只是建议采用这种方式而己。比如在Tomcat中，类加载器所采用的加载机制就和传统的双亲委派模型有一定区别，当缺省的类加载器接收到一个类的加载任务时，首先会由它自行加载，当它加载失败时，才会将类的加载任务委派给它的超类加载器去执行，这同时也是Servlet规范推荐的一种做法。
为了兼容这些已有代码，无法再以技术手段避免loadClass()被子类覆盖的可能性，只能在JDK1.2之后的java.lang.ClassLoader中添加一个新的protected方法findClass()，并引导用户编写的类加载逻辑时尽可能去重写这个方法，而不是在loadClass()中编写代码。双亲委派的具体逻辑就实现在loadClass()方法里面，按照loadClass()方法的逻辑，如果父类加载失败，会自动调用自己的findClass()方法来完成加载，这样既不影响用户按照自己的意愿去加载类，又可以保证新写出来的类加载器是符合双亲委派规则的。如果有基础类型又要调用回用户的代码，那该怎么办呢？ 线程上下文类加载器（Thread ContextClassLoader)。这个类加载器可以通过java.lang.Thread类的setContextClassLoader()方法进行设置，如果创建线程时还未设置，它将会从父线程中继承一个，如果在应用程序的全局范围内都没有设置过的话，那这个类加载器默认就是应用程序类加载器。 网状结构。当收到类加载请求时，OSGI将按照下面顺序进行类搜索。 将以java.*开头的类，委派给父类加载器加载。 否则，将委派列表名单内的类，委派给父类加载器加载。
热替换的关键需求在于服务不能中断，修改必须立即表现正在运行的系统之中。基本上大部分脚本语言都是天生支持热替换的，比如：PHP，只要替换了PHP源文件，这种改动就会立即生效，而无需重启Web服务器。
public class CustomClassLoader extends ClassLoader {
private String classPath;
public CustomClassLoader ( String classPath) {
this . classPath = classPath;
}
public CustomClassLoader ( ClassLoader parent, String classPath) {
super ( parent) ;
this . classPath = classPath;
}
@Override
protected Class < ? > findClass ( String className) throws ClassNotFoundException {
Class < ? > = this . findLoadedClass ( className) ;
FileChannel fileChannel = null ;
WritableByteChannel outChannel = null ;
if ( null == clazz) {
try {
String classFile = getClassFile ( className) ;
FileInputStream fis = new FileInputStream ( classFile) ;
fileChannel = fis. getChannel ( ) ;
ByteArrayOutputStream bos = new ByteArrayOutputStream ( ) ;
outChannel = Channels . newChannel ( bos) ;
ByteBuffer buffer = ByteBuffer . allocateDirect ( 1024 ) ;
while ( true ) {
int i = fileChannel. read ( buffer) ;
if ( i == 0 || i == - 1 ) {
break ;
}
buffer. flip ( ) ;
outChannel. write ( buffer) ;
buffer. clear ( ) ;
}
byte [ ] bytes = bos. toByteArray ( ) ;
clazz = defineClass ( className, bytes, 0 , bytes. length) ;
} catch ( FileNotFoundException e) {
e. printStackTrace ( ) ;
} catch ( IOException e) {
e. printStackTrace ( ) ;
} finally {
try {
if ( fileChannel != null ) {
fileChannel. close ( ) ;
}
} catch ( IOException e) {
e. printStackTrace ( ) ;
}
try {
if ( outChannel != null ) {
outChannel. close ( ) ;
}
} catch ( IOException e) {
e. printStackTrace ( ) ;
}
}
}
return clazz;
}
private String getClassFile ( String className) {
return classPath + "\\" + className. replace ( '.' , '\\' ) + ".class" ;
}
}
public class CustomClassLoaderTest {
@Test
public void test1 ( ) {
while ( true ) {
try {
CustomClassLoader ccl = new CustomClassLoader ( "D:\\IdeaProbject\\JVM\\src\\main\\java\\" ) ;
Class < ? > = ccl. findClass ( "com.itan.middle.day5.Demo" ) ;
Object demo = clazz. newInstance ( ) ;
Method method1 = clazz. getMethod ( "method1" ) ;
method1. invoke ( demo) ;
System . out. println ( "加载此类的类的加载器为：" + clazz. getClassLoader ( ) . getClass ( ) . getName ( ) ) ;
System . out. println ( "加载当前Demo1类的类的加载器的父类加载器为：" + clazz. getClassLoader ( ) . getParent ( ) . getClass ( ) . getName ( ) ) ;
Thread . sleep ( 20000 ) ;
} catch ( Exception e) {
e. printStackTrace ( ) ;
}
}
}
}
public class Demo {
public void method1 ( ) {
System . out. println ( "Demo中的method1方法" ) ;
}
}
注意：在一般情况下，使用不同的类加载器去加载不同的功能模块，会提高应用程序的安全性。但是，如果涉及Java类型转换，则加载器反而容易产生不美好的事情。在做Java类型转换时，只有两个类型都是由同一个加载器所加载，才能进行类型转换，否则转换时会发生异常。
方式一：重写loadClass方法 方式二：重写findClass()方法【推荐使用】 因此我们最好是在双亲委派模型框架内进行小范围的改动，不破坏原有的稳定结构。同时，也避免了自己重写loadClass()方法的过程中必须写双亲委托的重复代码，从代码的复用性来看，不直接修改loadClass()方法始终是比较好的选择。 5、代码实现参考热替换中的代码
424
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
