Android 简单热修复（上）——Java类加载器

2018-01-04 489

作为阳历新年的第一篇文章，本想把之前总结的用到实践中，简单写了个钟表，写着写着感觉索然无味(/ □ )。写完后，百无聊赖之际，随便翻看了些技术文章。让我眼前为之一亮的有两个：

Android 破解跳一跳
Android 简单热修复原理

作为Android狗的我果断选择了热修复的介绍，在看完Android类加载器的源码后，对于简单的热修复原理算是了解了一些。遂作此文，以谨记。

在介绍Android热修复原理之前，有必要了解下关于Java的类加载器的相关知识。在《深入理解Java虚拟机》一书中关于类加载的可以分为五个过程：

加载
在加载过程中需要完成3件事情：
1.1 通过一个类的全限定名来获取定义此类的二进制字节流。
1.2 将这个字节流所代表的静态存储结构转换为方法区的运行时数据结构。
1.3 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。
验证
这一阶段的主要目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
准备
准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。
解析
解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。
初始化
初始化阶段是执行类构造器<clinit>()方法的过程。

关于详细介绍，还是乖乖看书吧。
OK，知道了类加载的过程，但是究竟是什么“东西”加载类呢？答案是类加载器（ClassLoader），也是今天的主题。
简单说下类加载器的分类：

启动类加载器（BootStrap ClassLoader）：启动类加载器负责将<JAVA_HOME>\lib目录下中的，或者被-Xbootclasspath参数所指定的路径中的，并且被虚拟机识别的类库加载到虚拟机内存中（有点拗口）。通过System.getProperty("sun.boot.class.path")可知默认情况加载如下类库：

C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar
C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar
C:\Program Files\Java\jdk1.8.0_131\jre\lib\sunrsasign.jar
C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar
C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar
C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar
C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar
C:\Program Files\Java\jdk1.8.0_131\jre\classes

扩展类加载器（Extension ClassLoader）：扩展类加载器用于将<JAVA_HOME>\lib\ext中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库。扩展类加载器加载的类库（默认情况），可以看到其就是<JAVA_HOME>\lib\ext中的类库：

扩展类加载器加载的类库
应用程序类加载器（Application ClassLoader）：用于加载用户类路径上所指定的类库，如果程序没有自定义过自己的类加载器，一般情况下这个就是这个程序的默认类加载器。应用程序类加载器加载的类库（默认情况），可以看到其加载的类库包括了<JAVA_HOME>\lib和<JAVA_HOME>\lib\ext目录下的类库，也就是说如果前两个没有找到要加载的类，也可以通过AppClassLoader去加载：

应用程序类加载器加载的类库

启动类加载器

上面已经说过启动类加载器会加载的类库，下午我和一个大佬讨论了下关于java类是否按需加载。答案是：java类是按需加载，只有当需要用到这个类的时候才会加载这个类。在运行时添加-verbose:class参数，我们先看到被加载到内存中的类：

启动时加载的类

启动类加载了rt.jar中的类，我们可以通过反向来证明某个类是由启动类加载器加载：

System.out.println(String.class.getClassLoader());

在上面我们只是输出了一下String这个类的类加载器，结果如下：

String类加载器

我们可以知道其类加载器是 null，这又是为什么呢？我们看下 getClassLoader()这个方法的注释：

注释

从注释中我们可以知道如果返回值为 null，那么代表此时的类加载器是 BootStrap ClassLoader，所以上面所讲述的完全没毛病。

扩展类加载器

先看下默认的<JAVA_HOME>\lib\ext路径下的类库有什么：

ext类库

默认的路径下加载的类库并不是特别多，我们挑选其中的一个来测试下：

System.out.println(JarFileSystemProvider.class.getClassLoader());

测试扩展类加载器

从结果中我们可以知道加载扩展类的加载器是 sun.misc.Launcher类的内部类 ExtClassLoader。

应用程序类加载器

应用程序加载器用于加载当前程序的类库（默认情况下），按照上面的测试我们同样测试下：

// UserModel为当前程序里的一个类
System.out.println(UserModel.class.getClassLoader());

运行结果：

应用程序类加载器

从结果中我们可以知道加载扩展类的加载器是 sun.misc.Launcher类的内部类 AppClassLoader。
类关系图：

类关系图

讲下每个类加载器的父亲：

BootStrap ClassLoader：无父类加载器
ExtClassLoader：父类加载器BootStrap ClassLoader
AppClassLoader：父类加载器ExtClassLoader

关于三个类加载器的创建

BootStrap ClassLoader

Bootstrap ClassLoader是由C/C++编写的，它本身是虚拟机的一部分，所以它并不是一个JAVA类，也就是无法在Java代码中获取它的引用。

ExtClassLoader的创建

话不多少，还是先看下代码吧：

Launcher.java:
public Launcher() {
    Launcher.ExtClassLoader var1;
    try {
        // 获得ExtClassLoader
        var1 = Launcher.ExtClassLoader.getExtClassLoader();
    } catch (IOException var10) {
        throw new InternalError("Could not create extension class loader", var10);
    }

    try {
        // 将ExtClassLoader作为参数传入AppClassLoader中
        this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
    } catch (IOException var9) {
        throw new InternalError("Could not create application class loader", var9);
    }

    Thread.currentThread().setContextClassLoader(this.loader);
    ......

}

static class ExtClassLoader extends URLClassLoader {
    public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
        // 获取了Ext的目录
        final File[] var0 = getExtDirs();

        try {
            return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
                public Launcher.ExtClassLoader run() throws IOException {
                    int var1 = var0.length;

                    for(int var2 = 0; var2 < var1; ++var2) {
                        MetaIndex.registerDirectory(var0[var2]);
                    }
                    // 创建一个新的ExtClassLoader，传入文件数组
                    return new Launcher.ExtClassLoader(var0);
                }
            });
        } catch (PrivilegedActionException var2) {
            throw (IOException)var2.getException();
        }
    }

    void addExtURL(URL var1) {
        super.addURL(var1);
    }

    public ExtClassLoader(File[] var1) throws IOException {
        // 父类构造方法，其中第二个参数为parent也就是当前ClassLoader的父类加载器
        // 这里传入的是null，也就是其父类加载器是BootStrap ClassLoader
        super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
        SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
    }

    private static File[] getExtDirs() {
        String var0 = System.getProperty("java.ext.dirs");
        File[] var1;
        if(var0 != null) {
            StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);
            int var3 = var2.countTokens();
            var1 = new File[var3];

            for(int var4 = 0; var4 < var3; ++var4) {
                var1[var4] = new File(var2.nextToken());
            }
        } else {
            var1 = new File[0];
        }

        return var1;
    }

    ......
}

从代码中我们可以知晓：

ExtClassLoader是在Launcher中创建，并且指定其父类加载器为null（BootStrap ClassLoader）
通过getExtDirs获得扩展类的目录文件数组

我们看下getExtDirs输出：

C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext
C:\Windows\Sun\Java\lib\ext

这个输出一个代表了<JAVA_HOME>\lib\ext路径，另一个则是默认的扩展类路径。

AppClassLoader的创建

从Launcher的部分代码中可以知道ExtClassLoader作为参数传入AppClassLoader中，这里看下AppClassLoader类：

static class AppClassLoader extends URLClassLoader {
    final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);

    public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
        final String var1 = System.getProperty("java.class.path");
        final File[] var2 = var1 == null?new File[0]:Launcher.getClassPath(var1);
        return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
            public Launcher.AppClassLoader run() {
                URL[] var1x = var1 == null?new URL[0]:Launcher.pathToURLs(var2);
                // 这里将传入的ExtClassLoader作为构造参数，说明其父类加载器为ExtClassLoader
                return new Launcher.AppClassLoader(var1x, var0);
            }
        });
    }

    AppClassLoader(URL[] var1, ClassLoader var2) {
        super(var1, var2, Launcher.factory);
        this.ucp.initLookupCache(this);
    }

    public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
        int var3 = var1.lastIndexOf(46);
        // 加载前的判断，检查包权限以及是否已经知道不存在
        if(var3 != -1) {
            SecurityManager var4 = System.getSecurityManager();
            if(var4 != null) {
                var4.checkPackageAccess(var1.substring(0, var3));
            }
        }

        if(this.ucp.knownToNotExist(var1)) {
            Class var5 = this.findLoadedClass(var1);
            if(var5 != null) {
                if(var2) {
                    this.resolveClass(var5);
                }

                return var5;
            } else {
                throw new ClassNotFoundException(var1);
            }
        } else {
            // 调用ClassLoader的loadClass
            return super.loadClass(var1, var2);
        }
    }

    ......
}

AppClassLoader把ExtClassLoader作为父类加载器，并且重写了loadClass方法，用于校验。不过我在debug时发现System.getSecurityManager()返回值为null，所以推测这里需要自己实现安全管理。

验证：

ClassLoader classLoader = Main.class.getClassLoader();
while (classLoader.getParent() != null) {
    System.out.println(classLoader);
    classLoader = classLoader.getParent();
}
System.out.println(classLoader);

输出：

sun.misc.Launcher$AppClassLoader@18b4aac2
sun.misc.Launcher$ExtClassLoader@1540e19d

类加载器的双亲委派机制

双亲委派机制模型

双亲委派机制：某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。
好处：使用双亲委派模型的好处在于Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object，它存在在rt.jar中，无论哪一个类加载器要加载这个类，最终都是委派给处于模型最顶端的Bootstrap ClassLoader进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。相反，如果没有双亲委派模型而是由各个类加载器自行加载的话，如果用户编写了一个java.lang.Object的同名类并放在ClassPath中，那系统中将会出现多个不同的Object类，程序将混乱。因此，如果开发者尝试编写一个与rt.jar类库中重名的Java类，可以正常编译，但是永远无法被加载运行。
（《深入理解Java虚拟机》）

双亲委派机制的实现

废话不多说，先上代码为敬：

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        // 第一步检查此类是否已经被加载，native层实现
        Class<?> c = findLoadedClass(name);
        // 如果没有被加载
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                // 获取其父类加载器，并且调用loadClass()方法
                // 如果父类加载器是BootStrap ClassLoader，则调用findBootstrapClassOrNull
                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
            }
            
            // 如果没有加载此类，尝试通过类名查找此类
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

这里看下loadClass的过程：

查看类是否已经被加载过，通过native方法实现。如果已经加载过，直接返回此Class。
类没有被加载过，如果其父类加载器存在，调用父类加载器的loadClass方法加载Class。
父类加载器不存在，调用findBootstrapClassOrNull方法查找启动类加载器是否加载此类，如果有加载则返回；如果没有加载则调用findClass方法。
递归的过程中如果有一处得到了Class，那么将返回此Class。

光说不练假把式，还是来举两个栗子吧

1. 启动类加载器加载类

测试代码：

System.out.println(Provider.class.getClassLoader());

接着将ClassLoader中的findClass设置断点，调试。执行结果如下：

第一次

AppClassLoader

可以看到，第一次执行的时候是AppClassLoader进行loadClass方法的调用。接着进入parent.loadClass方法中：

parent.loadClass

ExtClassLoader

接着调用了ExtClassLoader中的loadClass方法，我们知道其父类加载器不存在，所以执行findBootstrapClassOrNull方法：

findBootstrapClassOrNull

因为我现在挑选的是启动类加载器加载的类，所以这里面返回值不为空，接着就把此值返回给 ExtClassLoader， ExtClassLoader又把值返回给 AppClassLoader，最终将值返回，整个过程结束。

2. 应用程序类加载器

测试代码：

System.out.println(UserModel.class.getClassLoader());

接着将ClassLoader中的findClass设置断点，调试。其查找过程和上面一致，这里不多说，这里需要知道的是此时findBootstrapClassOrNull方法返回值为null，接着会调用findClass方法：

ExtClassLoader findClass

ExtClassLoader

在 ExtClassLoader中查找 UserModel没有找到，返回结果 null，紧接着就会调用 AppClassLoader的 findClass方法：

AppClassLoader findClass

AppClassLoader

通过 defineClass方法最终获取到UserModel类，并将结果返回。

破坏双亲委派机制的自定义类加载器

双亲委派机制是建立在不重写loadClass流程的基础上，如果某一个自定义类加载器重写了loadClass方法，并将其流程改变，那么所谓的双亲委派机制也就消失了。下面的自定义类加载器破坏了双亲委派机制：

public class CustomClassLoader extends ClassLoader {

    private String classPath;

    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }
    // 重写了loadClass方法，不用去查找是否加载，如果类文件存在，直接返回所需类
    // 否则按照原方式进行
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        File file = new File(classPath + name.replace(".", "\\") + ".class");
        if (file.exists()) {
            try {
                InputStream is = new FileInputStream(file);
                byte[] b = new byte[is.available()];
                is.read(b);
                return defineClass(name, b, 0, b.length);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return super.loadClass(name);
    }

}
// 测试代码
private static void test() {
    CustomClassLoader customClassLoader = new CustomClassLoader("C:\\Users\\B-0137\\Desktop\\");
    try {
        Class<?> userModel = customClassLoader.loadClass("com.nick.model.UserModel");
        Object o = userModel.newInstance();
        System.out.println(o);
        System.out.println(o instanceof UserModel);
        IUser iUser = (IUser) o;
        iUser.test();

        Class<?> mC = Main.class.getClassLoader().loadClass("com.nick.model.UserModel");
        Object mainO = mC.newInstance();
        System.out.println(mainO);
        System.out.println(mainO instanceof UserModel);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    }
}

测试结果：

com.nick.model.UserModel@7f31245a
false
测试
com.nick.model.UserModel@6d6f6e28
true

在这也能看出通过破坏双亲委派机制可以由不同的类加载器加载相同的类，但是他们并不相等——类加载器不同。

保持双亲委派机制的自定义类加载器

其实想要保持双亲委派机制很简单：只需要在自定义类加载器的时候重写findClass方法即可。
自定义类加载器这里省略，就是重写了findClass方法，其他代码没变。测试代码：

private static void test() {
    CustomClassLoader customClassLoader = new CustomClassLoader("C:\\Users\\B-0137\\Desktop\\");
    try {
        Class<?> userModel = customClassLoader.loadClass("com.nick.model.UserModel");
        Object o = userModel.newInstance();
        System.out.println(o);
        System.out.println(o instanceof UserModel);
        System.out.println(userModel.getClassLoader());
        IUser iUser = (IUser) o;
        iUser.test();
        System.out.println();

        Class<?> mC = Main.class.getClassLoader().loadClass("com.nick.model.UserModel");
        Object mainO = mC.newInstance();
        System.out.println(mainO);
        System.out.println(mainO instanceof UserModel);
        System.out.println(mC.getClassLoader());
        System.out.println();
        
        Class<?> userModel2 = customClassLoader.loadClass("com.nick.model.UserModel2");
        Object o2 = userModel2.newInstance();
        System.out.println(o2);
        System.out.println(userModel2.getClassLoader());
        IUser iUser2 = (IUser) o;
        iUser2.test();

    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    }
}

测试结果：

com.nick.model.UserModel@677327b6
true
sun.misc.Launcher$AppClassLoader@18b4aac2
测试

com.nick.model.UserModel@14ae5a5
true
sun.misc.Launcher$AppClassLoader@18b4aac2

com.nick.model.UserModel2@135fbaa4
com.nick.classloader.CustomClassLoader@7f31245a
测试

我们用自定义的类加载器去加载外部的一个和项目中同名的类，结果发现其是由应用程序类加载器加载，那么可以说明自定义类加载器重写findclass方法保持了双亲委派机制。

结尾

作为开年的第一篇文章，洋洋洒洒写了好多字。从论据到论点，详详细细全部写完。啰哩啰唆说了一大堆，结果还没进入正题（热修复）。这篇文章主要是为热修复打下些基础，下一篇将会讲述基于类加载器原理实现的热修复以及如何实现。
最后上个美女养养眼吧~

img_e4f27a7d57580f0ca53217bcf19f0f46.jpe

美女

微信关注我们

原文链接：https://yq.aliyun.com/articles/665834

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Java中的main线程是不是最后一个退出的线程

之所以写这篇文章，是因为上次被人问到这么一个问题：“在main函数里启动一个定时器，是不是main函数执行完整个程序就退出了，包括那个定时器”。多说无益，直接写个程序测试一下就知道了。 Java代码 publicclassMainThreadTest{ publicstaticvoidmain(String[]args){ newTimer().schedule(newTimerTask(){ @Override publicvoidrun(){ System.out.println("Timerthreadisrunning..."); } },500,500); System.out.println("Mainthreadends!"); } } 然后你就会发现执行结果是这样的：引用 Main thread ends! Timer thread is running... Timer thread is running... Timer thread is running... 这至少说明main函数执行完毕之后，定时器依旧在运行，那么main线程是否退出了呢？我想不少同...

2018-01-05

724

官方文档中对event的解释如下： event是用户调用函数时传入的数据，它可以是一个简单的string，也可以是一个JSON string，还可以是一个图片（二进制数据）。函数中的event参数是个字节流，在Python2.7中是str类型，在Python3中是bytes类型。用户在函数中可以根据实际情况对event进行转换：输入数据是一个JSON string的话，用户可以把它转换成一个dict: # -*- coding: utf-8 -*- import json def my_handler(event, context): evt = json.loads(event) return evt['key'] 输入数据是一个文件的bytes, 比如图片的文件作为event参数传入 # -*- coding: utf

2018-01-05

865

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

Android 简单热修复（上）——Java类加载器

启动类加载器

扩展类加载器

应用程序类加载器

关于三个类加载器的创建

BootStrap ClassLoader

ExtClassLoader的创建

AppClassLoader的创建

类加载器的双亲委派机制

双亲委派机制的实现

光说不练假把式，还是来举两个栗子吧

1. 启动类加载器加载类

2. 应用程序类加载器

破坏双亲委派机制的自定义类加载器

保持双亲委派机制的自定义类加载器

结尾

Java中的main线程是不是最后一个退出的线程

函数计算入口参数event详解

相关文章

发表评论

资源下载

优质分享App

Mario

Spring

Sublime Text

欢迎您来访！