greendao 3.0集成和使用封装

最新推荐文章于 2025-06-18 14:31:57 发布
最新推荐文章于 2025-06-18 14:31:57 发布
阅读量2.8k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： android开发 数据库 文章标签： greendao android-数据 异步处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lmq121210/article/details/75078329
本文介绍了在Android项目中使用greendao 3.0进行数据库集成，重点讨论了异步操作数据库的方法，以应对大规模数据场景。作者分享了集成配置、实体类创建以及异步处理的封装过程，包括自定义回调接口、DaoManager和DaoUtils类的设计。此外，还提到了在实现异步操作过程中遇到的问题和一些使用greendao的注意事项，并提供了源码下载链接。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

现在项目中要用到数据库，最终选择使用了greendao ，至于原因，肯定是性能原因了。本文将着重介绍数据库的异步操作，因为网上很多都是配置集成+简单的使用，并且都还是同步的（重要的是 都是一样的文章！！！）。我想说，如果是百万级的数据就GG了。
一般来说，我们需要数据时，先访问数据库看是否有数据，如果有，就从数据库取，如果没有，就访问网络，成功后，将开启线程将数据插入数据库中，同事更新UI 如下图所示：
这里写图片描述
1：集成配置


apply plugin: 'org.greenrobot.greendao'

greendao {
    schemaVersion 1
    daoPackage 'com.app.test.textgreendao.db' //这个填写你自己创建的路径
    targetGenDir 'src/main/java'
}
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'
    }
}

dependencies {
    compile'org.greenrobot:greendao:3.0.1'
    compile'org.greenrobot:greendao-generator:3.0.0'
}

2：接下来就是创建实体类了：

/**
 * Created by ${liumengqiang} on 2017/7/10.
 */
@Entity
public class User {
    @Id
    private long memberId;
    @Property
    private String name;
    @Property
    private String age;


}

然后点击 Build —— make build 就是那个绿色小锤子按钮，就会自动帮你生成相应的方法；
至于@Id，@Property 这一类的标记 大家可以上网搜一下 这个不再赘述。

3：然后就是自己封装GreenDao了，首先网上很多都是同步数据 在这里 我用的是异步处理的也就是使用的是AsyncSession类，这个是GreenDao内部封装好的 再次我们可以在封装一下，专门用于异步操作数据库的成功和失败；
首先 我定义了返回操作数据库结果的回调接口

package com.app.test.textgreendao.user;

import java.util.List;

/**
 * Created by ${liumengqiang} on 2017/7/12.
 */

public interface UserInterface {

    /**
     * type true 成功。 false 失败
     * @param <T>
     */

    interface OnIsertInterface<T>{//单个插入成功
        void onIsertInterface(boolean type);
    }

    interface OnQuerySingleInterface<T>{//单个查询成功
        void onQuerySingleInterface(T entry);
    }

    interface OnDeleteInterface<T>{//单个删除成功
        void onDeleteInterface(boolean type);
    }

    interface OnUpdateInterface<T>{//单个修改成功
        void onUpdateInterface(boolean type);
    }

    interface OnQueryAllInterface<T>{//批量查询数据回调
        void onQueryAllBatchInterface(List<T> list);
    }

}

然后 我们声明这些接口：

package com.app.test.textgreendao.db;

import com.app.test.textgreendao.user.UserInterface;

/**
 * Created by ${liumengqiang} on 2017/7/12.
 */

public class DaoInterface<T>  {

    protected UserInterface.OnQueryAllInterface<T> onQueryAllInterface;
    protected UserInterface.OnUpdateInterface<T> onUpdateInterface;
    protected UserInterface.OnIsertInterface<T> onIsertInterface;
    protected UserInterface.OnQuerySingleInterface<T> onQuerySingleInterface;
    protected UserInterface.OnDeleteInterface<T> onDeleteInterface;

    public UserInterface.OnQueryAllInterface<T> getOnQueryAllInterface() {
        return onQueryAllInterface;
    }

    public void setOnQueryAllInterface(UserInterface.OnQueryAllInterface<T> onQueryAllInterface) {
        this.onQueryAllInterface = onQueryAllInterface;
    }

    public UserInterface.OnUpdateInterface<T> getOnUpdateInterface() {
        return onUpdateInterface;
    }

    public void setOnUpdateInterface(UserInterface.OnUpdateInterface<T> onUpdateInterface) {
        this.onUpdateInterface = onUpdateInterface;
    }

    public UserInterface.OnIsertInterface<T> getOnIsertInterface() {
        return onIsertInterface;
    }

    public void setOnIsertInterface(UserInterface.OnIsertInterface<T> onIsertInterface) {
        this.onIsertInterface = onIsertInterface;
    }

    public UserInterface.OnQuerySingleInterface<T> getOnQuerySingleInterface() {
        return onQuerySingleInterface;
    }

    public void setOnQuerySingleInterface(UserInterface.OnQuerySingleInterface<T> onQuerySingleInterface) {
        this.onQuerySingleInterface = onQuerySingleInterface;
    }

    public UserInterface.OnDeleteInterface<T> getOnDeleteInterface() {
        return onDeleteInterface;
    }

    public void setOnDeleteInterface(UserInterface.OnDeleteInterface<T> onDeleteInterface) {
        this.onDeleteInterface = onDeleteInterface;
    }
}

首先封装一下数据库 DaoManager ，这个网上很多 ，直接看下代码吧

package com.app.test.textgreendao.db;

import android.content.Context;

/**
 * Created by ${liumengqiang} on 2017/7/10.
 */

public class DaoManager {
    private static DaoManager daoManager;
    private DaoMaster daoMaster;
    private DaoSession daoSession = null;
    private DaoMaster.DevOpenHelper devOpenHelper;

    private DaoManager(){};
    public static DaoManager getInstance(){
        if(daoManager == null){
            daoManager = new DaoManager();
        }
        return daoManager;
    }
    public DaoMaster getDaoManager(Context context, String DB_NAME){
        if(daoMaster == null){
            devOpenHelper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);
            daoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());
        }
        return daoMaster;
    }
    public DaoSession getDaoSession(){
        if(daoSession == null){
            daoSession = daoMaster.newSession();
        }
        return  daoSession;
    }

    /**
     * 关闭DaoSession
     */
    private void closeDaoSession(){
        if(daoSession != null){
            daoSession.clear();
            daoSession = null;
        }
    }
    /**
     * 关闭Helper
     */
    private void closeHelper(){
        if(devOpenHelper != null){
            devOpenHelper.close();
            devOpenHelper = null;
        }
    }
    /**
     * 关闭所有的操作
     */
    public void closeConnection(){
        closeDaoSession();
        closeHelper();
    }
}

然后就是我们核心部分了，就是处理创建一个类DaoUtils继承UserInterface类，
daoSession.startAsyncSession()返回一个AsyncSession对象，通过该对象我们可以通过setListenerMainThread 方法监听操作数据库的结果， 然后在执行增删改查，比如：asyncSession.queryUnique(query)；

package com.app.test.textgreendao.db;

import android.content.Context;
import org.greenrobot.greendao.async.AsyncOperation;
import org.greenrobot.greendao.async.AsyncOperationListener;
import org.greenrobot.greendao.async.AsyncSession;
import org.greenrobot.greendao.query.DeleteQuery;
import org.greenrobot.greendao.query.Query;
import org.greenrobot.greendao.query.WhereCondition;
import java.util.List;

/**
 * Created by ${liumengqiang} on 2017/7/11.
 */

public class DaoUtils<T> extends DaoInterface{
    private DaoManager daoManager;
    public DaoSession daoSession;

    public DaoUtils(Context context, String dao_name){
        daoManager = DaoManager.getInstance();
        daoManager.getDaoManager(context, dao_name);
        daoSession = daoManager.getDaoSession();
    }

    /**
     * 条件查询数据
     * @param cls
     * @return
     */
    public <T>void query(Class cls, WhereCondition whereCondition){
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully() && onQuerySingleInterface  != null){
                    onQuerySingleInterface.onQuerySingleInterface(operation.getResult());
                }else if(onQuerySingleInterface  != null){
                    onQuerySingleInterface.onQuerySingleInterface(null);
                }
            }
        });
        Query query = daoSession.queryBuilder(cls).where(whereCondition).build();
        asyncSession.queryUnique(query);
    }
    public T query(Class cls, String whereString, String[] params){
        return (T) daoSession.getDao(cls).queryRaw(whereString, params);
    }

    /**
     * 批量查询
     * @param object
     * @return
     */
    public void queryAll(Class object, Query<T> query){
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                List<T> result = (List<T>)operation.getResult();
                onQueryAllInterface.onQueryAllBatchInterface(result);
            }
        });
        if(query == null){
            asyncSession.loadAll(object);
        }else{
            asyncSession.queryList(query);
        }
//        return objects;
    }
    /**
     * 删除
     */
    public  void deleteSingle(T entry){
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully() && onDeleteInterface  != null){
                    onDeleteInterface.onDeleteInterface(true);
                }else if(onDeleteInterface  != null){
                    onDeleteInterface.onDeleteInterface(false);
                }
            }
        });
        asyncSession.delete(entry);
    }
    /**
     * 批量删除
     */
    public void deleteBatch(Class cls,final List<T> list){
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully() && onDeleteInterface  != null){
                    onDeleteInterface.onDeleteInterface(true);
                }else if(onDeleteInterface  != null){
                    onDeleteInterface.onDeleteInterface(false);
                }
            }
        });
        asyncSession.deleteInTx(cls, list);
    }
    /**
     * 根据Id单个删除
     */
    public void deleteByIdSingle(Class cls,long longParams){//此处longParams数值类型必须为主键id的类型
        daoSession.getDao(cls).deleteByKey(longParams);
    }
    /**
     * 根据Id批量删除
     */
    public void deleteByIdBatch(Class cls, List<Long> longList){//同上
        daoSession.getDao(cls).deleteByKeyInTx(longList);
    }
    /**
     * 删除所有数据
     */
    public void deleteAll(Class cls){
        final AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully() && onDeleteInterface != null){
                    onDeleteInterface.onDeleteInterface(true);
                }else if(onDeleteInterface != null){
                    onDeleteInterface.onDeleteInterface(false);
                }
            }
        });
        asyncSession.deleteAll(cls);
    }
    /**
     * 插入一条数据
     */
    public void insertSingle(final T  entity){
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully() && onIsertInterface != null){
                    onIsertInterface.onIsertInterface(true);
                }else if(onIsertInterface != null){
                    onIsertInterface.onIsertInterface(false);
                }
            }
        });
        asyncSession.runInTx(new Runnable() {
            @Override
            public void run() {
                daoSession.insert(entity);
            }
        });
    }
    /**
     * 批量插入
     */
    public <T>void insertBatch(final Class cls,final List<T> userList){
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully() && onIsertInterface != null){
                    onIsertInterface.onIsertInterface(true);
                }else if(onIsertInterface != null){
                    onIsertInterface.onIsertInterface(false);
                }
            }
        });
        asyncSession.runInTx(new Runnable() {
            @Override
            public void run() {
                for (T object : userList) {
                    daoSession.insertOrReplace(object);
                }
            }
        });
    }
    /**
     * 更新一个数据
     */
    public <T>void updateSingle(Class cls,T entry){
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully() && onUpdateInterface != null){
                    onUpdateInterface.onUpdateInterface(true);
                }else if(onUpdateInterface != null){
                    onUpdateInterface.onUpdateInterface(false);
                }
            }
        });
        asyncSession.update(entry);
    }
    /**
     * 批量更新数据
     */
    public <T>void  updateBatch(final Class cls, final List<T> tList){
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully() && onUpdateInterface != null){
                    onUpdateInterface.onUpdateInterface(true);
                }else if(onUpdateInterface != null){
                    onUpdateInterface.onUpdateInterface(false);
                }
            }
        });
        asyncSession.updateInTx(cls, tList);
    }

}

上面的核心类，有几个我搞的不太懂 就是那个根据id删除的，如何整成异步的；再有就是删除异步里面的迭代器我不太会用。小伙伴们知道的话 可以交流沟通一下。
由于greendao是通过类的不同来识别的，所以当我们操作不同表时，都创建一个相应的操作数据库Utils 继承自DaoUtils。比如我创建的User类 就可以创建一个相应的操作数据库utils类如下：

package com.app.test.textgreendao.user;

import android.content.Context;

import com.app.test.textgreendao.db.DaoUtils;
import com.app.test.textgreendao.db.UserDao;

import org.greenrobot.greendao.async.AsyncOperation;
import org.greenrobot.greendao.async.AsyncOperationListener;
import org.greenrobot.greendao.async.AsyncSession;
import org.greenrobot.greendao.query.Query;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by ${liumengqiang} on 2017/7/11.
 */

public class UserDaoUtils extends DaoUtils<User>{

    public UserDaoUtils(Context context, String dao_name) {
        super(context, dao_name);
    }

    /**
     * 单个插入
     * @param user
     */
    public void insertUser(User user){
        insertSingle(user);
    }
    /**
     * 批量插入
     */
    public void insertBatchUser(List<User> list){
        insertBatch(User.class,list);
    }
    /**
     * 条件查询
     */
    public void queryWhereUser(long memberId){
        query(User.class, UserDao.Properties.MemberId.eq(memberId));
    }
    /**
     * 查询全部
     */
    public void queryAllUser(){
        queryAll(User.class, null);
//        return users;
    }
    /**
     * 条件删除
     */
    public void deleteSingleUser(long memberId){
        User user = new User();
        user.setMemberId(memberId);
        deleteSingle(user);
    }
    /**
     * 批量删除
     */
    public void deleteBatchUser(List<Integer> integerList){
        List<User> userList = new ArrayList<>();
        for(int i = 0;i < integerList.size(); i++){
            User user = new User();
            user.setMemberId(integerList.get(i));
            userList.add(user);
        }
        deleteBatch(User.class, userList);
    }
    /**
     * 单个更新
     */
    public void updateSingleUser(User user){
        updateSingle(User.class, user);
    }
    /**
     * 批量更新
     */
    public void updateBatchUser(List<User> list){
        updateBatch(User.class,list);
    }
    /**
     * 根据Id 单个删除
     */
    public void deleteByIdSingleUser(long memberId){
        deleteByIdSingle(User.class, memberId);
    }
    /**
     * 根据Id批量删除
     */
    public void deleteByIdBatchUser(List<Long> longList){
        deleteByIdBatch(User.class, longList);
    }
    /**
     * 删除所有
     */
    public void deleteAll(){
        deleteAll(User.class);
    }
    /**
     * 条件批量删除
     */
    public void deleteWhereBatch(String ageString){
        Query<User> build = daoSession.queryBuilder(User.class).where(UserDao.Properties.Age.eq(ageString)).build();
        AsyncSession asyncSession = daoSession.startAsyncSession();
        asyncSession.setListenerMainThread(new AsyncOperationListener() {
            @Override
            public void onAsyncOperationCompleted(AsyncOperation operation) {
                if(operation.isCompletedSucessfully()){
                    deleteBatch(User.class, (List<User> )operation.getResult());
                }
            }
        });
        asyncSession.queryList(build);
    }
}

当我们需要在view层操作数据库的结果时，比如插入结果，我们可以通过：

userDaoUtils = new UserDaoUtils(getApplicationContext(), "123456789");

userDaoUtils.setOnIsertInterface(new UserInterface.OnIsertInterface() {
            @Override
            public void onIsertInterface(boolean type) {
                if(type){
                    /**
                     * 插入一条数据成功 
                     */
                }
            }
});

这样是不是方便多了。
其次有几个坑大家共勉：

1: 删除数据时， greendao是根据Id进行删除的。
2：添加或删除字段时，需要删除重新安装apk
3: 创建的实体类 ，不要创建成内部类。

最后附上源码地址：
http://download.youkuaiyun.com/download/lmq121210/9897747

Andorid进阶之路 - greenDao数据库存储
Android、前端、小程序、后端
06-18 1048
Android常见的本地存储一般有文件存储、sp存储，还有数据库存储，而其中数据库存储应该是用的相对较少的，目前正好遇到这样的项目需求，就此记录一波 ~ 主要采用 GreenDao 缓存数据到本地数据库 ~ 基础了解GreenDao优势GreenDao角色划分开发实战基础配置基础使用注解释义属性释义小课堂常见问题 基础了解 greenDao可以说是当今最流行，最高效而且还在迭代的关系型数据库。而且greenDao3.0还支持RxJava操作，greenDao如此受欢迎离不开以下几点： GreenDao.
我的Android进阶之旅】GitHub 上排名前 100 的 Android 开源库进行简单的介绍
字节卷动
09-16 2257
GitHub Android Libraries Top 100 简介 本文转载于：https://github.com/ouyangpeng/Android_Data/edit/master/Android-Librarys-Top-100.md 本项目主要对目前 GitHub 上排名前 100 的 Android 开源库进行简单的介绍, 至于排名完全是根据 GitHub 搜索 Java 语言
Android数据库框架GreenDao封装使用，易理解、易扩展
04-13
该资源有博客文档分享，下载前可先访问了解 主要是重构GreenDao官网DEMO，方便嵌入与扩展，同样适合初学者
GreenDao封装使用
Android唐浮的专栏
10-22 696
GreenDao封装使用 GreenDAO是一个开源的Android ORM(“对象/关系映射”)，通过ORM（称为“对象/关系映射”），简单来说就是操作对象达到更改数据库的效果，在我们数据库开发过程中节省了开发时间！ 为什么使用GreenDao 历来的工作中用GreenDao很多，在官方的对比截图中也觉得它强于其它框架。 高性能 易于使用的强大API，涵盖关系和连接； 最小的内存消耗; 小库大...
fastAPI中的async_sessionmaker有什么用？一文告诉你如何使用异步处理多个方法
最新发布
jingyucsdn的博客
06-18 549
autocommit=False 和 expire_on_commit=False 确保事务边界清晰，数据一致性更强。pool_pre_ping=True 自动检测失效连接，pool_timeout=30 防止长时间阻塞。results = await asyncio.gather(task1, task2) # 并行触发两个查询。await io_operation() # → 遇到第一个await，挂起task1。await io_operation() # → 挂起task2。
GreenDao的封装及使用
qq_39200790的博客
11-15 720
导入步骤： 第一步： 在项目的.gradle文件里面添加 buildscript { repositories { google() jcenter() mavenCentral() } dependencies { classpath 'com.android.tools.build:gra...
GreenDao的实用封装
Jamy博客
06-23 9753
前面简单介绍了下GreenDao的使用，从前面的介绍看来是不是觉得有点 so easy。对就是这么简单。曾经有位大神说作为一位合格的程序员就要在学习别人的东西时，有点自己的想法。为了表示我是位比较合格的程序员，今天和大家介绍下GreenDao的比较实用的封装。如果您还没来得及学习greenDao的实用详解，请前往GreenDao的使用详解学习。长话短说我们正式开始介绍。首先我们新建两个表，分别是C
GreenDao封装
09-11
GreenDao封装，对数据库进行增删改查，升级等操作。其中有使用示例。相关的博客链接地址说明： http://blog.csdn.net/wu371894545/article/details/77936224
ORM框架之GreenDao3.0使用详解(二)
LeiHolmes的博客
10-16 644
上一篇讲解了GreenDao3.0如何集成环境与添加各类注解，这一篇我们来看看如何使用GreenDao实现数据库增删改查的功能，还是上一篇公司Company与雇员Employee的例子。
xutils3.0 Jar包的获取与介绍
xutils3.0基于AndroidAnnotations框架，但相较于原始的AndroidAnnotations，xutils3.0在使用上更加轻量级，更易于集成和使用。 #### 二、xutils3.0 jar包的作用 1. **网络请求**：xutils3.0提供了强大的网络请求...
我的Android进阶之旅------>直接拿来用！最火的Android开源项目
字节卷动
12-07 3763
http://www.csdn.net/article/2013-05-03/2815127-Android-open-source-projectshttp://www.csdn.net/article/2013-05-08/2815145-Android-open-source-projects-twohttp://www.csdn.net/article/2013-05-21/2815370
GreenDao 封装
09-22
对GreenDao 进行封装，快速实现SQLite数据的CRUD操作，支持精确查找和模糊查找，并且可根据个人需求继续进行扩展。
greenDAO的使用工具类封装
04-06
作者YaphetZhao，源码PearGreenDAO，一个基于GreenDAO的Android使用例子，对GreenDAO进行工具类封装，使之快速使用。 可Clone之后查看使用，方便二次开发。
GreenDao单利封装
huihuafei的博客
10-11 559
public class GreenDaoHelper { private static GreenDaoHelper greenDaoHelper; private DaoMaster.DevOpenHelper devOpenHelper; public GreenDaoHelper(Context context) { devOpenHelper = ne
Android ORM框架介绍之greenDao封装(二)
Widsom的博客
08-24 2038
Android ORM框架介绍之greenDao封装(二)数据库操作增删改查操作重复太高，所以需要进行抽取，通过DataBaseManager统一管理。package www.weshared.greendao;import android.content.Context; import android.database.Cursor; import android.support.annotati
Greendao简单封装
gyx549347187_ggg的博客
07-04 312
public class DaoHelper{ private DaoSession daoSession; private static DaoHelper instance = new DaoHelper(); public static DaoHelper getInstance() { return instance; } ...
Android GreenDao简单初始化封装
sinat_35816092的博客
01-18 670
public class DaoManager { private static DaoManager instance; private static final String DATABASE_NAME = "xxxx.db"; private final DaoSession mDaoSession; public synchronized static ...
GreenDao的封装和使用
qingxuan521721的博客
11-23 1145
GreenDao的封装和使用         首先先集成GreenDao，在本人博客里有GreenDao3.2的集成步骤，可参考  MainActivity package com.example.greendaodemo; import android.os.Bundle; import android.support.v7.app.AppCompatAc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值