Android Jetpack组件之ViewModel篇

最新推荐文章于 2025-10-20 16:55:57 发布
原创 最新推荐文章于 2025-10-20 16:55:57 发布 · 1k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Jetpack #ViewModel #LiveData #Lifecycle #ViewModelStore

PS：原文首发于微信公众号：躬行之(jzman-blog)

前面学习了 LiveData 和 Lifecycle 架构组件的使用：

ViewModel 具有生命周期意识，会自动存储和管理 UI 相关的数据，即使设备配置发生变化后数据还会存在，我们就不需要在 onSaveInstanceState 保存数据，在 onCreate 中恢复数据了，使用 ViewModel 这部分工作就不需要我们做了，很好地将视图与逻辑分离开来。

  1. ViewModel生命周期
  2. ViewModel的源码分析
  3. 什么是ViewModelStore
  4. 什么是ViewModelStoreOwner
  5. 如何简化Fragment之间的通信
ViewModel生命周期

ViewModel生命周期

从 OnCreate 获取到 ViewModel 之后，它会一直存在，直到该 ViewModel 绑定的 View 彻底 onDestory。

ViewModel的源码分析

本次创建项目是升级 Android Studio 为 3.2.1，所以直接将项目中的依赖包替换成 androidx 下面的对应包，主要配置如下：

//gradle插件
dependencies {
    classpath 'com.android.tools.build:gradle:3.2.1'
}

// ViewModel and LiveData版本
def lifecycle_version = "2.0.0"
implementation "androidx.lifecycle:lifecycle-extensions:$lifecycle_version"

//gradle-wrapper.properties文件
distributionUrl=https\://services.gradle.org/distributions/gradle-4.6-all.zip

创建 ViewModel 如下：

/**
 * 
 * 如果需要使用Context可以选择继承AndroidViewModel
 * Powered by jzman.
 * Created on 2018/12/13 0013.
 */
public class MViewModel extends ViewModel {

    private MutableLiveData<List<Article>> data;

    public LiveData<List<Article>> getData(){
        if (data == null){
            data = new MutableLiveData<>();
            data.postValue(DataUtil.getData());
        }
        return data;
    }
}

如果需要使用 Context 可以选择继承 AndroidViewModel，这里继承 ViewModel 就可以了，然后，在 Activity 中使用就可以了，具体如下：

MViewModel mViewModel = ViewModelProviders.of(this).get(MViewModel.class);
mViewModel.getData().observe(this, new Observer<List<Article>>() {
    @Override
    public void onChanged(List<Article> articles) {
        for (Article article : articles) {
            Log.i(TAG,article.getDesc());
        }
    }
});

来看一看调用过程，从 ViewModelProviders 开始，ViewModelProviders 主要提供四个静态方法获取对应的 ViewModelProvider，四个静态方法如下：

public static ViewModelProvider of(@NonNull Fragment fragment)
public static ViewModelProvider of(@NonNull FragmentActivity activity)
public static ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory)
public static ViewModelProvider of(@NonNull FragmentActivity activity, @Nullable Factory factory)

以第二个方法为例，其实现如下：

@NonNull
@MainThread
public static ViewModelProvider of(@NonNull FragmentActivity activity,
        @Nullable Factory factory) {
    Application application = checkApplication(activity);
    if (factory == null) {
        factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
    }
    return new ViewModelProvider(activity.getViewModelStore(), factory);
}

可以使用用默认的 AndroidViewModelFactory，也可以自定义 Factory，直接调用上面任意一个方法创建 ViewModelProvider 即可：

那就来看一下 ViewModelProvider，ViewModelProvider 中两个关键属性：

private final Factory mFactory;
private final ViewModelStore mViewModelStore;

当创建完 ViewModelProvider 的时候，mFactory 和 mViewModelStore 已经被初始化了，然后是 get() 方法，源码如下：

@NonNull
@MainThread
public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
    //获取类名称，在获取内部类名称时与getName有所区分
    //getCanonicalName-->xx.TestClass.InnerClass
    //getName-->xx.TestClass$InnerClass
    String canonicalName = modelClass.getCanonicalName();
    if (canonicalName == null) {
        throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
    }
    return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
}

然后调用带参数 key 的 get 方法如下：

 public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        ViewModel viewModel = mViewModelStore.get(key);

        if (modelClass.isInstance(viewModel)) {
            //noinspection unchecked
            return (T) viewModel;
        } else {
            //noinspection StatementWithEmptyBody
            if (viewModel != null) {
                // TODO: log a warning.
            }
        }

        //创建ViewModel
        viewModel = mFactory.create(modelClass);
        //从mViewModelStore中根据key获取对应的ViewModel返回
        mViewModelStore.put(key, viewModel);
        //noinspection unchecked
        return (T) viewModel;
    }

此时，ViewModel 就创建好了，那 VIewModel 是如何被创建的呢，mFactory 的具体实现这里是默认的 AndroidViewModelFactory，其创建时通过反射获取构造方法创建的，关键代码如下：

@NonNull
@Override
public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
    //判断AndroidViewModel是不是modelClass的父类或接口
    if (AndroidViewModel.class.isAssignableFrom(modelClass)) {
        //...
        //反射创建ViewModel并返回
        return modelClass.getConstructor(Application.class).newInstance(mApplication);
    }
    return super.create(modelClass);
}

具体的 ViewModel 对象创建完成之后，就可以随意调用具体的 ViewModel 中的方法了，前面跟源码的时候会遇到各种封装类，如 ViewModelStore、ViewModelStoreOwner、AndroidViewModelFactory 等，下文中将会介绍。

什么是ViewModelStore

ViewModelStore 主要是用来保存当设备配置发生变化的时候保存 ViewModel 的状态，如当前界面被重新创建或者销毁等，对应的新的 ViewModelStore 应该和旧的 ViewModelStore 一样保存对应 ViewModel 的所有信息，只有调用了对应的 clear() 方法才会通知这个 ViewModel 不在使用，其对应的 ViewModelStore 也不会存储相关信息了。

该类实际上使用 HashMap 存储相应的 ViewModel，非常简单：

public class ViewModelStore {
    private final HashMap<String, ViewModel> mMap = new HashMap<>();
    final void put(String key, ViewModel viewModel) {
        ViewModel oldViewModel = mMap.put(key, viewModel);
        if (oldViewModel != null) {
            oldViewModel.onCleared();
        }
    }

    final ViewModel get(String key) {
        return mMap.get(key);
    }

    public final void clear() {
        for (ViewModel vm : mMap.values()) {
            vm.onCleared();
        }
        mMap.clear();
    }
}
什么是ViewModelStoreOwner

这是一个接口，定义了一个方法 getViewModelStore() 用来获取对应 ViewModel 的 ViewModelStore , 同样调用了 ViewModelStoreOwner 的 clear() 方法，则获取不到对应的 ViewModelStore 了，源码如下：

public interface ViewModelStoreOwner {
    /**
     * Returns owned {@link ViewModelStore}
     *
     * @return a {@code ViewModelStore}
     */
    @NonNull
    ViewModelStore getViewModelStore();
}

当然，具体的肯定是实现类了，实际上像 FragmentActivity 、Fragment 等都间接或直接实现了这个接口，这一点和 LifecycleOwner 一样，源码参考如下：

  • Activity 间接实现:
public ViewModelStore getViewModelStore() {
    if (getApplication() == null) {
        throw new IllegalStateException("Your activity is not yet attached to the "
                + "Application instance. You can't request ViewModel before onCreate call.");
    }
    if (mViewModelStore == null) {
        NonConfigurationInstances nc =
                (NonConfigurationInstances) getLastNonConfigurationInstance();
        if (nc != null) {
            // Restore the ViewModelStore from NonConfigurationInstances
            mViewModelStore = nc.viewModelStore;
        }
        if (mViewModelStore == null) {
            mViewModelStore = new ViewModelStore();
        }
    }
    return mViewModelStore;
}
  • Fragment 直接实现：
@Override
public ViewModelStore getViewModelStore() {
    if (mFragmentManager == null) {
        throw new IllegalStateException("Can't access ViewModels from detached fragment");
    }
    return mFragmentManager.getViewModelStore(this);
}

其保存 ViewModelStore 过程是在 Activty 或 Fragment 的上层实现中完成，对于认识 ViewModelStoreOwner 这个接口到这里就 OK 了。

如何简化Fragment之间的通信

Fragment 之间的通信以前是使用接口通过宿主 Activity 转发来实现的，现在可以使用同一 ViewModel 完成两个 Fragment 之间的通信，记住一点，使用 ViewModel 进行两个 Fragment 之间通信的时候，创建 ViewModel 使用其宿主 Activity 来创建，实现过程如下，首先创建一个 ViewModel 如下：

/**
 * Powered by jzman.
 * Created on 2018/12/14 0014.
 */
public class FViewModel extends ViewModel {
    private MutableLiveData<String> mSelect = new MutableLiveData<>();
    public void selectItem(String item) {
        mSelect.postValue(item);
    }
    public LiveData<String> getSelect() {
        return mSelect;
    }
}

然后，创建 LeftFragment 如下：

public class LeftFragment extends Fragment {
    private FViewModel mViewModel;
    private FragmentTitleBinding titleBinding;
    public LeftFragment() {
    }
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_title, container, false);
        titleBinding = DataBindingUtil.bind(view);
        mViewModel = ViewModelProviders.of(getActivity()).get(FViewModel.class);
        RvAdapter adapter = new RvAdapter(getActivity(), new RvAdapter.OnRecycleItemClickListener() {
            @Override
            public void onRecycleItemClick(String info) {
                mViewModel.selectItem(info);
            }
        });
        titleBinding.rvData.setLayoutManager(new LinearLayoutManager(getActivity()));
        titleBinding.rvData.setAdapter(adapter);
        return view;
    }
}

LeftFragment 布局文件就一个 RecycleView，其 Item 的布局文件如下：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="itemData"
            type="String"/>
        <variable
            name="onItemClick"
            type="com.manu.archsamples.fragment.RvAdapter.OnRecycleItemClickListener"/>
    </data>
    <LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:onClick="@{() -> onItemClick.onRecycleItemClick(itemData)}">

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@{itemData}"
            android:padding="10dp"/>
    </LinearLayout>
</layout>

RecyclerView 的 Adapter 如下：

public class RvAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
    private Context mContext;
    private List<String> mData;
    private OnRecycleItemClickListener mOnRecycleItemClickListener;
    public RvAdapter(Context mContext,OnRecycleItemClickListener itemClickListener) {
        this.mContext = mContext;
        mData = DataUtil.getDataList();
        mOnRecycleItemClickListener = itemClickListener;
    }

    @NonNull
    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(mContext).inflate(R.layout.recycle_item,null);
        view.setLayoutParams(new ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.MATCH_PARENT,
                ViewGroup.LayoutParams.WRAP_CONTENT
        ));
        return new MViewHolder(view);
    }

    @Override
    public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
        MViewHolder mHolder = (MViewHolder) holder;
        mHolder.bind(mData.get(position),mOnRecycleItemClickListener);
    }

    @Override
    public int getItemCount() {
        return mData.size();
    }

    private static class MViewHolder extends RecyclerView.ViewHolder{
        RecycleItemBinding itemBinding;
        MViewHolder(@NonNull View itemView) {
            super(itemView);
            itemBinding = DataBindingUtil.bind(itemView);
        }

        void bind(String info, OnRecycleItemClickListener itemClickListener){
            itemBinding.setItemData(info);
            itemBinding.setOnItemClick(itemClickListener);
        }
    }

    public interface OnRecycleItemClickListener {
        void onRecycleItemClick(String info);
    }
}

然后，创建 RightFragment 如下：

public class RightFragment extends Fragment {
    private static final String TAG = RightFragment.class.getName();
    private FragmentContentBinding contentBinding;
    private FViewModel mViewModel;
    public RightFragment() {
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_content, container, false);
        contentBinding = DataBindingUtil.bind(view);
        mViewModel = ViewModelProviders.of(getActivity()).get(FViewModel.class);
        mViewModel.getSelect().observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                //接收LeftFragment Item 点击事件的值
                contentBinding.setData(s);
            }
        });
        return view;
    }
}

RightFragment 的布局文件如下：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="data"
            type="String"/>
    </data>

    <FrameLayout
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        tools:context=".fragment.LeftFragment">
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:textSize="18sp"
            android:layout_marginStart="12dp"
            android:layout_marginTop="10dp"
            android:text="@{data,default=def}"/>
    </FrameLayout>
</layout>

实现方式比较简单，没什么多说的，使用 ViewModel 之后，宿主 Activity 就非常清爽，只负责 Fragment 的切换就可以了，测试效果如下：

jzman-blog

使用 ViewModel 的优势如下：

  1. Activity 不在介入子 Fragment 之间的通信了，职责更单一。
  2. Fragment 之间除了使用同一个 ViewModel 的实例，其他互不相同，任何一个 Fragment 都可单独工作。
  3. 每个 Fragment 都有自己的生命周期，可以随意替换和移除都不会互相影响另一个 Fragment 的正常工作。

在这里插入图片描述

由浅入深，详解ViewModel那些事
https://juejin.cn/user/1654096907477549/posts
06-19 3741
今年的龙舟雨来了，一场接一场，雨量很大。前言 以往如果需要在 `Activity` 或者 `Fragment` 中保存数据状态则需要重写**onSaveInstanceState ，使用bundle去存储相应的数据和状态**，但是这也只能保存轻量简单的序列化数据。而 `ViewModel` 可以做到在配置变更后依然持有状态。
Android架构组件之ViewModel和LiveData
dfqin的专栏
04-03 4042
关于应用架构，Google官方现在主推MVVM架构，官方推出的JetPack库提供了一系类支持MVVM架构，其中最核心的两个类是ViewModel和LiveData。 在MVVM架构中，View通常指Activity和Fragment，主要用来根据数据渲染UI，而Model主要负责数据的获取，这里通常包含获取网络数据和本地缓存数据，而ViewModel作为View和Model的桥梁，主要负责UI数据的处理，官方提供了ViewModel类作为一种实现。LiveData作为一种可观察的数据存储类，可以很好在支
Android Jetpack系列之 ViewModel
黄林晴
05-22 7214
前言 前面两篇文章我们已经学习了Lifecycle和DataBind,本片文章我们来学习Jetpack系列中比较重要的ViewModel，Jetpack的很多很多组件都是搭配使用的，所以单独的知识点可能会有些”无意义“但却是我们项目实战的基础！ ...
Android Jetpack 系列（八）ViewModel 视图模型
最新发布
子云心的博客
10-20 1077
但在 Kotlin 中，Jetpack 已经为常见场景（如 Activity、Fragment、Compose）提供了更简洁的扩展函数：by viewModels() （Compose 版是 viewModel()）。在应用开发中，随着业务逻辑的复杂化，我们往往需要管理越来越多的数据状态，例如网络请求结果、界面输入内容、滚动位置、用户交互状态等。MVVM 架构中引入了 ViewModel，它从视图层中抽离出“可感知生命周期的状态持有者”，通过数据驱动（通常搭配 LiveData）来自动更新 UI。
Android ViewModel深入解析
weixin_44780781的博客
03-03 4375
ViewModel 类是一种业务逻辑或屏幕级状态容器。它用于将状态公开给界面，以及封装相关的业务逻辑。它的主要优点是，它可以缓存状态，并可在配置更改后持久保留相应状态。这意味着在 activity 之间导航时或进行配置更改后（例如旋转屏幕时），界面将无需重新提取数据。注意：AndroidX以后才能使用ViewModel。
Android : ViewModel+LiveData observe观察数据 改变内容简单应用
javaGHui的博客
12-04 746
Android : ViewModel+LiveData observe观察数据 改变内容 简单应用
ViewModel
小迈的博客
12-25 4270
ViewModel 负责根据生命周期来存储和管理 UI 相关（Activity 或 Fragment）的数据。当配置发生变化时，如：屏幕方向旋转，它可以保证数据不被销毁。
精选资源
Android Jetpack架构组件 ViewModel详解
01-03
前面两篇文章我们已经学习了Lifecycle和DataBind,本篇文章我们来学习Jetpack系列中比较重要的ViewModel，Jetpack的很多很多组件都是搭配使用的，所以单独的知识点可能会有些”无意义“但却是我们项目实战的基础！...
Android Jetpack 架构组件之 ViewModel
haoyuegongzi的博客
12-30 457
一、ViewModel 介绍 传统开发模式下，Activity、fragment 等任务繁琐，同时负责逻辑和UI，往往在一个比较大型的项目，一个 Activity 几千行代码算少的，让人看了就没下手的欲望，这也为啥衍生了 MVP、MVVM 的原因；而使用 ViewModel 的一个很重要的作用，就是可以为 Activity 分担一部分工作：专门存放界面相关的数据。也就是说，只要是界面上能看到的东西，它的变量都应该放在 ViewModel 中，而不是 Activity，这样就可以一定程序上减少 Activit
Android Jetpack组件：Room与ViewModel
2501_92487266的博客
06-17 985
Room是一个SQLite对象映射库，它提供了简洁的API来操作数据库，使得开发者能够以更少的代码实现数据持久化。Room将SQLite数据库的操作抽象化，使得开发者可以专注于业务逻辑，而不是数据库操作细节。ViewModel是Jetpack组件之一，用于存储和管理与UI相关的数据。ViewModel的设计目的是让UI控制器（如Activity或Fragment）能够保持一个干净的界面状态，同时确保数据的持久性和一致性。本文详细阐述了Android Jetpack组件中的Room与ViewModel。
Android-Jetpack组件ViewModel基本使用和原理分析【建议收藏】
2401_84408404的博客
04-30 920
以上就是 ViewModel 的简单使用，是配合 LiveData 的，具体 LiveData 的使用以及与原理分析，请看这篇文章Android Jetpack组件LiveData基本使用和原理分析通过上文可以 ViewModel 的定义以及特点，可以知道ViewModel在对应的作用域内，保正只生产出对应的唯一实例，保证UI组件间的通信我们来验证一下这个特点，我再写个例子，证明一下这个特点考虑到文章的篇幅问题，我把这些问题和答案以及我多年面试所遇到的问题和一些面试资料做成了PDF文档。
Android Jetpack之ViewModel、LiveData
csdn_aiyang的博客
09-13 1168
Jetpack是一个由多个技术库组成的套件，可帮助开发者遵循最佳做法，减少样板代码并编写可在各种Android版本和设备中一致运行的代码，让开发者精力集中编写重要的代码。页面翻转数据状态保留不再需要手动处理生命周期数据始终保持最新状态不会发生内存泄露异步情况，不会因Activity停止而导致崩溃。
Android Jetpack架构组件（六）ViewModel使用和源码篇
周将的博客
02-27 1652
前言
Android ViewModel实现和原理
wodongx123的博客
06-15 1985
提供者Provider：在我们这里就是数据的提供者，当实体的数据改变的时候，会自动通知所有观察者，观察者收到通知后就可以做对应的数据。观察者Observer：观察者注册提供程序，当提供者每次发送通知的时候，观察者就会做对应的处理。其最终实现出来的效果就是，在代码中，一旦我们注册的实体对象里面的数据改变之后，对应的UI就会自动的进行更新，这样数据更新的代码我们只需要在观察者里面写一套，不需要反复写多套了。提供者和观察者是一对多的关系，也就是一个提供者可以被很多个观察者注册。
Android 中的 ViewModel详解
ZLGSPACE的博客
05-26 2679
ViewModel 是 Android 开发中管理 UI 数据的核心工具，其生命周期感知能力和数据持久化特性显著提升了应用的稳定性和可维护性。通过结合 LiveData、Room、Retrofit 等组件，开发者可构建高效、可扩展的架构。遵循最佳实践（如避免持有 Context、使用 Repository 模式）能进一步优化代码质量，降低维护成本。无论是简单的计数器应用还是复杂的数据驱动界面，ViewModel 都是实现清晰架构的关键组件。
Android Jetpack之ViewModel的使用及源码分析
蜗牛快跑
11-24 1254
ViewModel 类是一种业务逻辑或屏幕级状态容器。它用于将状态公开给界面，以及封装相关的业务逻辑。它的主要优点是，它可以缓存状态，并可在配置更改后持久保留相应状态。这意味着在 activity 之间导航时或进行配置更改后（例如旋转屏幕时），界面将无需重新提取数据。现在，常用的项目架构，在MVP向MVVM转变。相对于MVP中的P（presenter），MVVM中的ViewModel有哪些优势呢。ViewModel的优势我们先通过代码来看下ViewModel的使用。然后，看下ViewModel的原理。
Jetpack系列之ViewModel
李林杰的博客
03-07 562
省略相关背景介绍，直接进入主题。ViewModel 它是一个对Activity/Fragment 组件进行数据管理的。可以理解为一个数据管家，那么日常的业务逻辑数据交互都可以在里面实现， 也可以比喻为我们所知道的Presenter、或者Controller，不过它更强大，因为它是Google实现的，并且是响应式的，换句话说，Activty/Fragment销毁了，他不一定销毁，比我们的Activity是非正常销毁，或者重建了，那么这个ViewModel仍然活着，Activity重建之后可以继续使用。但是如果
android viewModel 源码与原理 观察者探索
zhjin8510的专栏
12-18 495
说明 viewmodel 是android 现在推出来的基于观察者模式的数据处理方式。 是在androidx下的lifecycle 包名下面， LiveData 类 也是 observer类 在androidx.lifecycle的lifecycle-live-core包下 LiveData 是基类，下面有MutableLiveData实现类。其实也是observer类。 LifecycleOwner 接口 有getLifecycle方法,Activity,Fragment都是继承这个接口。 ...
Jetpack系列 ViewModel
csdn546229768的博客
05-31 392
文章目录前言一、ViewModel 是什么？二、使用步骤1.新建View Model实例2.原理分析2.1 那么ViewModel 是怎么实现对数据的管理的呢？2.2 分析ViewModel实例3.ViewModel的使用3.1 AndroidViewModel总结 前言 大家如果想了解ViewModel的理论可以先去官方去了解下这里不做概述，直接干货 一、ViewModel 是什么？ ViewModel是生命周期的方式存储和管理界面相关的数据类。ViewModel 让数据可在发生屏幕旋转等配置更改后继
android jetpack架构组件 viewmodel详解 文档
01-09
Android Jetpack是Google提供的一套用于加速Android应用开发的工具包，其中包括了许多架构组件，其中之一就是ViewModel。 ViewModel是一种设计模式，用于保存和管理与UI相关的数据。在传统的Android开发中，当屏幕...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

躬行之

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

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

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

打赏作者

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

抵扣说明：

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

余额充值