Java 类加载机制详解

引子

Java 虚拟机的启动是通过引导类加载器 ( Bootstrap Class Loader ) 创建一个初始类 (Initial Class ) 来完成，这个类是由虚拟机的具体实现指定。紧接着，Java虚拟机链接这个初始类，初始化并调用它的 public void main(String[])方法。之后的整个执行过程都是由对此方法的调用开始。执行 main 方法中的 Java 虚拟机指令可能会导致 Java 虚拟机链接另外的一些类或接口，也可能会调用另外的方法。

可能在某种 Java 虚拟机的实现上，初始类会作为命令行参数被提供给虚拟机。当然，虚拟机实现也可以利用一个初始类让类加载器依次加载整个应用。初始类当然也可以选择组合上述的方式来工作。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　—— 以上内容摘自《Java 虚拟机规范》（Java SE 7 版）

在讲类的加载机制前，先来看一道题目：

public class ClassLoaderTest {
    public static void main(String[] args) {
        System.out.println("爸爸的岁数:" + Son.factor);  //入口1
        // new Son();  //入口 2
    }
}

class Grandpa {
    static {
        System.out.println("爷爷在静态代码块");
    }
    public Grandpa() {
        System.out.println("我是爷爷~");
    }
}    

class Father extends Grandpa {
    static {
        System.out.println("爸爸在静态代码块");
    }
    public static int factor = 25;

    public Father() {
        System.out.println("我是爸爸~");
    }
}

class Son extends Father {
    static {
        System.out.println("儿子在静态代码块");
    }

    public Son() {
        System.out.println("我是儿子~");
    }
}

上面的代码中分了入口1和入口2，两者不同时存在，入口不一样，最后输出的结果也是不一样的。小伙伴可以思考下这两个入口对于类的初始化有啥不一样。下面是具体结果：

入口1 的结果：

爷爷在静态代码块
爸爸在静态代码块
爸爸的岁数:25

入口2 的结果

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
我是爷爷~
我是爸爸~
我是儿子~

如果以前没有遇到这种问题，现在要你解答肯定是很难的。该题考察的就是你对 Java 类加载机制的理解。如果你对 Java 加载机制不理解，那么你是无法解答这道题目的。

对比上面两个结果，可以发现，入口1 都是静态代码的初始化，入口2 既涉及到静态代码的初始化，也涉及到类的初始化。到此大家肯定就知道对于静态代码和非静态代码的初始化逻辑是有区别的。

这篇文章，将对 Java 类加载机制的进行讲解，让你以后遇到类似问题不在犯难。

类的加载过程

当 Java 虚拟机将 Java 源码编译为字节码之后，虚拟机便可以将字节码读取进内存，从而进行解析、运行等整个过程，这个过程我们叫：Java 虚拟机的类加载机制。JVM 虚拟机执行 class 字节码的过程可以分为七个阶段：加载、验证、准备、解析、初始化、使用、卸载。其中加载、检验、准备、初始化和卸载这个五个阶段的顺序是固定的，而解析则未必。为了支持动态绑定，解析这个过程可以发生在初始化阶段之后。

1. 加载

什么情况下需要开始类加载的第一个阶段：加载。 JAVA虚拟机规范并没有进行强制约束，交给虚拟机的具体实现自由把握。

加载阶段是“类加载”过程中的一个阶段，这个阶段通常也被称作“装载”，在加载阶段，虚拟机主要完成以下3件事情：

通过 "类全名" 来获取定义此类的二进制字节流
将字节流所代表的静态存储结构转换为方法区的运行时数据结构
在 java 堆中生成一个代表这个类的 java.lang.Class 对象，作为方法区这些数据的访问入口（所以我们能够通过低调用类.getClass() ）

注意这里字节流不一定非得要从一个 Class 文件获取，这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）。加载的信息存储在 JVM 的方法区。

对于数组类来说，它并没有对应的字节流，而是由 Java 虚拟机直接生成的。对于其它的类来说，Java 虚拟机则需要借助类加载器来完成查找字节流的过程。

如果上面那么多记不住：请一定记住这句： 加载阶段也就是查找获取类的二进制数据（磁盘或者网络）动作，将类的数据（Class 的信息：类的定义或者结构）放入方法区（内存）。

一图说明：

加载阶段

2. 验证

验证的主要作用就是确保被加载的类的正确性。也是连接阶段的第一步。说白了也就是我们加载好的 .class 文件不能对我们的虚拟机有危害，所以先检测验证一下。他主要是完成四个阶段的验证：

文件格式的验证：验证 .class 文件字节流是否符合 class 文件的格式的规范，并且能够被当前版本的虚拟机处理。这里面主要对魔数、主版本号、常量池等等的校验（魔数、主版本号都是 .class 文件里面包含的数据信息、在这里可以不用理解）。
元数据验证：主要是对字节码描述的信息进行语义分析，以保证其描述的信息符合 java 语言规范的要求，比如说验证这个类是不是有父类，类中的字段方法是不是和父类冲突等等。
字节码验证：这是整个验证过程最复杂的阶段，主要是通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。在元数据验证阶段对数据类型做出验证后，这个阶段主要对类的方法做出分析，保证类的方法在运行时不会做出威海虚拟机安全的事。
符号引用验证：它是验证的最后一个阶段，发生在虚拟机将符号引用转化为直接引用的时候。主要是对类自身以外的信息进行校验。目的是确保解析动作能够完成。

对整个类加载机制而言，验证阶段是一个很重要但是非必需的阶段，如果我们的代码能够确保没有问题，那么我们就没有必要去验证，毕竟验证需要花费一定的的时间。当然我们可以使用 -Xverfity:none 来关闭大部分的验证。

3. 准备（重点）

当完成字节码文件的校验之后，JVM 便会开始为类变量分配内存并初始化。这里需要注意两个关键点，即内存分配的对象以及初始化的类型。

内存分配的对象。Java 中的变量有「类变量」和「类成员变量」两种类型，「类变量」指的是被 static 修饰的变量，而其他所有类型的变量都属于「类成员变量」。在准备阶段，JVM 只会为「类变量」分配内存，而不会为「类成员变量」分配内存。「类成员变量」的内存分配需要等到初始化阶段才开始。

例如下面的代码在准备阶段，只会为 factor 属性分配内存，而不会为 website 属性分配内存。

public static int factor = 3;
public String website = "www.cnblogs.com/chanshuyi";

初始化的类型。在准备阶段，JVM 会为类变量分配内存，并为其初始化。但是这里的初始化指的是为变量赋予 Java 语言中该数据类型的零值，而不是用户代码里初始化的值。

例如下面的代码在准备阶段之后，sector 的值将是 0，而不是 3。

public static int sector = 3;

但如果一个变量是常量（被 static final 修饰）的话，那么在准备阶段，属性便会被赋予用户希望的值。例如下面的代码在准备阶段之后，number 的值将是 3，而不是 0。

public static final int number = 3;

之所以 static final 会直接被复制，而 static 变量会被赋予零值。其实我们稍微思考一下就能想明白了。

两个语句的区别是一个有 final 关键字修饰，另外一个没有。而 final 关键字在 Java 中代表不可改变的意思，意思就是说 number 的值一旦赋值就不会在改变了。既然一旦赋值就不会再改变，那么就必须一开始就给其赋予用户想要的值，因此被 final 修饰的类变量在准备阶段就会被赋予想要的值。而没有被 final 修饰的类变量，其可能在初始化阶段或者运行阶段发生变化，所以就没有必要在准备阶段对它赋予用户想要的值。

4. 解析

解析阶段是虚拟机常量池内的符号引用替换为直接引用的过程。

符号引用：符号引用是一组符号来描述所引用的目标对象，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引用的目标对象并不一定已经加载到内存中。Java 虚拟机明确在 Class 文件格式中定义的符号引用的字面量形式。

直接引用：直接引用可以是直接指向目标对象的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用是与虚拟机内存布局实现相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同，如果有了直接引用，那引用的目标必定已经在内存中存在。

在解析的阶段，解析动作主要针对7类符号引用进行，它们的名称以及对于常量池中的常量类型和解析报错信息如下：

| 解析动作 | 符号引用 | 解析可能的报错 | | ---------- | ------------------------------- | -----------------------------------------------------------

| | 类或接口 | CONSTANTClassInfo | java.land.IllegalAccessError

| | 字段 | CONSTANTFieldrefInfo | java.land.IllegalAccessError 或 java.land.NoSuchFieldError

| | 类方法 | CONSTANTMethodefInfo | java.land.IllegalAccessError 或 java.land.NoSuchMethodError

| | 接口方法 | CONSTANTInterfaceMethoderInfo | java.land.IllegalAccessError 或 java.land.NoSuchMethodError

| | 方法类型 | CONSTANTMethodTypeInfo |

| | 方法句柄 | CONSTANTMethodhandlerInfo |

| | 调用限定符 | CONSTANTInvokeDynamicInfo |

解析的整个阶段在虚拟机中还是比较复杂的，远比上面介绍的复杂的多，但是很多特别细节的东西我们可以暂时先忽略，先有个大概的认识和了解之后有时间在慢慢深入了。

5. 初始化（重点）

类初始阶段是类加载过程的最后一步，在上面提到的类加载过程中，除了加载阶段用户应用程序可以通过自定义类加载器参与之外，其余的动作全部由虚拟机主导和控制。初始化阶段，是真正开始执行类中定义的 Java 程序代码（或者说是字节码）。

在准备阶段，变量已经赋值过一次系统要求的初始值（零值），而在初始化阶段，则根据程序员通过程序制定的主观计划去初始化类变量和其他资源。（或者从另一个角度表达：初始化阶段是执行类构造器 <clinit>() 方法的过程。）

在这个阶段，JVM 会根据语句执行顺序对类对象进行初始化，一般来说当 JVM 遇到下面 5 种情况的时候会触发初始化：

遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的 Java 代码场景是：使用new 关键字实例化对象的时候、读取或设置一个类的静态字段（被 final 修饰、已在编译器把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。
使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类。
当使用 JDK1.7 动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果 REF_getstatic，REF_putstatic，REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。

看到上面几个条件你可能会晕了，但是不要紧，不需要背，知道一下就好，后面用到的时候回到找一下就可以了。

注意这里的初始化，并不是说创造的类的实例，而是执行了类构造器，简单来说就是只对静态变量，静态代码块进行初始化。对于构造函数只有在创建实例的时候才会执行。

6. 使用

当 JVM 完成初始化阶段之后，JVM 便开始从入口方法开始执行用户的程序代码。这个阶段也只是了解一下就可以。

7. 卸载

当用户程序代码执行完毕后，JVM 便开始销毁创建的 Class 对象，最后负责运行的 JVM 也退出内存。这个阶段也只是了解一下就可以。

8. 引子题目解答

还记得前面的题目嘛，下面开始分析：

入口1

也许会有人问为什么没有输出「儿子在静态代码块」这个字符串？

这是因为对于静态字段，只有直接定义这个字段的类才会被初始化（执行静态代码块）。因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

对面上面的这个例子，我们可以从入口开始分析一路分析下去：

首先程序到 main 方法这里，使用标准化输出 Son 类中的 factor 类成员变量，但是 Son 类中并没有定义这个类成员变量。于是往父类去找，我们在 Father 类中找到了对应的类成员变量，于是触发了 Father 的初始化。
但根据我们上面说到的初始化的 5 种情况中的第 3 种（当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化）。我们需要先初始化 Father 类的父类，也就是先初始化 Grandpa 类再初始化 Father 类。于是我们先初始化 Grandpa 类输出：「爷爷在静态代码块」，再初始化 Father 类输出：「爸爸在静态代码块」。
最后，所有父类都初始化完成之后，Son 类才能调用父类的静态变量，从而输出：「爸爸的岁数：25」。

入口2

这里采用 new 进行初始化，所以先进行父类得初始化。先是执行静态变量初始化。子类创建对象的同时会先创造父类的对象，因此必须先调用父类的构造方法。

变动

这里我做了一些改变：

public class ClassLoaderTest {
    public static void main(String[] args) {
        // System.out.println("爸爸的岁数:" + Son.factor);  //入口1
         new Son(3);  //入口 2
    }

}

class Grandpa {
    int s = 3;
  
    public Grandpa(int s) {
        System.out.println("我是爷爷~" );
    }
    static {
        System.out.println("爷爷在静态代码块");
    }
}    

class Father extends Grandpa {
    static {
        System.out.println("爸爸在静态代码块");
    }
    public static int factor = 25;

    public Father(int s) {
        //super(s);
        System.out.println("我是爸爸~");
    }
}

class Son extends Father {
    static {
        System.out.println("儿子在静态代码块");
    }

    public Son(int s ) {
        super(s);
        System.out.println("我是儿子~");
    }
}

这里的变动是，父类子类都只有一个有参构造函数，在初始化子类得时候，不显示的调用父类的构造函数，运行结果如下：

爷爷在静态代码块 Exception in thread "main" 
爸爸在静态代码块
儿子在静态代码块
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Implicit super constructor Grandpa() is undefined. Must explicitly invoke another constructor

    at Father.<init>(ClassLoaderTest.java:27)
    at Son.<init>(ClassLoaderTest.java:39)
    at ClassLoaderTest.main(ClassLoaderTest.java:5)

简单来说，如果子类构造函数不显示调用父类的构造函数，这时候在初始化子类得时候，就会去父类寻找无参构造函数，如果父类只定义了有参构造函数，没有无参构造函数，就会报错。因此一般来说最好是显示调用，又或者多定义几种不同的构造函数，方便在不同场景下调用。

类加载器

把类加载阶段的 "通过一个类的全限定名来获取描述此类的二进制字节流" 这个动作交给虚拟机之外的类加载器来完成。这样的好处在于，我们可以自行实现类加载器来加载其他格式的类，只要是二进制字节流就行，这就大大增强了加载器灵活性。

系统自带的类加载器分为三种：

启动类加载器。其它的类加载器都是 java.lang.ClassLoader 的子类，启动类加载器是由 C++ 实现的，没有对应的 Java 对象，因此在 Java 中只能用 null 代替。启动类加载器加载最为基础，最为重要的类，如 JRE 的 lib 目录下 jar 包中的类；扩展类加载器的父类是启动类加载器，它负责加载相对次要，但又通用的类，如 JRE 的 lib/ext 目录下jar包中的类
扩展类加载器。Java核心类库提供，负责加载java的扩展库（加载 JAVA_HOME/jre/ext/*.jar 中的类），开发者可以直接使用扩展类加载器。
应用程序类加载器。Java核心类库提供。应用类加载器的父类加载器则是扩展类加载器，它负责加载应用程序路径下的类。开发者可以直接使用这个类加载器，若应用程序中没有定义过自己的类加载器，java 应用的类都是由它来完成加载的。

具体关系如下：

双亲委派机制工作过程：

如果一个类加载器收到了类加载器的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父加载器去完成。每个层次的类加载器都是如此，因此所有的加载请求最终都会传送到 Bootstrap 类加载器(启动类加载器)中，只有父类加载反馈自己无法加载这个请求(它的搜索范围中没有找到所需的类)时，子加载器才会尝试自己去加载。

双亲委派模型的优点：java类随着它的加载器一起具备了一种带有优先级的层次关系.

例如类 java.lang.Object 它存放在 rt.jart 之中，无论哪一个类加载器都要加载这个类.最终都是双亲委派模型最顶端的 Bootstrap 类加载器去加载.因此Object类在程序的各种类加载器环境中都是同一个类.相反.如果没有使用双亲委派模型.由各个类加载器自行去加载的话.如果用户编写了一个称为 "java.lang.Object" 的类，并存放在程序的 ClassPath 中。那系统中将会出现多个不同的Object类，java类型体系中最基础的行为也就无法保证，应用程序也将会一片混乱。

这里也可以用代码验证下：

public class ClassLoaderTest {
    public static void main(String[] args) {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        System.out.println(loader);  
        System.out.println(loader.getParent());  
        System.out.println(loader.getParent().getParent());  
    }
}

输出结果为：

sun.misc.Launcher$AppClassLoader@2a139a55
sun.misc.Launcher$ExtClassLoader@7852e922
null

跟前面的描述是一致的。启动类加载器是由 C++ 实现的，没有对应的 Java 对象，因此在 Java 中只能用 null 代替。

自定义类加载器

1、为什么要自定义ClassLoader

因为系统的 ClassLoader 只会加载指定目录下的 class 文件,如果你想加载自己的 class 文件，那么就可以自定义一个 ClassLoader.

而且我们可以根据自己的需求，对 class 文件进行加密和解密。

2. 如何自定义ClassLoader

新建一个类继承自 java.lang.ClassLoader 重写它的 findClass 方法。将 class 字节码数组转换为 Class 类的实例。调用 loadClass 方法加载即可

代码实战：

先是定义一个自定义类加载器

package com.hello.test;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class MyClassLoader extends ClassLoader {
    // 指定路径
    private String path ;
    
    public MyClassLoader(String classPath){
        path=classPath;
    }
 
    /**
     * 重写findClass方法
     * @param name 是我们这个类的全路径
     * @return
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class log = null;
        // 获取该class文件字节码数组
        byte[] classData = getData();
 
        if (classData != null) {
            // 将class的字节码数组转换成Class类的实例
            log = defineClass(name, classData, 0, classData.length);
        }
        return log;
    }
 
    /**
     * 将class文件转化为字节码数组
     * @return
     */
    private byte[] getData() {
 
        File file = new File(path);
        if (file.exists()){
            FileInputStream in = null;
            ByteArrayOutputStream out = null;
            try {
                in = new FileInputStream(file);
                out = new ByteArrayOutputStream();
 
                byte[] buffer = new byte[1024];
                int size = 0;
                while ((size = in.read(buffer)) != -1) {
                    out.write(buffer, 0, size);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    in.close();
                } catch (IOException e) {
 
                    e.printStackTrace();
                }
            }
            return out.toByteArray();
        }else{
            return null;
        }
    }
}

可以再 getData 里面做很多事情，比如加密解密之类的都是可以的。

接着创建一个试验 class :

package com.hello.test;

public class Log {
    public static void main(String[] args) {
        System.out.println("load Log class successfully from log " );
    }
}

执行命令行 javac Log.java 生成我们的 Log.class 文件:

最后就是进行加载：

package com.hello.test;

import java.lang.reflect.Method;

public class ClassLoaderTest {
    public static void main(String[] args) {
         // 这个类class的路径,自己复制自己电脑的路径
        String classPath = "/Users/yourname/Documents/workspace-sts-3.9.6.RELEASE/HelloWorld/src/Log.class";
 
        MyClassLoader myClassLoader = new MyClassLoader(classPath);
        // 类的全称，对应包名
        String packageNamePath = "com.hello.test.Log";
        try {
        // 加载Log这个class文件
            Class<?> Log = myClassLoader.loadClass(packageNamePath);
            System.out.println("类加载器是:" + Log.getClassLoader());
            // 利用反射获取main方法
            Method method = Log.getDeclaredMethod("main", String[].class);
            Object object = Log.newInstance();
            String[] arg = {"ad"};
            method.invoke(object, (Object) arg);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

输出结果如下：

可以看到是委托父类进行加载的。到此，关于类加载器的内容就说完了。

巩固练习

最后我们再来看一道升级过后的题目：

public class Book {
 
    static int amount1 = 112;

    static Book book = new Book();  // 入口1


    public static void main(String[] args) {
        staticFunction();
    }


    static {
        System.out.println("书的静态代码块");
    }

    {
        System.out.println("书的普通代码块");
    }

    Book() {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +", amount=" + amount + ", amount1=" + amount1);
    }

    public static void staticFunction() {
        System.out.println("书的静态方法");

　　　　 System.out.println("amount=" + amount + ",amount1=" + amount1);

    }
    
    int price = 110;
    static int amount = 112;
    // static Book book = new Book(); // 入口2
}

入口1 的结果

书的普通代码块
书的构造方法
price=110, amount=0, amount1=112
书的静态代码块
书的静态方法
amount=112, amount1=112

入口2 的结果

书的静态代码块
书的普通代码块
书的构造方法
price=110, amount=112, amount1=112
书的静态方法
amount=112, amount1=112

入口1 分析

在上面两个例子中，因为 main 方法所在类并没有多余的代码，我们都直接忽略了 main 方法所在类的初始化。

但在这个例子中，main 方法所在类有许多代码，我们就并不能直接忽略了。

当 JVM 在准备阶段的时候，便会为类变量分配内存和进行初始化。此时，我们的 book 实例变量被初始化为 null，amount，amout1 变量被初始化为 0。
当进入初始化阶段后，因为 Book 方法是程序的入口，根据我们上面说到的类初始化的五种情况的第四种（当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类）。所以 JVM 会初始化 Book 类，即执行类构造器。
JVM 对 Book 类进行初始化首先是执行类构造器（按顺序收集类中所有静态代码块和类变量赋值语句就组成了类构造器），
后执行对象的构造器（按顺序收集成员变量赋值和普通代码块，最后收集对象构造器，最终组成对象构造器）。

对于入口1，执行类构造器发现 book 实例是静态变量，于是就会执行普通代码块，再去执行 book 的构造函数。执行完后，重新回到执行类构造器的路上，对剩下的静态变量进行初始化。

入口2 分析

入口2 的变化就是将静态实例初始化移到了最后。从而保证优先执行类构造器，再去进行对象初始化过程。

变例

假如把入口1，2 都注释掉，这回结果会怎么样：

书的静态代码块
书的静态方法
amount=112, amount1=112

可以发现，最终只有类构造器得到了执行。

方法论

从上面几个例子可以看出，分析一个类的执行顺序大概可以按照如下步骤：

确定类变量的初始值。在类加载的准备阶段，JVM 会为类变量初始化零值，这时候类变量会有一个初始的零值。如果是被 final 修饰的类变量，则直接会被初始成用户想要的值。
初始化入口方法。当进入类加载的初始化阶段后，JVM 会寻找整个 main 方法入口，从而初始化 main 方法所在的整个类。当需要对一个类进行初始化时，会首先初始化类构造器（），之后初始化对象构造器（）。
初始化类构造器。JVM 会按顺序收集类变量的赋值语句、静态代码块，最终组成类构造器由 JVM 执行。
初始化对象构造器。JVM 会按照收集成员变量的赋值语句、普通代码块，最后收集构造方法，将它们组成对象构造器，最终由 JVM 执行。

如果在初始化 main 方法所在类的时候遇到了其他类的初始化，那么就先加载对应的类，加载完成之后返回。如此反复循环，最终返回 main 方法所在类。

参考文章

刷新页面返回顶部

huansky