类加载机制实现Android热修复

最新推荐文章于 2024-03-17 23:01:19 发布

一个有梦想的屌丝程序员

最新推荐文章于 2024-03-17 23:01:19 发布

阅读量1.7k

点赞数 3

分类专栏： android热修复文章标签：热修复类加载机制 android热修复热修复原理

本文链接：https://blog.csdn.net/u013366008/article/details/77932938

版权

android热修复专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文通过类加载机制实现Android热修复，Demo实现的功能：检测服务器是否存在补丁，存在即下载补丁，安装补丁，重启APP生效。支持多个补丁包修复：如果已经下载了多个补丁包，重启app对补丁包进行排序，并依次修复。本文比较贴近实际应用。

效果图

如果感觉不能一步步自己实现，可以看看本文将的热修复原理，然后直接下载完整代码，多敲几遍，就行了。

什么是Android热修复技术？

PS：本文通过 “类加载机制” 实现代码热修复，资源和so库类修复不在本文介绍范围内，是在想使用的话，请参考下文介绍的当下流行的热修复技术框架。

对于这个弱智的问题，相信不需要过多的解释，就是：在不重新安装apk的情况下，通过补丁，修复bug。盗用阿里的2张图（Thanks阿里）

目前主流的热修复技术框架

阿里系的： Andfix、Hotfix、Sophix
腾讯系的：QQ空间超级补丁技术、Qfix、Tinker
美团系的：Robust
饿了么的：Amigo

代码热修复实现原理和优缺点

Ps：上述4大系列框架都很全面，包括了代码修复、资源修复、so库修复等。本文我们只谈如何自己动手实现代码热修复（我觉得日常开发足够了）

代码热修复2种方案

通过类加载机制实现

优点：适用性强、修复范围广、限制少

缺点：属于热修复中的冷修复、需要重启App
通过底层替换方法实现

优点：时效好、不需重启，即使生效

缺点：受限制较多(需要修改虚拟机字段，如果手机厂商修改了虚拟机…….)

通过类加载机制实现代码热修复(来点干货)

类加载机制有什么是我们可利用的呢？

认识BaseDexClassLoader、PathClassLoader和DexClassLoader

PathClassLoader：系统运作，app运行时用于加载app所有需要的类。属于系统层面，正常情况下我们不可操作(二班情况下，就可以了，哈哈，我们接下类要做的就是通过反射机制修改它，达到热修复的目的)。
DexClassLoader：程序员运作，可以通过它加载我们想加载的资源，一般包括这么几种：jar、dex、apk等。
BaseDexClassLoader：热修复中的大Boss，PathClassLoader和DexClassLoader均继承自BaseDexClassLoader，PathClassLoader和DexClassLoader的重要方法均在其父类BaseDexClassLoader中。(我们反编译就需要从BaseDexClassLoader入手)。

用到xx类的时候，虚拟机是怎么找到它的？

简单描述下：用到xx类的时候，虚拟机会利用PathClassLoader去遍历加载过的所有dex文件，从中查找到xx类，一旦找到就return。

BaseDexClassLoader查找类的源码：

@Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
        Class c = pathList.findClass(name, suppressedExceptions);
        if (c == null) {
            ClassNotFoundException cnfe = new ClassNotFoundException("Didn't find class \"" + name + "\" on path: " + pathList);
            for (Throwable t : suppressedExceptions) {
                cnfe.addSuppressed(t);
            }
            throw cnfe;
        }
        return c;
    }

通过源码可以看到，BaseDexClassLoader通过pathList.findClass查找类的，这里出现一个大Boss “PathList”

PathList：中保存类所有dex文件和信息，看一下它是怎么查找类的
PathList源码：

public Class findClass(String name, List<Throwable> suppressed) {
        for (Element element : dexElements) {
            DexFile dex = element.dexFile;

            if (dex != null) {
                Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
                if (clazz != null) {
                    return clazz;
                }
            }
        }
        if (dexElementsSuppressedExceptions != null) {
            suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
        }
        return null;
    }

前方高能：

看到没有，PathList从dexElements中查找类，如果clazz != null直接return class，这就是我们可以利用的地方，从源码看，dexElements应该是个数组或者集合，设想：我们是不是可以把我们修复bug后的xx类，打包成dex，插入到dexElements的最前面，这样，系统通过PathClassLoader,查找bug类的时候，就会下找到我们的修复bug的xx类，然后直接返回，不去管后面有bug的那个xx类，达到热修复的功能。

Ps：不放心，看看dexElements中到底是什么？
贴一部分能说明问题的代码：

private Element[] dexElements;

static class Element {
        private final File dir;
        private final boolean isDirectory;
        private final File zip;
        private final DexFile dexFile;

        private ClassPathURLStreamHandler urlHandler;
        private boolean initialized;

        public Element(File dir, boolean isDirectory, File zip, DexFile dexFile) {
            this.dir = dir;
            this.isDirectory = isDirectory;
            this.zip = zip;
            this.dexFile = dexFile;
        }

这段你代码是从PahtList.java中复制的，dexElements是Element类型的数组，而Element是PahtList的内部类，其中保存了DexFile和路径等信息。证实我们的热修复方案是可行的。

理一下我们热修复的方案

修复有bug的类，生成dex补丁包；
通过反射机制得到PathClassLoader的成员你变量PathList字段(通过上面分析知道，PathList是PathClassLoader父类BaseDexClasLoader中的)
然后再反射PathList获取它的dexElements字段(是一个存放dex的Element数组)
将我们生成的dex补丁包，插入到dexElements的数组的最前端

代码实现Android热修复(代码开撸)

需求

现有一个app，MainActivity中有2个按钮，“跳转Activity2”和“查看People信息”，从服务器下载补丁，把“查看People信息”按钮改为“悄悄修改了代码”，将Acitivity2原来展示的信息，改为“我又来热修复了…”

实现步骤

编写改变前的app
编写热修复需要重写生成的类
通过2步骤的新类生成dex补丁包”001dex”，并放到本地的tomcat服务器，编写配置文件
编写补丁检测和下载代码
编写修复补丁代码

Ps：为了更清晰，一步步来，大牛请直接跳到第5部，哈哈~~~

编写原app

一共3个类：MainActivity、Acitivity2、People类，部分代码如下

MainActivity.java


public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    // 跳转Activity2按钮点击回调方法
    public void jumpToA2(View v){
        Intent intent = new Intent(this, Activity2.class) ;
        startActivity(intent) ;
    }

   // 展示People信息
   public void showPeopleInfo(View v){
        Toast.makeText(this, new People(20, "小明").toString(), Toast.LENGTH_LONG).show() ;
   }
}

Activity2.java

public class Activity2 extends Activity {

    private TextView view ;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity2);
        view = (TextView) findViewById(R.id.tv_info) ;
        view.setText("Activit2") ;
    }
}

People.java

public class People {
    private int age ;
    private String name ;
    public People(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "People{" +
                "age=" + age +
                ", name=" + name +'}';
    }
}

以上3个类特别简单，可以运行一下试试

修改 MainAtvity、Acitivity2类和People类

1. MainActivity类修改如下：
//将展示People信息按钮文字，改为"悄悄修改了代码"
showPeopleInfoButton.setText("悄悄修改了代码") ;

2. Activity2类修改如下：
将view.setText("Activit2") ;
改为：view.setText("我又来热修复啦...") ;

3. People类修改如下：
将 return "People{" +"age=" + age +", name=" + name +'}';
改为：return "People{" +"age=" + age +", name=" + name +'}'+"史上最牛逼人物!!!";

编译生成class文件，修改也非常简单，我们就将这两个类做成”001dex”补丁

用class文件生成”001dex”补丁

android在sdk/build-tools/文件件下提供了”dx”命令工具，帮助我们将class文件生成dex文件

生成方式如下：

dx –dex –output=<要生成的文件> <’class’文件路径>

例如：
dx –dex –output=001.dex …MainAtvity …Actvity2.class …People.class

将”001.dex”放入tomcat服务器并编写配置文件

将001dex放到tomcat服务器这一步，我们不用写代码，只要能通过局域网访问到这个文件就行，”Tomcat7.0\apache-tomcat-7.0.64\webapps\examples\”新建”hotfix”文件夹，在hotfix文件夹中创建“config”文件夹和“patch”文件夹，将001.dex放入”patch”文件夹
Ps:我的tomcat是7.0，”Tomcat7.0\apache-tomcat-7.0.64\”是我的安装目录(说白了，就是解压目录，我们都知道tomcat只需解压就能用，不用安装，当然也有安装的)，根据自己的实际情况来。
编写配置文件
所谓的配置文件，就是app用来检测是否存在补丁的一个文件，可以是.txt文件、xml文件、json文件等等。这里我们用json格式的文件。
在“Tomcat7.0\apache-tomcat-7.0.64\webapps\examples\hotfix\config”目录创建”config.json”，内容如下：

{"patchCode":"001.dex","patchUrl":"http://192.168.1.106:8080/example/hotfix/patch/001.dex"}

配置文件中有2个字段：一个是补丁代码，一个是补丁下载地址。pathUrl是我的ip地址，只需将ip换成你自己的即可

* 开启tomct服务器，测试是否成功*
* 在浏览器输入config.json的地址”http://192.168.1.106:8080/examples/hotfix/config/config.json”

在浏览器输入配置文件中”patchUrl”的地址”http://192.168.1.106:8080/example/hotfix/patch/001.dex“，会现在001.dex文件，表示成功

至此，补丁服务器配置成功，下面可尽情的撸核心代码啦

编写补丁检测和下载代码

PS：网络操作，本例用的是Okhttp；json数据解析，用的是FastJson。还不熟悉的朋友可自行研究一下，很简单

检测补丁

/**
 * [检测服务器是否存在补丁和本地是否一下载过该补丁]
 * @type {Request}
 */
public void checkPatch(){
        //检测是否存在补丁包
        Request request = new Request.Builder()
                .get()
                .url(CHECK_URL)
                .build() ;
        Call call = mClient.newCall(request) ;
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.d(TAG, "check patch failed....") ;
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                JSONObject jsonObject = JSON.parseObject(response.body().string());
                patchCode = jsonObject.getString("patchCode") ;
                Log.d(TAG, "pathCode:"+patchCode) ;

                //判断是否存在补丁
                if(!"-1".equals(patchCode)){
                    //判断当前补丁是否已经下载过
                    if(isDownLoad()){
                        Log.d(TAG, "this version pathCode is fixed...") ;
                        fixPatch();
                    }else{
                        //获取补丁链接
                        patchUrl = jsonObject.getString("patchUrl") ;
                        //开启补丁下载
                        downLoadPatch(patchUrl) ;
                    }
                }
            }
        });
    }

下载补丁

Ps：这里需要注意，补丁文件要下载到我们的安装目录，只有我们自己可以访问，如果下载到存储卡，很容易被别人替换，影响app的安全。先贴一段初始化下载目录的代码：

//这句代码，的意思是：在我们app的安装目录新建一个叫“patch”的文件夹，
//如果不存在，则创建，路径为： /data/data/app的包名/app_patch，
//在安装目录创建的文件夹，均会被加上"app_"
File fPatchPath = context.getDir("patch", Context.MODE_PRIVATE) ;
//为了保险起见，我们判断一下此路径是否存在，不存在则创建
if(fPatchPath.exists()){
  fPatchPath.mkdirs() ;
}

    /**
     * [下载补丁]
     * @type {Request}
     */
    private void downLoadPatch(String downUrl) {
        Request request = new Request.Builder()
                .get()
                .url(downUrl)
                .build() ;
        Call call = mClient.newCall(request) ;
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.d(TAG, "the patch download failed...") ;
                Log.d(TAG, e.getMessage()) ;
            }
            @Override
            public void onResponse(Call call, Response response) throws IOException {

                //请求成功，获取补丁输入流，下面就是文件的读取和保存了
                //相信都是平时大家写烂的东西了，就不备注了
                byte[] buffer = new byte[2048] ;
                int len = 0  ;
                OutputStream os = new FileOutputStream(patchPath+File.separator+patchCode+".dex") ;
                InputStream is = response.body().byteStream() ;
                Log.d(TAG, "start download patch...") ;
                while((len=is.read(buffer,0,buffer.length))!=-1){
                    os.write(buffer,0, len);
                }
                os.close();
                is.close();
                Log.d(TAG, "download patch completion...") ;
                //保存当前补丁编码
                SharedPreferences sp = context.getSharedPreferences(HOTFIX_SP, Context.MODE_PRIVATE) ;
                sp.edit().putString(HOTFIX_CODE, hotfixConfig.getPatchCode()).commit() ;
            }
        });
    }

安装补丁包的2种方案（其实也没多大的意义，可以不看，直接看代码）

对于安装补丁包，我考虑了2种方案

每次生成补丁包xxx.dex的时候，都将以前的补丁包含进去(就是将以前补丁的class文件一起打包成dex补丁包),这样可以保证，无论用户什么时候检测到补丁，都能保证修复所有bug的补丁。这样做：我们每次安装补丁，只需要安装下载的最新补丁包。
每次生成的补丁包都是独立的，不包含之前的补丁，意味着：每次打补丁，都要通过循环的方式，将/data/data/app包名/app_patch/目录下的补丁重新安装一遍。当然，这样做的好处是：用户每次下载的文件大小可以减少一点。

小结：当然，如果采用第二种方式，我们搭建的简易服务器肯定是不行的，因为，如果有的用户没有下载安装上一个补丁，而直接安装了最新的，意味着上一个补丁修复的bug，他将永远带着(除非更新app)。

当然，也不能说第一种方案是完美的，对于用户来讲，dex补丁包越下载越大；对开发人员来说，每次都要保留上次修复bug的class，还要对比，这次有没有对该class做修改，也是比较麻烦的，很容易出错。

这里，虽然我们的服务器暂不完美，暂且使用第二种方式吧，可以多学到一点东西：比如：补丁打包的排序；遍历/app_patch目录安装每一个补丁等。

Ps：既然多个补丁都会安装了，那么，第一种方案的只安装一个补丁，应该是手到擒来的吧~

编写核心代码：安装dex补丁包

在回顾一下我们热修复的原理，核心就一句话：将我们的dex补丁插入到系统加载的dex数组之前，让系统查找类的收，先找到我们补丁中的类，而不再去加载后面的有bug的类。

具体实现步骤

通过反射机制拿到”PathClassLoader”中的”PathList”对象
通过反射机制拿到”PathList”对象中的”dexElements”数组
通过”DexClassLoader” 加载我们的xxx.dex补丁包
通过反射机制拿到”DexClassLoader”中的”PathList”对象
通过反射机制拿到”PathList”对象中的”dexElements”数组
将”DexClassLoader”的”dexElements”插入”PathClassLoader”的dexElements的前面

Ps：上面也说过，PathClassLoader和DexClassLoader均继承自BaseDexClassLoader,重要的方法都在BaseDexClassLoader中，包括”PathList”，所有我们重要反射BaseDexClassLoader就可以了。

安装补丁，就是通过反射机制实现，如果不熟悉反射机制，下面的代码可能会让你像坐过山车一样晕头转向。像了解反射机制的朋友可以看下我的上一篇文章 java/android中的反射机制。

代码开撸


/**
 * [修复aap_patch目录下的所有补丁]
 * @type {File}
 */
private void fixPatch() {
        //获取patch文件夹下所有的补丁文件
        File[] files = new File(patchPath).listFiles() ;
        if(files.length>0){
            //补丁按下载日期排序(最新补丁放前面)
            patchSort(files);
            for (File file : files) {
                //判断file是否为补丁
                if(file.isFile() && file.getAbsolutePath().endsWith(".dex")){
                    System.out.println("---:"+file.getName());
                    //开始加载补丁并修复
                    loadPatch(file);
                }
            }
            Log.d(TAG, "fiexd success....") ;
        }
    }

上面一段代码是遍历补丁文件加下所有的补丁，并对补丁排序。为什么要排序？因为，如果上次的补丁001.dex修复了”类A”的一个bug，而这次的002.dex补丁又对”类A”做了其他修复，那么，如果不排序，遍历补丁文件夹的时候，如果把001.dex补丁打在了002.dex补丁的前面，那么系统会先找到001.dex中的”类A”，002.dex补丁将永远不会生效。

按日期排序

/**
 * [按最后修改日期排序]，排序方式有很多：冒泡排序、快速排序等等，
 * 这个随便，只要排序后，保证最新的dex补丁在最前面就行
 * @type {[type]}
 */
private void patchSort(File[] files){
        Arrays.sort(files, new Comparator<File>() {
            @Override
            public int compare(File file, File t1) {
                System.out.println(file.getName()+":"+file.lastModified());
                System.out.println(t1.getName()+":"+t1.lastModified());
                long d = t1.lastModified() - file.lastModified() ;
                //从大到小排序
                if(d>0){
                    return -1 ;
                }else if(d<0){
                    return 1 ;
                }else{
                    return 0 ;
                }
            }
            @Override
            public boolean equals(Object obj) {
                return true ;
            }
        });
    }

加载并安装dex补丁

/**
 * 加载并安装补丁
 * @type {[type]}
 */
private void loadPatch(File file){
        Log.d(TAG, file.getAbsolutePath()) ;
        if(file.exists()){
            Log.d(TAG,"文件存在...") ;
        }else{
            Log.d(TAG, "文件不存在...") ;
        }
        //获取系统PathClassLoader
        PathClassLoader pLoader = (PathClassLoader) context.getClassLoader();
        //获取PathClassLoader中的PathList
        Object pPathList = getPathList(pLoader) ;
        if(pPathList == null){
            Log.d(TAG, "get PathClassLoader pathlist failed...") ;
            return ;
        }
        //加载补丁
        DexClassLoader dLoader = new DexClassLoader(file.getAbsolutePath(),optPath, null, pLoader) ;
        //获取DexClassLoader的pathLit，即BaseDexClassLoader中的pathList
        Object dPathList = getPathList(dLoader) ;
        if(dPathList == null){
            Log.d(TAG, "get DexClassLoader pathList failed...") ;
            return ;
        }
        //获取PathList和DexClassLoader的DexElements
        Object pElements = getElements(pPathList) ;
        Object dElements = getElements(dPathList) ;

        //将补丁dElements[]插入系统pElements[]的最前面
        Object newElements = insertElements(pElements, dElements) ;
        if(newElements == null){
            Log.d(TAG, "patch insert failed...") ;
            return ;
        }
        //用插入补丁后的新Elements[]替换系统Elements[]
        try {
            Field fElements = pPathList.getClass().getDeclaredField("dexElements") ;
            fElements.setAccessible(true);
            fElements.set(pPathList, newElements);
        } catch (Exception e) {
            e.printStackTrace();
            Log.d(TAG, "fixed failed....") ;
            return ;
        }
    }

    /**
     * 将补丁插入系统DexElements[]最前端，生成一个新的DexElements[]
     * @param pElements
     * @param dElements
     * @return
     */
    private Object insertElements(Object pElements, Object dElements){
        //判断是否为数组
        if(pElements.getClass().isArray() && dElements.getClass().isArray()){
            //获取数组长度
            int pLen = Array.getLength(pElements) ;
            int dLen = Array.getLength(dElements) ;
            //创建新数组
            Object newElements = Array.newInstance(pElements.getClass().getComponentType(), pLen+dLen) ;
            //循环插入
            for(int i=0; i<pLen+dLen;i++){
                if(i<dLen){
                    Array.set(newElements, i, Array.get(dElements, i));
                }else{
                    Array.set(newElements, i, Array.get(pElements, i-dLen)) ;
                }
            }
            return newElements ;
        }
        return null ;
    }

    /**
     *  获取DexElements
     * @param object
     * @return
     */
    private Object getElements(Object object){
        try {
            Class<?> c = object.getClass() ;
            Field fElements = c.getDeclaredField("dexElements") ;
            fElements.setAccessible(true);
            Object obj = fElements.get(object) ;
            return obj ;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null ;
    }

    /**
     * 通过反射机制获取PathList
     * @param loader
     * @return
     */
    private Object getPathList(BaseDexClassLoader loader){
        try {
            Class<?> c = Class.forName("dalvik.system.BaseDexClassLoader") ;
            //获取成员变量pathList
            Field fPathList = c.getDeclaredField("pathList") ;
            //抑制jvm检测访问权限
            fPathList.setAccessible(true);
            //获取成员变量pathList的值
            Object obj = fPathList.get(loader) ;
            return obj ;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null ;
    }

上面的代码有点长，但是注释也很详细。如果你熟悉了热修复原理和反射机制，我觉得上面的代码对你来说，完全就是力气活。不熟悉就多敲几遍，熟能生巧。

Ps：记住检测和下载dex补丁，可以在程序的任何位置进行，但是安装dex补丁，一定要在代码逻辑未执行之前，即：在Application中的onCreate方法中安装补丁。
到这一步，热修复基本完成。经测试，可正常修复Activity，但是修复其他类，会报错，重复加载xxx类，就是传说中”CLASS_ISPREVERIFIED问题标志”问题。

解决CLASS_ISPREVERIFIED问题

经过测试，如果不修复CLASS_ISPREVERIFIED问，也是可以修复Activity和Service等类的。

CLASS_ISPREVERIFIED是怎么产生的呢？
dilvk虚拟机通过PathClassLoader加载类的时候，如果A类中用到了类B中的方法，而且A类和B类又在同一个Dex包中，那么B将被会被虚拟机打上CLASS_ISPREVERIFIED标志，再查找到我们的B类，则会报错。

解决方案，大致有2种

QQ的提出的，创建一个”AntilazyLoad”类，并打包成hack.dex，让项目中的每个类都引用hack.dex中的”AntilazyLoad”类，就不会被虚拟机打上CLASS_ISPREVERIFIED标志了。有个牛逼的名字叫：代码入侵。
利用google的dex分包方案，将app中的某个X类打包带另一个dex中，app中的每个类都引用X类。

想深入了解的可自行差资料，这里我们采用QQ的方案，使用QQ的方案，晚上有很多介绍，都是使用gradle插件，我也不是很了解，也是看的别人的，其实也没那么难。我就不误人子弟了，这里推荐2篇文章，本文解决CLASS_ISPREVERIFIED问题，就是参考的这篇文章。我仅仅会用，可能教不好，还是劳烦各位朋友移步，或者自己百度解决方案。

两篇很有技术含量的文章。

http://blog.csdn.net/lmj623565791/article/details/49883661

http://blog.csdn.net/u010386612/article/details/51131642

总结

其实本文实现的热修复仅仅只是皮毛，仅仅做到了代码修复。当下有太多成熟的热修复框架了，能实现资源、代码、so库等的热修复。我们自己实现热修复是为在使用这些框架的时候，而不至于一脸茫然，不知其所以然。对于这些框架，我个人比较细化阿里系的“Sophix”，这里有一本阿里的Sophix热修复的书，推荐给大家： 深入探索Android热修复技术原理6.29b-final.pdf
贴一张对比图：

对于热修复技术框架的选型，大家心里应该清楚自己更需要哪个体系，各有有缺，为大家推荐一篇不错的文章：Android热修复技术选型——三大流派解析，希望对大家有帮助。

Demo源码下载

Demo源码下载

一个有梦想的屌丝程序员

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
类加载机制实现Android热修复

本文通过类加载机制实现Android热修复，Demo实现的功能：检测服务器是否存在补丁，存在即下载补丁，安装补丁，重启APP生效。支持多个补丁包修复：如果已经下载了多个补丁包，重启app对补丁包进行排序，并依次修复。本文比较贴近实际应用。效果图如果感觉不能一步步自己实现，可以看看本文将的热修复原理，然后直接下载完整代码，多敲几遍，就行了。什么是Android热修复技术？PS：本文通过 “类加载机制
复制链接

扫一扫