漫谈MVVM(2)LiveData_LiveDataBus核心原理

于 2024-05-10 19:16:41 发布
阅读量607 收藏 18
点赞数 15
分类专栏： 程序员 文章标签： java 数据库 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83641180/article/details/138678259
版权

val userLiveData = MutableLiveData()
userLiveData.postValue()// 入口代码

那么进入源码：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

它实际上调用的是父类的postValue()

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这段注释的意思大概是：

发送一个任务给主线程去设置给定的value。如果你在主线程中执行了如下代码：

liveData.postValue(“a”)

liveData.setValue(“b”)

这个value值 b 将会被首先设置，并且随后主线程将会用a覆盖它。

如果你在主线程执行post任务之前多次调用这个方法，那么只有最后一个value才会被分发。

接着往下看，方法内容：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这里进行了一系列判定，规避了无需执行任务的情况.

ArchTaskExecutor是一个单例类，用来在主线程中执行任务，细节无需关心。

来看看 mPostValueRunnable

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这个runnable，其实就做了两件事，1，传递刚刚更新的mPendingData给newValue，然后还原mPendingData。2，将newValue值继续往下传输。

看setValue做了什么

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

发现了重点，这个函数的注释上说明，如果存在存活状态的观察者，将会把这个value值分发给他们。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

继续观察considerNotify()方法：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

可以看到，一个observer本身就有是否存活的状态值 mActive. 如果判定存活，就继续往下走程序，

这里我得到几个关键信息：

  • 观察者本身就有mActive属性

  • 为了防止观察者的mActive状态在通过了第一层判定之后突然改变（因为观察者的状态不可预知），又增加了第二层判定，如果这次判定发现观察者不再存活，也不通知

  • 观察者存在一个mLastVersion属性，影响是否会被通知到（这个有用，下一节LiveDataBus会讲），并且在正式通知观察者之后，mLastVersion会更新

  • 最终执行的是观察者的onChange方法，也就是我们在示例代码中所写的Observer<User>

user.userLiveData.observe(this, Observer {
Log.d(“hanTag”, “MainActivity:侦测到User发生变化$it”)
textView.text = it.toString()
})

接下来的重点就转移到了ObserverWrapper这个类,它是 LiveData的内部抽象类：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这个类，在我们去注册观察者的时候其实就用到了：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

那它作为一个观察者，他自己的存活状态mActive是由什么决定的呢？

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

是ObserverWrapper自己的 activeStateChanged(). 这个函数的调用有4处，但是经过Debug追踪，最终锁定一处：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

在LifecycleBoundObserver类的onStateChange函数中，这里已经说的很明白了，上面的代码解读一下：

  • mOwner 是 Activity或者Fragment，他们都是LifeCycleOwner接口的实现者
  • 判定观察者是否存活的依据，是 mOwner 是否处于至少START状态，但是排除DESTORYED状态
  • 如果mOwner的状态被判定为大于START 小于 DESTROYED， 那么观察者会被认定为存活,mActive被设置为true

OK.到此为止，作结论：

总结

LiveData之所以可以仅在观察者存活的时候通知到多个观察者，是因为：

  • 借助了LifeCycle，使用它来判定lifeCycleOwner的状态值，大于START小于DESTORY，则判定观察者是mActive是true, 反之 false
  • 当LiveData数据发生变化时，轮询所有观察者，逐个判断观察者状态，发现mActive是true，则通知，反之，则不通知

LiveDataBus

LiveDataBus基于LiveData， 是一种在application全局范围内的事件总线的新方案,当然这个并不是谷歌直接给的，在此之前，可能存在EventBus，RxBus这种写法，但是他们都有内存泄漏的问题。而使用基于LiveData的LiveDataBus，将不会有类似的问题。

必须提到的是，原始的MutableLiveData存在多次通知的问题，解决方式也不止一种，后文再细讲。

核心功能

负责Activty/Fragment之间，多个Activity之间，以及Fragment与Activity之间的数据通信。

基本用法

由于它不是谷歌提供的，是开发者根据需求创造的，所以这里我给出参考源码，实际开发中每个人的写法都可能不同：

package com.zhou.baselib.bus

import android.util.Log
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Observer
import java.util.concurrent.atomic.AtomicBoolean

class LiveDataBus {

/**

  • 只有当前存活的owner才能收到消息, 即，尚未创建成功的owner将不会收到消息 ，
  • 即使它进行了监听
    */
    private val mapOfAliveOwner: HashMap<String, AliveOwnerMutableLiveData<Any?>> = HashMap()

/**

  • 全部owner都能收到消息，就算将要跳转的Activity并没创建成功的情况
    */
    private val mapOfAllOwner: HashMap<String, MutableLiveData<Any?>> = HashMap()

/**

  • d
    */
    private val mapOfSingleEventOwner: HashMap<String, SingleLiveData<Any?>> = HashMap()

// 内部类的单例写法，静态成员天生就是线程安全的
class SingleHolder {
companion object {
val DATA_BUS = LiveDataBus()
}
}

companion object {
// 提供给外界一个get方法来获取单例对象
fun get(): LiveDataBus {
return SingleHolder.DATA_BUS
}
}

/**

  • 获取消息通道, 仅支持当前存活的 lifeCycleOwner
  • @key 消息通道的key
    */
    fun getAliveOwnerChannel(key: String): MutableLiveData<Any?> {
    if (!mapOfAliveOwner.containsKey(key)) {
    mapOfAliveOwner[key] = AliveOwnerMutableLiveData()
    }
    return mapOfAliveOwner[key]!!
    }

/**

  • 获取默认消息通道, 支持所有lifeCycleOwner，包括目前还没创建成功的
    */
    fun getDefaultChannel(key: String): MutableLiveData<Any?> {
    if (!mapOfAllOwner.containsKey(key)) {
    mapOfAllOwner[key] = MutableLiveData()
    }
    return mapOfAllOwner[key]!!
    }

fun getSingleEventChannel(key: String): SingleLiveData<Any?> {
if (!mapOfSingleEventOwner.containsKey(key)) {
mapOfSingleEventOwner[key] = SingleLiveData()
}
return mapOfSingleEventOwner[key]!!
}
}

/**

  • 只有当前存活的lifeCycleOwner才会收到 消息, 重写它的observer的mLastVersion
    */
    class AliveOwnerMutableLiveData : MutableLiveData() {

override fun observe(owner: LifecycleOwner, observer: Observer) {
super.observe(owner, observer)
hook(observer)
}

private fun hook(observer: Observer) {
val classLiveData: Class<LiveData<>> = LiveData::class.java
val fieldObservers = classLiveData.getDeclaredField(“mObservers”)
fieldObservers.isAccessible = true
val mObservers = fieldObservers[this]
val classObservers: Class<> = mObservers.javaClass

val methodGet = classObservers.getDeclaredMethod(“get”, Any::class.java)
methodGet.isAccessible = true
val objectWrapperEntry = methodGet.invoke(mObservers, observer)
val objectWrapper =
(objectWrapperEntry as Map.Entry<*, >).value!!
val classObserverWrapper: Class<>? = objectWrapper.javaClass.superclass

val fieldLastVersion =
classObserverWrapper!!.getDeclaredField(“mLastVersion”)
fieldLastVersion.isAccessible = true
val fieldVersion = classLiveData.getDeclaredField(“mVersion”)
fieldVersion.isAccessible = true
val objectVersion = fieldVersion[this]
fieldLastVersion[objectWrapper] = objectVersion
}

}

/**

  • 如果希望创建一个消息通道，只允许通知一次，那就使用SingleLiveEvent
  • @param the data type
    */
    class SingleLiveData : MutableLiveData() {
    private val mPending = AtomicBoolean(true)

override fun observe(owner: LifecycleOwner, observer: Observer) {
if (hasActiveObservers()) {
Log.d(
“SingleLiveEvent”,
“Multiple observers registered but only one will be notified of changes.”
)
}
// Observe the internal MutableLiveData
super.observe(owner, Observer { t ->
if (mPending.compareAndSet(true, false)) {// 获取bool值，并且在获取之后将它的值设置成false
observer.onChanged(t)
}
})
}

}

以Activity之间的通信为例：

  • 使用情形1，Activity之间的跳转，从MainActivity跳转到Main2Activity，要进行通信

// 第一个Activity
class MainActivity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
btn.setOnClickListener {
startActivity(Intent(this, Main2Activity::class.java))
// 获取通道，发送消息，通道的key是MainActivity
LiveDataBus.get().getDefaultChannel(“MainActivity2”).postValue(“发送给第二个Activity的消息”)
}
}
}

// 第二个Activity
class Main2Activity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main2)

// 监听事件通道
LiveDataBus.get().getDefaultChannel(“Main2Activity”).observe(this, Observer {
Log.d(“MainActivityTag”, “$it”)
})

}
}

运行程序，从MainActivity跳转到Main2Activity时，会看到日志：

Main2Activity收到消息: 发送给第二个Activity的消息

消息发送成功，这里的**postValue()**的参数类型，可以是任意对象，或者基础类型。

  • 使用情形2：以上的情况是从一个Activity，跳转到另一个Activity2，其实在发送消息之时，目标Activity2并没有创建成功，它也能在Activity2创建成功之后收到消息（下一节分析原理 ）。但是也存在另一种情况，如果我们只希望目标Activity/Fragment存在的时候，才收到消息（而不是等他创建成功）。可以这么用。

// 第一个Activity
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

LiveDataBus.get().getAliveOwnerChannel(“MainActivity”).observe(this, Observer {
Log.d(“MainActivityTag”, “MainActivity 收到消息: $it”)
})

btn.setOnClickListener {
startActivity(Intent(this, Main2Activity::class.java))
LiveDataBus.get().getAliveOwnerChannel(“Main2Activity”).postValue(“发送给第二个Activity的消息”)
}
}
}

// 第二个Activity
class Main2Activity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main2)
LiveDataBus.get().getAliveOwnerChannel(“Main2Activity”).observe(this, Observer {
Log.d(“MainActivityTag”, “Main2Activity收到消息: $it”)
})
btn.setOnClickListener {
finish()
LiveDataBus.get().getAliveOwnerChannel(“MainActivity”).postValue(“回馈给Activity1的消息”)
}
}
}

当从MainActivty点按钮跳到Main2Activity时，Main2Activity并收不到消息。

这是因为，消息发送时，Main2Activity对象并不存在(如果Main2Activity已经处于栈内，并且它是栈内唯一的启动模式 SingleInstance，也能收到，亲测 )。

而从Main2Activity点按钮跳回MainActivity时， MainActivity能收到消息。

Fragment的情形也是一样，篇幅有限，这里就不做示例了…

  • 使用情形3

有的时候，当数据变化时，只需要通知一次View层即可。此时单独使用 SingleLiveData（参照LiveData基本用法），也可以使用LiveDataBus的getSingleEventChannel(“xxx”)取得 单次消息通道即可。

//注册监听
LiveDataBus.get().getSingleEventChannel(“NoticeTipsFragment”).observe(this, Observer {
tvMsg.text = it.toString()
})

// 发送消息
var seriCode = 1
tvMsg.setOnClickListener {//点击事件
LiveDataBus.get().getSingleEventChannel(“NoticeTipsFragment”).postValue(“哈哈哈${seriCode++}”)
}

就算点击多次按钮，发送了多次事件，监听器也只会收到一次通知。

核心原理

使用上述LiveDataBus类，只需要做两件事，

其一：获得消息通道 LiveDataBus.get().getXXXChannel(“xxxx”) 然后 observer(this,Observer{…})进行监听注册。

其二：获得消息通道 LiveDataBus.get().getXXXChannel(“xxxx”) ** 然后 postValue(xxx) 发送消息

上面的LiveDataBus类提供了3种消息通道，

  • 一个是不支持粘性消息的getAliveOwnerChannel，内部使用的是hook之后的自定义AliveOwnerMutableLiveData对象来当作消息通道.

  • 一个是支持粘性消息的getDefaultChannel，使用的是纯天然的MutableLiveData。

  • 还有一种是支持单次消息通知的 SingleEventLiveData， 也是重写了observer方法， 使用AtomicBoolean 的特性（compareAndSet(true,false)获取当前值，并且使用之后更改为false）完成单次通知。

LiveDataBus本身的设计，就是基于 订阅，发布者模式，和Rxjava如出一辙，但是由于利用到了LiveData,LifeCycle，它纯天然就带有生命周期感知机制，无需我们操心去做更多防止内存泄漏的工作。但是，LiveDataBus与RxJava有一个共同之处，那就是支持粘性消息，即使 订阅者对象尚未创建，待到创建成功之后，也能收到。

进入源码, 本次探索源码，分析的目标是：

为何使用默认的MutableLiveData时，它支持粘性消息呢？

从发布者入手：

LiveDataBus.get().getDefaultChannel(“Main2Activity”).postValue(“发送给第二个Activity的消息”)

postValue之后，追踪到LiveData类的mPostValueRunnable…

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

继续往下，进入到setValue：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

observer.mActive值是由 Activity/Fragment的状态决定的（前面LiveData的核心原理已经说明），

如果我想阻止消息的通知，想在这里执行return不现实。所以唯一的解决方案就锁定在 下图中的observer.mLastVersion >= mVersion 的判断上。只要我们能够让判断成立，那么这里就会return。onChange就不会执行，消息也就不会具备粘性。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

一向严谨的谷歌工程师居然对这里的 mVersion变量加注释，但是根据代码逻辑可以判定：

只有在消息的版本mVersion 大于 订阅者的版本mLastVersion 时，才执行消息 通知.

这个也好理解，毕竟不能让订阅者收到过时的消息。

LiveData类的mVersion属性，唯一一处和当前情形有关的变动，就是：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

而它的初始值是 START_VERSION -1

observer.mLastVersion 的初始值也是 START_VERSION -1

总结

这次面试问的还是还是有难度的，要求当场写代码并且运行，也是很考察面试者写代码
因为Android知识体系比较庞大和复杂的，涉及到计算机知识领域的方方面面。在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

里面包含不同方向的自学编程路线、面试题集合/面经、及系列技术文章等，资源持续更新中…
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！
领域的方方面面。在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）
[外链图片转存中…(img-eZyCYcH4-1715339790101)]
里面包含不同方向的自学编程路线、面试题集合/面经、及系列技术文章等，资源持续更新中…
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！

2401_83641180
关注
专栏目录
Android mvvm 之 LiveData 的原理，腾讯T3大牛手把手教你
m0_61417954的博客
09-01 378
以上，只为了说明一个问题：LiveData 需要订阅 LifecycleOwner，感知其生命周期变化： 图示说明，LiveData 订阅 LifecycleOwner，而由 LifecycleOwner.Lifecycle 代理完成生命周期状态变化通知，所以 LiveData 直接能感知的是 Lifecycle。 2.2 LifecycleOwner 订阅数据变化 LifecycleOwner 在 STARTED 和 RESUMED 的状态下可以根据 LiveData 更新 UI 的状态，所以 Life
LiveDataBus实现原理#用法详解#LiveData扩展
geyuecang的博客
04-04 3984
LiveDataBus实现原理#LiveData源码分析 一、liveDataBus简单实现 public class LiveDataBus { private final Map<String, MutableLiveData<Object>> mBus; private LiveDataBus() { mBus = new Array...
LiveData原理解析和仿写一个LiveDataBus
sunlifeall的博客
02-27 231
引入LiveData： implementation "androidx.lifecycle:lifecycle-viewmodel:2.2.0" 学习内容： //这个实际上还是继承了LiveData public class MutableLiveData<T> extends LiveData<T> { @Override public void postValue(T value) { super.postValue(value); }
LiveDataBus核心原来如此简单
luo_boke的博客
01-27 1103
本篇博客通过自己对LiveData的理解，封装名为LiveData的通信框架。框架为纯Kotlin代码框架,其实框架实现很简单，原理完全基于LiveData。名字虽与网络上的LiveDataBus一样，功能也基本一致，但其内涵完全不一样，且看我一一剖析。
DevExpress.Mvvm.zip_C# mvvm_c# mvvm_devexpress_mvvm_quietlycju
07-13
devexpress实现MVVM源码，C#代码实现MVVM架构
MVVM.rar_mvvm_orm_outsideg6v
09-23
《MVVM与ORM在三层架构中的融合应用》 在当今的软件开发领域，MVVM（Model-View-ViewModel）架构模式和ORM（Object-Relational Mapping）技术已经成为了提升开发效率和代码可维护性的关键工具。这篇文档将深入探讨...
WPF_Project.zip_WPF_WPF mvvm_mvvm_wpf mvvm 登录%2_wpf 增删改查
07-15
总结来说，这个WPF项目提供了一个基础的MVVM架构示例，结合了登录验证和图书管理系统，是学习和实践WPF以及MVVM模式的理想起点。通过对项目的探索和调试，开发者可以掌握WPF中的关键概念和技术，为构建更复杂的应用...
awtk-mvvm-master_mvvm_awtk_
09-28
首先，理解MVVM的核心理念至关重要。MVVM模式是由微软的WPF框架引入，旨在简化用户界面的开发，主要由三部分组成：模型（Model）负责数据和业务逻辑，视图（View）负责用户界面，而视图模型（ViewModel）作为桥梁，...
DataGridMVVM.zip_WPF MVVM datagrid_datagrid_datagrid mvvm_mvvm_w
07-15
2. 创建视图模型（ViewModel）：这是业务逻辑的核心，包含对模型的访问和操作方法，以及与视图交互的命令。例如，可以定义添加、删除、编辑记录的命令，这些命令在视图中绑定到DataGrid的按钮或上下文菜单。 3. ...
livedatamvvm:MVVM中的LiveData示例
04-28
让我们使用LiveData保持活动哑巴 MVVM中的LiveData示例
基于livedata实现的mvvm_clean
毕业生笔记的博客
09-03 1048
一、mvvm是什么 引用度娘：MVVM是Model-View-ViewModel的简写。它本质上就是MVC 的改进版。MVVM 就是将其中的View 的状态和行为抽象化，让我们将视图 UI 和业务逻辑分开。当然这些事 ViewModel 已经帮我们做了，它可以取出 Model 的数据同时帮忙处理 View 中由于需要展示内容而涉及的业务逻辑 m(Model):数据源，主要包括网络数据源和本地缓...
Android之MVVM架构指南：LiveData
weixin_45365889的博客
09-21 515
Livedata 是一个数据源的包装类，他可以有效的取代请求信息时用到callback接口，还可以配合Lifecycle感知程序组件生命周期。 正常我们请求网络数据时的代码为： public class ListActivity extends AppCompatActivity { private TextView userNameTv; @Override pr...
MVVM系列之二：LiveData
最新发布
2401_84010836的博客
05-08 936
mLiveData.setValue(“onStart”);//活跃状态，会回调onChanged。并且value会覆盖onCreate、onStop中设置的value}@Overrideprotected void onResume() {super.onResume();Log.i(TAG, "onResume: ");mLiveData.setValue(“onResume”);//活跃状态，回调onChanged}@Overrideprotected void onPause() {super.on
“终于懂了“系列：Jetpack AAC完整解析（二）LiveData 完全掌握！
Android 开发架构
01-29 356
上一篇介绍了Jetpack AAC 的基础组件 Lifecycle，它是用于管理Activity/Fragment的生命周期。这篇来介绍基于Lifecycle的用于处理数据的组件——LiveData。 一、LiveData介绍 1.1 作用 LiveData是Jetpack AAC的重要组件，同时也有一个同名抽象类。 LiveData，原意是 活着的数据。 数据还能有生命？ 先来看下官方的定义： LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意
Android MVVM模式之LiveData详解与使用
01-05 1108
livedata是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 activity、fragment 或 service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。
c# mvvm模式获取当前窗口_ViewModel_DataBinding核心原理【漫谈MVVM】
06-01
MVVM（Model-View-ViewModel）是一种软件架构模式，它将用户界面（View）与业务逻辑（ViewModel）分离开来，并通过数据绑定技术实现二者之间的通信。在MVVM中，ViewModel作为中间层，负责处理业务逻辑，并将处理结果通过数据绑定传递给View。 在C#中，实现MVVM模式通常使用WPF框架。WPF提供了数据绑定机制，可以将ViewModel的属性绑定到View的控件上，从而实现数据的双向绑定。当ViewModel中的属性发生变化时，View中绑定该属性的控件也会自动更新。 要获取当前窗口的ViewModel，可以使用如下代码： ``` var viewModel = DataContext as MyViewModel; ``` 其中，MyViewModel是当前窗口的ViewModel类型。DataContext是WPF中的一个属性，用于绑定数据上下文。在MVVM中，将ViewModel实例赋值给DataContext属性，从而实现ViewModel与View的绑定。 通过以上代码，可以获取当前窗口的ViewModel实例，从而可以访问ViewModel中的属性和方法，实现业务逻辑的处理。同时，也可以在ViewModel中获取View中的控件，从而实现对View的操作。 总之，MVVM模式通过数据绑定技术实现了View与ViewModel之间的松耦合，使得软件的维护和扩展更加方便。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值