android的Handler

最新推荐文章于 2025-03-04 14:11:03 发布
转载 最新推荐文章于 2025-03-04 14:11:03 发布 · 592 阅读 · 0
文章标签：

#android #button #layout #timer #date #callback

本文详细研究了Android应用开发中消息机制与多线程的运用，通过分析JWood的Standup Timer项目，阐述了Handler、Looper、Runnable等关键概念，并实现代理模式实现倒计时功能，展示了如何利用Handler进行消息处理和线程间通信，最终提供了代码实现案例。
前言

　　学习android一段时间了，为了进一步了解android的应用是如何设计开发的，决定详细研究几个开源的android应用。从一些开源应用中吸收点东西，一边进行量的积累，一边探索android的学习研究方向。这里我首先选择了jwood的  Standup Timer  项目。本文将把研究的内容笔记整理，建立一个索引列表。

关键词

　　Android.os.Handler涉及较多的知识点，我把一些关键词列举在下面，将主要介绍Handler：

android.os.Handler

　　Handler在android里负责发送和处理消息。它的主要用途有：
　　1）按计划发送消息或执行某个Runnanble(使用POST方法)；
　　2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程）
　　 默认情况下，Handler接受的是当前线程下的消息循环实例（使用Handler( Looper  looper)、 Handler ( Looper  looper,  Handler.Callback  callback)可以指定线程），同时一个消息队列可以被当前线程中的多个对象进行分发、处理（在UI线程中，系统已经有一个Activity来处理了，你可以再起若干个Handler来处理）。在实例化Handler的时候，Looper可以是任意线程的，只要有Handler的指针，任何线程也都可以sendMessage。Handler对于Message的处理不是并发的。一个Looper 只有处理完一条Message才会读取下一条，所以消息的处理是阻塞形式的（handleMessage()方法里不应该有耗时操作，可以将耗时操作放在其他线程执行，操作完后发送Message（通过sendMessges方法）,然后由handleMessage()更新UI）。

倒计时程序

　　利用Timer 编写一个倒计时程序，程序使用Timer和TimerTask来完成倒计时，同时使用sendMessages方法发送消息，然后在HanleMessage里更新UI。
Activity布局：
Layout 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--><?xml version="1.0" encoding="utf-8"?>
        

        <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        
    android:orientation
        ="vertical"
        
    android:layout_width
        ="fill_parent"
        
    android:layout_height
        ="fill_parent"
        
    
        >
        

        <
        TextView  
    android:layout_width="fill_parent"
         
    android:layout_height="wrap_content"
         
    android:layout_gravity="center"
        
    android:id
        ="@+id/txt"
        
    
        />
        

        <
        Button
    android:id="@+id/btnStartTime"
        
    android:text
        ="开始计时"
        
    android:layout_width
        ="80dip"
        
    android:layout_height
        ="wrap_content"
         

    ></Button>
        
 
        <
        Button
     android:id="@+id/btnStopTime"
        
     android:text
        ="停止计时"
        
     android:layout_width
        ="80dip"
        
    android:layout_height
        ="wrap_content"
        
  
        />
        
  

        <SeekBar android:id="@+id/SeekBar01" android:layout_width="match_parent" android:layout_height="wrap_content"></SeekBar>
        

        </LinearLayout>

 

这里使用TextView 来显示倒计时的时间变化，两个按钮用于控制时间的开始和停止。SeekBar主要是用于查看线程是否被阻塞（阻塞时无法拖动）。
onCreate 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        @Override
    public void
         onCreate(Bundle savedInstanceState) {
        super
        .onCreate(savedInstanceState);
        setContentView(R.layout.main);
        txt =
         (TextView) findViewById(R.id.txt);
        btnStart =
         (Button) findViewById(R.id.btnStartTime);
        btnStop =
         (Button) findViewById(R.id.btnStopTime);
        Log.d("ThreadId", "onCread:"
        
                
        +
         String.valueOf(Thread.currentThread().getId()));
        myHandler = new Handler(this
        );

        btnStart.setOnClickListener(this
        );
        btnStop.setOnClickListener(this
        );

    }

 

在onCreate方法中初始化元素个元素，myHandler = new Handler(this); 调用的是  Handler( Handler.Callback  callback)构造函数，在回调方法callback中对发送来的消息进行处理（这样我们就不必使用内部类的写法来 重写HandleMessage()方法了），因此Activity必须实现  android.os.Handler.Callback  接口。我们还在将onCreate 方法的ThreadId 记录在了Log中用以和消息发送、处理时所作的线程进行比较。
发送消息 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        
    @Override
    
        public void
         onClick(View v) {
        switch
         (v.getId()) {
        case
         R.id.btnStartTime:
            startTimer();
            break
        ;
        case
         R.id.btnStopTime:
            timer.cancel();

            break
        ;
        }

    }

    private synchronized void
         startTimer() {

        timer = new
         Timer();
        //
         TimerTask updateTimerValuesTask = new TimerTask() {
        //
         @Override
        //
         public void run() {
        //
         updateTimerValues();
        //
         }
        //
        
        
        //
         };
        //自定义的CallBack模式。Task继承自TimerTask
        

                Task updateTimerValuesTask = new Task(this
        );

        timer.schedule(updateTimerValuesTask, 1000, 1000
        );
    }

    //执行耗时的倒计时任务。
        

            private void
         updateTimerValues() {
        total--
        ;

        Log.d("ThreadId", "send:"
        
                
        +
         String.valueOf(Thread.currentThread().getId()));
        
        Message msg=new
         Message();
        Bundle date = new Bundle();// 存放数据
        

                date.putInt("time"
        , total);
        msg.setData(date);
        msg.what=0
        ;
        myHandler.sendMessage(msg);

        //
        另一种写法
//
                Message msg=myHandler.obtainMessage();
//        Bundle date = new Bundle();//
         存放数据
//
                date.putInt("time", total);
//
                msg.setData(date);
//
                msg.what=0;
//        msg.sendToTarget();
        

                
    }

    @Override
    public void
         TaskRun() {
        updateTimerValues();

    }

 

实现Button按钮的事件处理以此进入倒计时操作。这里使用的Timer 来执行定时操作（其实我们完全可以另起一个线程）。Task类继承了TimerTask类,里面增加了一个任务处理接口来实现回调模式，应此Activity需要实现该回调的接口 ITaskCallBack（这样做是因为我比较不喜欢内部类的编写方法）。
ICallBack接口和Task类 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->public interface
         ITaskCallBack {

    void
         TaskRun();
}



public class Task extends
         TimerTask {

    private
         ITaskCallBack iTask;
    
    public
         Task(ITaskCallBack iTaskCallBack)
    {
        super
        ();
        iTask=
        iTaskCallBack;
    }
    
    public void
         setCallBack(ITaskCallBack iTaskCallBack)
    {
        iTask=
        iTaskCallBack;
    }
    @Override
    public void
         run() {
        // TODO Auto-generated method stub
        

                iTask.TaskRun();
    }

}

 

这是Java的回调函数的一般写法。
实现CallBack 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        
    
        /**
        
     * 实现消息处理
     
        */
        
    @Override
    
        public boolean
         handleMessage(Message msg) {
    
        switch
        (msg.what)
        {
        case 0
        :
            Bundle date=
        msg.getData();
            txt.setText(String.valueOf(date.getInt("time"
        )));
            
            Log.d("ThreadId", "HandlerMessage:"
        
                    
        +
         String.valueOf(Thread.currentThread().getId()));
            Log.d("ThreadId", "msgDate:"
        
                    
        + String.valueOf(date.getInt("time"
        )));
            break
        ;

        }
        return false
        ;
    }

 

运行结果

　　可以看到在onCreate 方法中线程的ID是1（UI线程） 这与 HandlerMessage 进行消息处理时是所作的线程ID是一样的，而消息发送的线程ID则为8非UI线程。

使用Threadle进行实现

Activity类 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        

        public class ThreadHandlerrActivity extends Activity implements
         Callback,
        OnClickListener {

    private
         TextView txt;
    private
         Button btnStart, btnStop;
    private
         Handler myHandler;
    private
         TimerThread timerThread;
    private int Total=30
        ;


    /** Called when the activity is first created. */
        
    @Override
    
        public void
         onCreate(Bundle savedInstanceState) {
        super
        .onCreate(savedInstanceState);
        setContentView(R.layout.main);
        txt =
         (TextView) findViewById(R.id.txt);
        btnStart =
         (Button) findViewById(R.id.btnStartTime);
        btnStop =
         (Button) findViewById(R.id.btnStopTime);
        Log.d("ThreadId", "onCread:"
        
                
        +
         String.valueOf(Thread.currentThread().getId()));
        myHandler = new Handler(this
        );
        
    
        btnStart.setOnClickListener(this
        );
        btnStop.setOnClickListener(this
        );

    }

    /**
        
     * 实现消息处理
     
        */
        
    @Override
    
        public boolean
         handleMessage(Message msg) {
    
        switch
        (msg.what)
        {
        case 0
        :
            Bundle date=
        msg.getData();
            txt.setText(String.valueOf(date.getInt("time"
        )));
            
            Log.d("ThreadId", "HandlerMessage:"
        
                    
        +
         String.valueOf(Thread.currentThread().getId()));
            Log.d("ThreadId", "msgDate:"
        
                    
        + String.valueOf(date.getInt("time"
        )));
            break
        ;

        }
        return false
        ;
    }

    @Override
    public void
         onClick(View v) {
        switch
         (v.getId()) {
        case
         R.id.btnStartTime:
            //自定义的线程
        

                timerThread=new TimerThread(myHandler,60
        );
            timerThread.start();
            
            break
        ;
        case
         R.id.btnStopTime:
            timerThread.stop();
            //timerThread.destroy();
        

                    break
        ;
        }

    }

    
        
    
}

 

自定义的线程类 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->**
        
 
        *
         自定义的线程类，通过传入的Handler,和Total 定期执行耗时操作
 *
         @author linzijun
 *
        
 
        */
        

        public class TimerThread extends
         Thread  {

    public int Total=60
        ;
    public
         Handler handler;
    /**
        
     * 初始化构造函数
     * 
        @param
         mhandler handler 用于发送消息
     * @param
         total 总周期
     */
        
    
        public TimerThread(Handler mhandler,int
         total)
    {
        super
        ();
        handler=
        mhandler;
        Total=
        total;
    }
    @Override
    public void
         run() {
        
        while(true
        )
        {
            Total--
        ;
            if(Total<0
        )
                break
        ;
            try
         {
                Thread.sleep(1000
        );
            } catch
         (InterruptedException e) {
                // TODO Auto-generated catch block
        

                        e.printStackTrace();
            }
            Message msg=new
         Message();
            Bundle date = new Bundle();// 存放数据
        

                    date.putInt("time"
        , Total);
            msg.setData(date);
            msg.what=0
        ;
            Log.d("ThreadId", "Thread:"
        
                    
        +
         String.valueOf(Thread.currentThread().getId()));
            handler.sendMessage(msg);
            
            
        }
        
        super
        .run();
    }

    
    
}

 

这里继承了Thread类，也可以直接实现 Runnable接口。

关于POST

　　Post的各种方法是把一个Runnable发送给消息队列，它将在到达时进行处理。
POST 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
        

        public class PostHandler extends Activity implements
         OnClickListener, Runnable {

    private
         TextView txt;
    private
         Button btnStart, btnStop;
    private
         Handler myHandler;
    private
         Timer timer;
    private int total = 60
        ;

    
    @Override
    protected void
         onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        

                super
        .onCreate(savedInstanceState);

        setContentView(R.layout.main);
        txt =
         (TextView) findViewById(R.id.txt);
        btnStart =
         (Button) findViewById(R.id.btnStartTime);
        btnStop =
         (Button) findViewById(R.id.btnStopTime);
        Log.d("ThreadId", "onCread:"
        
                
        +
         String.valueOf(Thread.currentThread().getId()));
        myHandler = new
         Handler()
        {

            @Override
            public void
         handleMessage(Message msg) {
                switch
        (msg.what)
                {
                case 0
        :
                    Bundle date=
        msg.getData();
                    txt.setText(String.valueOf(date.getInt("time"
        )));
                    
                    Log.d("ThreadId", "HandlerMessage:"
        
                            
        +
         String.valueOf(Thread.currentThread().getId()));
                    Log.d("ThreadId", "msgDate:"
        
                            
        + String.valueOf(date.getInt("time"
        )));
                    break
        ;

                }
    
            }
            
        };

        btnStart.setOnClickListener(this
        );
        btnStop.setOnClickListener(this
        );
    }

    @Override
    public void
         onClick(View v) {
        switch
         (v.getId()) {
        case
         R.id.btnStartTime:
            //myHandler.post(this);
        

                    myHandler.postDelayed(this, 1000
        );
            break
        ;
        case
         R.id.btnStopTime:
            
            break
        ;
        }
        
    }

    @Override
    public void
         run() {
        while(true
        )
        {
            total--
        ;
            if(total<0
        )
                break
        ;
            try
         {
                Thread.sleep(1000
        );
            } catch
         (InterruptedException e) {
                // TODO Auto-generated catch block
        

                        e.printStackTrace();
            }
            Message msg=new
         Message();
            Bundle date = new Bundle();// 存放数据
        

                    date.putInt("time"
        , total);
            msg.setData(date);
            msg.what=0
        ;
            Log.d("ThreadId", "POST:"
        
                    
        +
         String.valueOf(Thread.currentThread().getId()));
            myHandler.sendMessage(msg);
            Log.d("ThreadId", "Thread:"
        
                    
        +
         String.valueOf(Thread.currentThread().getId()));

        }
        
    }

}

 

使用POST的方式 是将Runnable 一起发送给处理的线程（这里为UI），如果Runnable的操作比较耗时的话那线程将进入阻塞状态。可以看到先运行 Runnable的Run方法 然后在进入 HandleMessage（） 。我还尝试了另一种写法，将TimerThreadPOST过去，运行结果是一样的。
代码 
       

        <!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->package
         zijunlin.me;

import
         java.util.Timer;

import
         android.app.Activity;
import
         android.os.Bundle;
import
         android.os.Handler;
import
         android.os.Message;
import
         android.util.Log;
import
         android.view.View;
import
         android.view.View.OnClickListener;
import
         android.widget.Button;
import
         android.widget.TextView;

public class PostHandler extends Activity implements
         OnClickListener, Runnable {

    private
         TextView txt;
    private
         Button btnStart, btnStop;
    private
         Handler myHandler;
    private
         Timer timer;
    private int total = 60
        ;
    private
         TimerThread timerThread;
    
    @Override
    protected void
         onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        

                super
        .onCreate(savedInstanceState);

        setContentView(R.layout.main);
        txt =
         (TextView) findViewById(R.id.txt);
        btnStart =
         (Button) findViewById(R.id.btnStartTime);
        btnStop =
         (Button) findViewById(R.id.btnStopTime);
        Log.d("ThreadId", "onCread:"
        
                
        +
         String.valueOf(Thread.currentThread().getId()));
        myHandler = new
         Handler()
        {

            @Override
            public void
         handleMessage(Message msg) {
                switch
        (msg.what)
                {
                case 0
        :
                    Bundle date=
        msg.getData();
                    txt.setText(String.valueOf(date.getInt("time"
        )));
                    
                    Log.d("ThreadId", "HandlerMessage:"
        
                            
        +
         String.valueOf(Thread.currentThread().getId()));
                    Log.d("ThreadId", "msgDate:"
        
                            
        + String.valueOf(date.getInt("time"
        )));
                    break
        ;

                }
    
            }
            
        };

        btnStart.setOnClickListener(this
        );
        btnStop.setOnClickListener(this
        );
    }

    @Override
    public void
         onClick(View v) {
        switch
         (v.getId()) {
        case
         R.id.btnStartTime:
            //
        myHandler.post(this);
            //myHandler.postDelayed(this, 1000);
        

                    timerThread=new TimerThread(myHandler,60
        );
            
            myHandler.post(timerThread);
            break
        ;
        case
         R.id.btnStopTime:
            
            break
        ;
        }
        
    }

    @Override
    public void
         run() {
        while(true
        )
        {
            total--
        ;
            if(total<0
        )
                break
        ;
            try
         {
                Thread.sleep(1000
        );
            } catch
         (InterruptedException e) {
                // TODO Auto-generated catch block
        

                        e.printStackTrace();
            }
            Message msg=new
         Message();
            Bundle date = new Bundle();// 存放数据
        

                    date.putInt("time"
        , total);
            msg.setData(date);
            msg.what=0
        ;
            Log.d("ThreadId", "POST:"
        
                    
        +
         String.valueOf(Thread.currentThread().getId()));
            myHandler.sendMessage(msg);
            Log.d("ThreadId", "Thread:"
        
                    
        +
         String.valueOf(Thread.currentThread().getId()));

        }
        
    }

}

 

可以说POST的各种方法主要是用于 “按计划发送消息或执行某个Runnanble(使用POST方法)”。

参考文献

　　 SDK

Handle本地调试及基础开发
Obuuu的博客
10-18 2744
Handle本地调试及基础开发 文章目录Handle本地调试及基础开发1.前言2.Handle的介绍3.Handle环境搭建&解析3.1环境3.2搭建步骤问题解决3.3Global解析3.4本地解析4.Handle的基础开发--解析Global及本地Handle值4.1建项目4.2改pom4.3主启动4.4handle解析函数5.结语 1.前言 本文主要介绍Handle标识解析服务的搭建及利用JAVA库进行本地handle以及Global’s Handle解析的开发 本文不会过多赘述Handle的
android.os.handler包,【Android】Handler详解
weixin_29122445的博客
05-29 1108
* Handler的定义:* 主要接受子线程发送的数据, 并用此数据配合主线程更新UI。当应用程序启动时，* Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发,比如说,* 你要是点击一个 Button ,Android会分发事件到Button上，来响应你的操作。* 如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候...
android.os.handler
热门推荐
陈谏辉
10-07 1万+
android.os.handler相关知识整理 Handler在android里负责发送和处理消息。它的主要用途有： 　　1）按计划发送消息或执行某个Runnanble(使用POST方法)； 　　2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新
初识android.os.Handler
05-30 813
今天学习了android.os.Handler 这个类，为了加强记忆，做下总结~ 整体理解是话，可以把Handler理解为线程队列的管理者，队列里的线程将会被系统逐个取出运行，我们可以用Handler来操作这个队列里的线程~ //添加线程1 handler.post(thread1); //延时1秒后添加线程1 handler.postDelayed(thread1,
Android Handler
liuning1985622的博客
05-02 977
Android Handler是一种事件驱动模型，用于实现线程切换或执行延时任务。它在整个Android开发体系中占据着很重要的地位，可以用于保证多个任务在执行时的有序性。在Android系统中，主线程有特殊地位，因此像EventBus和Retrofit这类并非Android独有的第三方库，都是通过Handler来实现对Android系统的特殊平台支持。Android Handler的主要作用是将消息(Message)或Runnable对象发送到主线程的消息队列中，以便在主线程中执行。
精选资源
Android Handler机制的工作原理详析
01-20
Android Handler机制是Android系统中用于实现线程间通信的核心组件，尤其在UI线程与后台线程交互时起到至关重要的作用。Handler、Message、Looper、MessageQueue和ThreadLocal是其主要涉及的五个关键类。 首先，...
Android Handler内存泄漏详解及其解决方案
08-27
Android Handler内存泄漏详解及其解决方案 在 Android 开发过程中，我们可能会遇到过令人奔溃的 OOM 异常，这篇文章主要介绍了 Android Handler 内存泄漏详解及其解决方案，具有一定的参考价值，感兴趣的小伙伴们...
精选资源
Android Handler 原理分析及实例代码
01-04
Android Handler 原理分析 Handler一个让无数android开发者头疼的东西，希望我今天这边文章能为您彻底根治这个问题 今天就为大家详细剖析下Handler的原理 Handler使用的原因 1.多线程更新Ui会导致UI界面错乱 2.如果...
Android Handler机制
Junes inh 的技术专栏
01-31 1531
Android Handler 机制是一种用于在 Android 应用中处理多线程和异步操作的机制。
Android Button click 事件监听
Yano_nankai的博客
01-03 1146
Activity 实现 android.view.View.OnClickListener。 public class MainActivity extends Activity implements android.view.View.OnClickListener { private Button button1, button2, button3; @Overrid
handle机制原理
盼盼
03-10 701
java代码 package com.example.handlertest; 　　import android.os.Bundle; 　　import android.os.Handler; 　　import android.os.Looper; 　　import android.os.Message; 　　import android.a
ESP8266—物联网开发
qq_46496768的博客
09-20 2606
123。
Android-Handler详解_使用篇
Hidanchaofan的博客
03-27 1541
我理解的Handler消息机制：以寄快递为例，我是Handler、快递员是Looper、商品仓库是MessageQueue、Messge是我下单消息寄出的物品。放假我Handler把电脑从公司寄回老家，我填写老家的地址就是声明handleMessage方法、我下单就是sendMessage我把电脑送到快递公司仓库MesssageQueue、然后经过快递公司内部流转，我老家的快递员Looper从仓库MessageQueue取出商品，根据地址送到我老家handleMessage方法。
Android由简到深之Handler
diaostar的博客
03-04 902
，如果没有消息处理的时候，next（）方法就会阻塞在这里，而阻塞却没有导致当前线程ANR的原因，是因为native的nativePoolOnce方法时候，调用了linux低层，使当前线程腾出CPU的使用权，处于休眠等待状态，直到休眠时间结束或消息入队被唤醒。首先我们要知道，在我们持有一个handler的时候，我们的post，postDelay，发送的事件，Handler是不会立刻响应的，它们会在一个队列里，Handler会不断取出我们发送的事件，一个个处理，那么我们再来看，这个流程涉及到了哪些类。
Android中Handler介绍
sky_1305995351的博客
08-18 3925
首先点击按钮会触发start函数，在start函数中创建了一个子线程，在子线程中创建消息的内容，即在getStringFromNet()中输入字符串，为了看到效果（子线程只执行run()中的代码，外面的代码都在主线程中执行），睡眠了三秒，之后使用sendMessage()将消息发送到Messagequeue中，随后主线程中使用handleMessage()去Messagequeue中取消息，最后将消息显示出来。如果队列中没有同步屏障，则返回队列中的同步消息，并将该同步消息从队列中移除。
Kotlin中正确的使用Handler
小马快跑的博客
08-08 5845
在`Kotlin`中，并不能直接通过`static`关键字来声明静态类，那么如何声明一个静态内部类呢？其实在`Kotlin`中，直接在一个类中声明另一个类，经过`Kotlin`编译器之后自动就是`static`静态内部类了。
Android基础学习（二十一）—— Handler
123
12-09 1824
android基础之Handler
安卓Handle的深入剖析和使用
Losileeya
04-25 3950
这是一个关于handle的剖析，里面详细的解释了handle的机制，使用就稍微介绍了
Android handler
最新发布
08-15
### Android Handler 使用与常见问题 在 Android 开发中，`Handler` 是用于在不同线程之间通信的重要工具。它主要用于将任务（如 UI 更新）从后台线程传递到主线程执行，从而避免主线程阻塞并确保 UI 的流畅性。 #...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值