【jvm】02-手写自己的类加载器

最新推荐文章于 2022-08-13 10:49:56 发布
最新推荐文章于 2022-08-13 10:49:56 发布
阅读量232 收藏
点赞数
分类专栏： jvm 文章标签： java jvm jdk class tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/seal_li/article/details/108422861
版权

【jvm】02-手写自己的类加载器

欢迎关注b站账号/公众号【六边形战士夏宁】，一个要把各项指标拉满的男人。该文章已在github目录收录。
屏幕前的大帅比和大漂亮如果有帮助到你的话请顺手点个赞、加个收藏这对我真的很重要。别下次一定了，都不关注上哪下次一定。

1.简单手写自己的类加载器

创建一个类继承ClassLoader,然后重写findClass、loadClass这两个方法

findClass的方法

private static byte[] loadByte(String name) throws Exception {
    name = name.replaceAll("\\.", "/");
    FileInputStream fis = new FileInputStream(classPath + "/" + name
            + ".class");
    int len = fis.available();
    byte[] data = new byte[len];
    fis.read(data);
    fis.close();
    return data;
}

protected Class<?> findClass(String name) throws ClassNotFoundException {
    try {
        byte[] data = loadByte(name);
        //defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。
        return defineClass(name, data, 0, data.length);
    } catch (Exception e) {
        e.printStackTrace();
        throw new ClassNotFoundException();
    }
}

loadClass直接复制ClassLoader中的方法然后把错误的行数删除就行了
重点改动代码如下，让该自己的加载器加载指定包的文件，注意需要提前编译java文件为class

if (name.startsWith("com.example.demo.lesson")) {
    c = findClass(name);
} else {
    c = this.getParent().loadClass(name);
}

2.加载一个和jdk中同名的类

创建一个java.lang.Byte的类，然后用自己的类加载器去加载，然后就触发了jdk的沙箱机制，报了一个安全错误

tomcat的类加载器逻辑

如图所示，这里的核心其实就是每一个war包的代码即使含有同名的类也可以加载
做法如下，自己的classloader复制一份然后加载同一个class文件，可以看到启用的是不同的加载器，都被加载了

3.完整代码

package com.example.demo.lesson.jvm.myloader;

import java.io.FileInputStream;

/**
 * @author seal email:876651109@qq.com
 * @date 2020/9/1 7:23 PM
 * @description
 */
public class MyClassLoaderDemo {

    public static void main(String[] args) throws ClassNotFoundException {
        // Class clazz1 = new MyClassLoader().loadClass("com.example.demo.lesson.jvm.loader.A",false);
        //Class clazz1 = new MyClassLoader().loadClass("java.lang.Byte",false);
        Class clazz2 = new MyClassLoader2().loadClass("com.example.demo.lesson.jvm.loader.A",false);
        System.out.println(new MyClassLoaderDemo().getClass().getClassLoader());
        // System.out.println(clazz1.getClassLoader());
        System.out.println(clazz2.getClassLoader());
    }

    public static String classPath = "F:\\IdeaProjects\\TechingCode\\demoGrace\\src\\main\\java";
    private static byte[] loadByte(String name) throws Exception {
        name = name.replaceAll("\\.", "/");
        FileInputStream fis = new FileInputStream(classPath + "/" + name
                + ".class");
        int len = fis.available();
        byte[] data = new byte[len];
        fis.read(data);
        fis.close();
        return data;
    }

    static class MyClassLoader extends ClassLoader {

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                //defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

        @Override
        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();
                    if (name.startsWith("java.lang.Byte")) {
                        c = findClass(name);
                    } else {
                        c = this.getParent().loadClass(name);
                    }
                    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
                    }
                }
                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }
    }

    static class MyClassLoader2 extends ClassLoader {

        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                //defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

        @Override
        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();
                    if (name.startsWith("com.example.demo.lesson")) {
                        c = findClass(name);
                    } else {
                        c = this.getParent().loadClass(name);
                    }
                    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
                    }
                }
                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }
    }
}

4.ConstantPool

Constant pool:
    #1 = Methodref          #2.#3         // java/lang/Object."<init>":()V
    #2 = Class              #4            // java/lang/Object
    #3 = NameAndType        #5:#6         // "<init>":()V
    #4 = Utf8               java/lang/Object
    #5 = Utf8               <init>
    #6 = Utf8               ()V
    #7 = Fieldref           #8.#9         // com/example/demo/lesson/jvm/construction/Master.master2:Lcom/example/demo/lesson/jvm/construction/Master;
    #8 = Class              #10           // com/example/demo/lesson/jvm/construction/Master
    #9 = NameAndType        #11:#12       // master2:Lcom/example/demo/lesson/jvm/construction/Master;
   #10 = Utf8               com/example/demo/lesson/jvm/construction/Master
   #11 = Utf8               master2
   #12 = Utf8               Lcom/example/demo/lesson/jvm/construction/Master;
   #13 = Fieldref           #8.#14        // com/example/demo/lesson/jvm/construction/Master.master4:Lcom/example/demo/lesson/jvm/construction/Master;
   #14 = NameAndType        #15:#12       // master4:Lcom/example/demo/lesson/jvm/construction/Master;
   #15 = Utf8               master4
   #16 = Fieldref           #8.#17        // com/example/demo/lesson/jvm/construction/Master.int2:I
   #17 = NameAndType        #18:#19       // int2:I
   #18 = Utf8               int2
   #19 = Utf8               I
   #20 = Fieldref           #8.#21        // com/example/demo/lesson/jvm/construction/Master.int4:I
   #21 = NameAndType        #22:#19       // int4:I
   #22 = Utf8               int4
   #23 = Methodref          #24.#25       // java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
   #24 = Class              #26           // java/lang/Integer
   #25 = NameAndType        #27:#28       // valueOf:(I)Ljava/lang/Integer;
   #26 = Utf8               java/lang/Integer
   #27 = Utf8               valueOf
   #28 = Utf8               (I)Ljava/lang/Integer;
   #29 = Fieldref           #8.#30        // com/example/demo/lesson/jvm/construction/Master.integerMax2:Ljava/lang/Integer;
   #30 = NameAndType        #31:#32       // integerMax2:Ljava/lang/Integer;
   #31 = Utf8               integerMax2
   #32 = Utf8               Ljava/lang/Integer;
   #33 = Fieldref           #8.#34        // com/example/demo/lesson/jvm/construction/Master.integerMax4:Ljava/lang/Integer;
   #34 = NameAndType        #35:#32       // integerMax4:Ljava/lang/Integer;
   #35 = Utf8               integerMax4
   #36 = Fieldref           #8.#37        // com/example/demo/lesson/jvm/construction/Master.integerMin2:Ljava/lang/Integer;
   #37 = NameAndType        #38:#32       // integerMin2:Ljava/lang/Integer;
   #38 = Utf8               integerMin2
   #39 = Fieldref           #8.#40        // com/example/demo/lesson/jvm/construction/Master.integerMin4:Ljava/lang/Integer;
   #40 = NameAndType        #41:#32       // integerMin4:Ljava/lang/Integer;
   #41 = Utf8               integerMin4
   #42 = String             #43           // str25
   #43 = Utf8               str25
   #44 = Fieldref           #8.#45        // com/example/demo/lesson/jvm/construction/Master.str2:Ljava/lang/String;
   #45 = NameAndType        #46:#47       // str2:Ljava/lang/String;
   #46 = Utf8               str2
   #47 = Utf8               Ljava/lang/String;
   #48 = String             #49           // str27
   #49 = Utf8               str27
   #50 = Fieldref           #8.#51        // com/example/demo/lesson/jvm/construction/Master.str4:Ljava/lang/String;
   #51 = NameAndType        #52:#47       // str4:Ljava/lang/String;
   #52 = Utf8               str4
   #53 = Class              #54           // java/lang/String
   #54 = Utf8               java/lang/String
   #55 = String             #56           // str30
   #56 = Utf8               str30
   #57 = Methodref          #53.#58       // java/lang/String."<init>":(Ljava/lang/String;)V
   #58 = NameAndType        #5:#59        // "<init>":(Ljava/lang/String;)V
   #59 = Utf8               (Ljava/lang/String;)V
   #60 = Fieldref           #8.#61        // com/example/demo/lesson/jvm/construction/Master.strN2:Ljava/lang/String;
   #61 = NameAndType        #62:#47       // strN2:Ljava/lang/String;
   #62 = Utf8               strN2
   #63 = String             #64           // str32
   #64 = Utf8               str32
   #65 = Fieldref           #8.#66        // com/example/demo/lesson/jvm/construction/Master.strN4:Ljava/lang/String;
   #66 = NameAndType        #67:#47       // strN4:Ljava/lang/String;
   #67 = Utf8               strN4
   #68 = String             #69           // str35
   #69 = Utf8               str35
   #70 = Methodref          #53.#71       // java/lang/String.intern:()Ljava/lang/String;
   #71 = NameAndType        #72:#73       // intern:()Ljava/lang/String;
   #72 = Utf8               intern
   #73 = Utf8               ()Ljava/lang/String;
   #74 = Fieldref           #8.#75        // com/example/demo/lesson/jvm/construction/Master.strI2:Ljava/lang/String;
   #75 = NameAndType        #76:#47       // strI2:Ljava/lang/String;
   #76 = Utf8               strI2
   #77 = String             #78           // str37
   #78 = Utf8               str37
   #79 = Fieldref           #8.#80        // com/example/demo/lesson/jvm/construction/Master.strI4:Ljava/lang/String;
   #80 = NameAndType        #81:#47       // strI4:Ljava/lang/String;
   #81 = Utf8               strI4
   #82 = String             #83           // str54
   #83 = Utf8               str54
   #84 = String             #85           // str56
   #85 = Utf8               str56
   #86 = String             #87           // str57
   #87 = Utf8               str57
   #88 = String             #89           // str59
   #89 = Utf8               str59
   #90 = String             #91           // str60
   #91 = Utf8               str60
   #92 = Fieldref           #93.#94       // java/lang/System.out:Ljava/io/PrintStream;
   #93 = Class              #95           // java/lang/System
   #94 = NameAndType        #96:#97       // out:Ljava/io/PrintStream;
   #95 = Utf8               java/lang/System
   #96 = Utf8               out
   #97 = Utf8               Ljava/io/PrintStream;
   #98 = Fieldref           #8.#99        // com/example/demo/lesson/jvm/construction/Master.integerMin1:Ljava/lang/Integer;
   #99 = NameAndType        #100:#32      // integerMin1:Ljava/lang/Integer;
  #100 = Utf8               integerMin1
  #101 = Methodref          #102.#103     // java/io/PrintStream.println:(Z)V
  #102 = Class              #104          // java/io/PrintStream
  #103 = NameAndType        #105:#106     // println:(Z)V
  #104 = Utf8               java/io/PrintStream
  #105 = Utf8               println
  #106 = Utf8               (Z)V
  #107 = Fieldref           #8.#108       // com/example/demo/lesson/jvm/construction/Master.integerMax1:Ljava/lang/Integer;
  #108 = NameAndType        #109:#32      // integerMax1:Ljava/lang/Integer;
  #109 = Utf8               integerMax1
  #110 = Fieldref           #8.#111       // com/example/demo/lesson/jvm/construction/Master.strN1:Ljava/lang/String;
  #111 = NameAndType        #112:#47      // strN1:Ljava/lang/String;
  #112 = Utf8               strN1
  #113 = String             #114          // str29
  #114 = Utf8               str29
  #115 = String             #116          // abc
  #116 = Utf8               abc
  #117 = Fieldref           #8.#118       // com/example/demo/lesson/jvm/construction/Master.master1:Lcom/example/demo/lesson/jvm/construction/Master;
  #118 = NameAndType        #119:#12      // master1:Lcom/example/demo/lesson/jvm/construction/Master;
  #119 = Utf8               master1
  #120 = Fieldref           #8.#121       // com/example/demo/lesson/jvm/construction/Master.master3:Lcom/example/demo/lesson/jvm/construction/Master;
  #121 = NameAndType        #122:#12      // master3:Lcom/example/demo/lesson/jvm/construction/Master;
  #122 = Utf8               master3
  #123 = Fieldref           #8.#124       // com/example/demo/lesson/jvm/construction/Master.int3:I
  #124 = NameAndType        #125:#19      // int3:I
  #125 = Utf8               int3
  #126 = Fieldref           #8.#127       // com/example/demo/lesson/jvm/construction/Master.integerMax3:Ljava/lang/Integer;
  #127 = NameAndType        #128:#32      // integerMax3:Ljava/lang/Integer;
  #128 = Utf8               integerMax3
  #129 = Fieldref           #8.#130       // com/example/demo/lesson/jvm/construction/Master.integerMin3:Ljava/lang/Integer;
  #130 = NameAndType        #131:#32      // integerMin3:Ljava/lang/Integer;
  #131 = Utf8               integerMin3
  #132 = String             #133          // str26
  #133 = Utf8               str26
  #134 = Fieldref           #8.#135       // com/example/demo/lesson/jvm/construction/Master.str3:Ljava/lang/String;
  #135 = NameAndType        #136:#47      // str3:Ljava/lang/String;
  #136 = Utf8               str3
  #137 = String             #138          // str31
  #138 = Utf8               str31
  #139 = Fieldref           #8.#140       // com/example/demo/lesson/jvm/construction/Master.strN3:Ljava/lang/String;
  #140 = NameAndType        #141:#47      // strN3:Ljava/lang/String;
  #141 = Utf8               strN3
  #142 = String             #143          // str34
  #143 = Utf8               str34
  #144 = Fieldref           #8.#145       // com/example/demo/lesson/jvm/construction/Master.strI1:Ljava/lang/String;
  #145 = NameAndType        #146:#47      // strI1:Ljava/lang/String;
  #146 = Utf8               strI1
  #147 = String             #148          // str36
  #148 = Utf8               str36
  #149 = Fieldref           #8.#150       // com/example/demo/lesson/jvm/construction/Master.strI3:Ljava/lang/String;
  #150 = NameAndType        #151:#47      // strI3:Ljava/lang/String;
  #151 = Utf8               strI3
  #152 = Utf8               int1
  #153 = Utf8               ConstantValue
  #154 = Integer            9
  #155 = Integer            10
  #156 = Utf8               str1
  #157 = String             #158          // str24
  #158 = Utf8               str24
  #159 = Utf8               Code
  #160 = Utf8               LineNumberTable
  #161 = Utf8               main
  #162 = Utf8               ([Ljava/lang/String;)V
  #163 = Utf8               StackMapTable
  #164 = Class              #165          // "[Ljava/lang/String;"
  #165 = Utf8               [Ljava/lang/String;
  #166 = Utf8               <clinit>
  #167 = Utf8               SourceFile
  #168 = Utf8               Master.java

参考资料

《深入理解Java虚拟机》-周志明

seal_li
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
大牛程序员用Java手写JVM：刚好够运行 HelloWorld
weixin_33709364的博客
01-04 5347
专注于Java领域优质技术号，欢迎关注作者：老曹撸代码1. 前言没错这又是一篇介绍 JVM 的文章，这类文章网上已经很多，不同角度、不同深度、不同广度，也都不乏优秀的。为什么还要来一篇？首先对于我来说，我正在学习 Java，了解JVM的实现对学习Java当然很有必要，但我已经做了多年C++开发，就算我用C++实现一个JVM，我还是个C++码农，而用 Java实现，即能学习 Java 语法，又能理解...
用Java手写JVM第一章——命令行工具
qq_46351133的博客
05-18 817
解析简单的参数 1、现在pom.xml中导入jcommander依赖，这个库用于解析参数。 <dependency> <groupId>com.beust</groupId> <artifactId>jcommander</artifactId> <version>1.72</version> </dependency> 2、首先定义
【手写JVM专栏】二、搭建JVM框架，输出hello world
子牙老师
07-26 1783
哈喽，大家好，我就是明明可以靠脸吃饭，却偏偏抢大家饭碗的硬核男人子牙老师。 本篇文章是专栏《用Java带你手写JVM》的第二篇。画人画皮先画骨，本篇文章咱们的目标是实现JVM框架，输出hello world。 是不是完全不知道代码怎么写？是不是就像当初学会Java不知道怎么做东西的感觉是一样的？这就是我说的虚拟机思维。把我这套课程跟完，把练习做做，慢慢地，你就有了虚拟机思维。这种思维对于你研究Hotspot或其他虚拟机，是非常非常非常有帮助的！ 课程目标 本篇文章咱们要学习的目标就是在我们自己实现的JVM
java 手写 jvm高性能缓存
weixin_30727835的博客
07-02 358
java 手写 jvm高性能缓存，键值对存储，队列存储，存储超时设置 缓存接口 package com.ws.commons.cache; public interface ICache { void expire(String key, int timeOutSecond); void leftPush(String key, Object...
minicat.rar
12-11
1. 自定义类加载器：在Java中，类加载器负责将类的字节码加载到JVM中。Tomcat作为一个Web服务器，它有自己的类加载机制，用于隔离不同Web应用的类加载，防止类冲突。自定义类加载器可以让我们根据需求定制加载规则，...
一次性精通JVM JAVA虚拟机
06-17
第3章 类的加载、解释、编译，本章节带你深入理解类加载器的分类、范围、双亲委托策略，自己手写类加载器，理解字节码解释器、即时编译器、混合模式、热点代码检测、分层编译等核心知识。 第4章 内存模型，本章节...
JVM讲解视频.zip
05-13
手写自定义类加载器类加载器双亲委派机制 oJVM内存模型深度理解 JVM内存模型结构 线程栈及栈帧内部结构详解 程序计数器详解 本地方法栈详解 堆详解 JVM启动参数设置 堆内存大小设置 方法...
java虚拟机简单原理jvm.pdf
11-26
类加载器是 JVM 中的一个重要组件，它负责加载 Java 类文件并将其转换为 JVM 可以识别的格式。在 MiniJavaVM 中，类加载器使用了一个简单的类加载算法，通过读取 Java 类文件并将其转换为 bytecode。 执行引擎 ...
手写JAVA虚拟机（一）——搭建环境
weixin_30559481的博客
04-17 321
　　毕业设计打算做一个java虚拟机，首先要对java虚拟机有一个简单的了解（jvm）。目前市面上有众多的jvm，如sun公司的HotSpot VM、Classic VM，IBM公司的J9 VM等等，这里以sun公司的HotSpot VM为蓝本实现一个java虚拟机。为什么选用hotspot呢，因为这个是目前jdk里面自带的并且是默认的jvm，也是使用最多的jvm。 　　 　　虽然世面上的jv...
自己手写Java虚拟机（第1章 命令行工具）
荆州长江大学 余攀(Java学生)
10-25 1106
学习Java虚拟机以及go语法，记录下自己的学习过程 第1章 命令行工具 1.1 准备工作 1.1.1 安装JDK 1.1.2 安装Go 1.1.3 创建目录结构 1.2 java命令 1.3 编写命令行工具 1.4 测试本章代码 1.5 本章小结 1.1 准备工作 这里就不作说明了，看书就可以轻松完成。 1.2 java命令 问题：如何启动Java应用程序？ 首先启动Java虚拟机，然...
手写JAVA虚拟机（二）——实现java命令行，java面试题，java基础笔试题，BAT
ccc_ccc8的博客
04-23 272
写在最前面，我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。扫码加微信好友进【程序员面试学习交流群】，免费领取。也欢迎各位一起在群里探讨技术。 查看手写JAVA虚拟机系列可以进我的博客园主页查看。 我们知道，我们编译.java并运行.class文件时，需要一些java命令，如最简单的helloworld程序。 这里的程序最...
能不做自己写个类，也叫java.lang.String?
evilcry2012的专栏
05-08 745
能不做自己写个类，也叫java.lang.String?  [复制链接] ozt6719393 1 黑马币 27 技术分 31 主题 中级黑马 发消息 电梯直达 楼主  发表于
Java类加载器--手写一个String类能否被类加载器加载？
Doit_kang的博客
07-06 3381
谈到Java的类加载器，大家应该都不陌生。但最近在逛面经分享时看到这样一个问题：“手写一个String类能否被类加载器加载？”笔者自己试了下，发现这个问题几乎把类加载器的原理都考了一遍，不信咱们就来碰一碰它。
JVM，用户自己写一个String类，会发生什么？
ganlanA的博客
01-02 2423
JVM，用户自己写一个String类，会发生什么？
JVM基础_2_类加载
最新发布
胖胖的博客
08-13 329
自定义String类，但是在加载自定义String类的时候会优先用启动类加载器进行加载，启动类加载器会优先加载jdk自带文件中的String类，而不是用户自定义的String类。JVM对class文件采用的是按需加载的方式，也就是说等到需要使用该类的时候才会对它的class文件加载到内存生成class对象。用户可以通过继承java.lang.ClassLoader类的方式，实现自己的类加载器，以满足自己的需求。Java程序对类的使用方式分为：主动使用和被动使用。将常量池内的符号引用转换为直接引用的过程。..
java中自定义String会怎样？
pocher的博客
05-10 5180
为了验证java的双亲委派模型模型，小编我决定自己做个试验。 包名和java自身String所在的java.lang包名不一致时的情况 首先，我们自定义一个包名不是java.lang的String（注意如果包名不是java.lang直接将java自定的String拷贝过来会报错，所以为了省去麻烦，此处小编没有使用从官方拷贝过来的String） package com.school.eut...
能否自己也写一个类叫做java.lang.String?
weixin_33973600的博客
01-07 659
  这次的随笔很逗吧~没错，我们的确也可以自己在创建一个包java.lang，然后在 相应的包下面创建一个对应的类String，但是在每次jre运行的时候，我们都回去加载原来默认的java.lang.String,这样的话，重写和没有重写也就没有 什么作用了。但是如果在web应用中我们可以在WEB-INF/classess下面创建对应的String类，这样在每次启用tomcat的时候都会先去加...
jvm基础学习，介绍各种jvm里面的知识点，和深入理解java虚拟机很像，易懂
11-13
jvm面试，jvm，想要学习jvm，这一个就够了，深度学习jvm，大家看一下，速学jvm

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

seal_li

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值