Mockito

最新推荐文章于 2024-07-24 17:24:29 发布
最新推荐文章于 2024-07-24 17:24:29 发布
阅读量4k 收藏 8
点赞数 1
分类专栏： Java 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cat_2_love_dog/article/details/119490424
版权

文章目录

前言

学习B站汪文君Mockito实战视频的笔记

1 mock的三种方式

1.1 MockByRunner

第一种mock方式，这种方式的mock的对象可以是测试函数的局部变量

package com.lanshang.mockito.lesson3;

import com.lanshang.mockito.quickstart.AccountDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;

//第一种mock方式，这种方式的mock的对象可以是测试函数的局部变量
@RunWith(MockitoJUnitRunner.class)
public class MokeByRunner {

    @Test
    public void test(){
        AccountDao dao = Mockito.mock(AccountDao.class);
    }
}

1.2 MockByAnnotation

第二种mock方式，注释的方式，这种方式mock的对象不可以是测试函数的局部变量，所以这里把需要mock的对象提到测试类的成员变量

package com.lanshang.mockito.lesson3;

import com.lanshang.mockito.quickstart.AccountDao;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

//第二种mock方式，注释的方式，这种方式mock的对象不可以是测试函数的局部变量，所以这里把需要mock的对象提到测试类的成员变量
public class MockByAnnotation {
    @Mock
    AccountDao accountDao;

    @Before
    public void init(){
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void test(){
        accountDao.findAccount("x","x");
    }
}

1.3 MockByRule

注意：这种mock方法在高版本可用，在1.9.0的mockito-all不支持

package com.lanshang.mockito.lesson3;

import com.lanshang.mockito.quickstart.AccountDao;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
//注意：这种mock方法在高版本可用，在1.9.0的mockito-all不支持
public class MockByRule {
    @Mock
    AccountDao accountDao;

    @Rule
    public MockitoRule mockitorule = MockitoJUnit.rule();

    @Test
    public void test(){
        accountDao.findAccount("x","x");
    }
}

2 深度mock

注意:深度Moke并不能确保每次都生效.
使用方法:在需要mock的对象注释上头这么写: @Mock(answer = Answers.RETURNS_DEEP_STUBS)

package com.lanshang.mockito.lesson3;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

public class DeepMode {
    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
    A a;

    @Before
    public void init(){
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void test(){
        a.getB().a();
    }
}

class A{
    public B getB(){
        throw new RuntimeException();
    }
}

class B{
    public void a(){
        throw new RuntimeException();
    }
}

3 Stub

3.1 有返回值的函数的测试方法

注意:list已经mock

    @Test
    public void testStubbing1(){
        //测试有返回值的函数的正常情况
        when(list.get(0)).thenReturn("0");
        //上述写法与下面的写法等同
        //doReturn("0").when(list).get(0);
        assertThat(list.get(0),equalTo("0"));

        //测试有返回值的函数的异常情况
        when(list.get(1)).thenThrow(new RuntimeException());
        try {
            list.get(1);
            fail();
        } catch (Exception e) {
            assertThat(e,instanceOf(RuntimeException.class));
        }

    }

3.2 无返回值的函数的测试方法

注意:list已经mock

//测试没有返回值的函数
    @Test
    public void testStubbing2(){

        //测试无返回值的函数的正常情况
        doNothing().when(list).clear();
        list.clear();
        verify(list,times(1)).clear();

        //测试无返回值的函数的异常情况
        doThrow(new RuntimeException()).when(list).clear();
        try {
            list.clear();
            fail();
        } catch (Exception e) {
            assertThat(e,instanceOf(RuntimeException.class));
        }

    }

3.3 遍历stub

    @Test
    public void testIterateStubbing(){
        //指定list.get(0)第一次调用结果为1，第二次调用结果为2，第三次调用结果为3
        when(list.get(0)).thenReturn(1,2,3);
        //下述写法等价于when(list.get(0)).thenReturn(1,2,3);
        //when(list.get(0)).thenReturn(1).thenReturn(2).thenReturn(3);
        assertThat(list.get(0),equalTo(1));
        assertThat(list.get(0),equalTo(2));
        assertThat(list.get(0),equalTo(3));
        //第三次后调用结果重复第三次调用的值
        assertThat(list.get(0),equalTo(3));
        assertThat(list.get(0),equalTo(3));
    }

3.4 when().thenAnswer()用法

when().thenAnswer()用于简化when里方法的每个参数要有同样的逻辑处理。
比如返回list.get()入参的10倍:
when(list.get(0)).thenReturn(0);
when(list.get(1)).thenReturn(10);
when(list.get(23)).thenReturn(230);
……
就可以写成以下方式：

    @Test
    public void testStubbingWithAnswer(){
        when(list.get(anyInt())).thenAnswer(new Answer<Object>() {
            @Override
            public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
                //invocationOnMock.getArguments()获取list.get()函数所有的入参，
                //因为list.get()函数只有一个入参，所以用invocationOnMock.getArguments()[0]取出该入参的值
                Integer index = (Integer)invocationOnMock.getArguments()[0];
                return index*10;
            }
        });
        assertThat(list.get(0),equalTo(0));
        assertThat(list.get(1),equalTo(10));
        assertThat(list.get(23),equalTo(230));
    }

3.5 when().thenCallRealMethod()用法

如果想mock出的对象真正执行其方法，可以用when().thenCallRealMethod()

class Service{
    public Integer light(){
        System.out.println("light()方法执行！");
        return 999;
    }

    public String weight(){
        System.out.println("weight()方法执行！");
        return "weight……";
    }
}

    @Test
    public void testRealCall(){
        Service service = mock(Service.class);
        //mock出的对象调用其方法不会真的执行该方法，而是返回其返回类型的默认值
        //service.light()的返回类型是Integer，所以输出0
        System.out.println(service.light());
        //service.weight()的返回类型是String，所以输出null
        System.out.println(service.weight());

        //如果想mock出的对象真正执行其方法，可以用when().thenCallRealMethod()
        when(service.light()).thenCallRealMethod();
        assertThat(service.light(),equalTo(999));

        //mock出的对象不真实调用其方法的写法和原来一样
        when(service.weight()).thenReturn("suc");
        assertThat(service.weight(),equalTo("suc"));
    }

4 Spy

spy不做处理时会真正调用函数，stub后会不真正调用函数而是返回指定结果。

4.1 方法一：MockByRunner

    @Test
    public void test(){
        ArrayList<String> realList = new ArrayList<>();
        ArrayList<String> list = spy(realList);
        list.add("A");
        list.add("B");
        assertThat(list.get(0),equalTo("A"));
        assertThat(list.get(1),equalTo("B"));
        assertThat(list.isEmpty(),equalTo(false));
        assertThat(list.size(),equalTo(2));

        //对部分方法进行stub使其不调用真实函数
        when(list.isEmpty()).thenReturn(true);
        when(list.size()).thenReturn(0);
        assertThat(list.isEmpty(),equalTo(true));
        assertThat(list.size(),equalTo(0));
    }

4.2 MockByAnnotation

其实就是把

        ArrayList<String> realList = new ArrayList<>();
        ArrayList<String> list = spy(realList);

合并成一步：

    @Spy
    ArrayList<String> list = new ArrayList<>();

完整代码如下：

public class SpyAnnotation {
    @Spy
    ArrayList<String> list = new ArrayList<>();

    @Before
    public void init(){
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void test(){
        list.add("A");
        list.add("B");
        assertThat(list.get(0),equalTo("A"));
        assertThat(list.get(1),equalTo("B"));
        assertThat(list.isEmpty(),equalTo(false));
        assertThat(list.size(),equalTo(2));

        //对部分方法进行stub使其不调用真实函数
        when(list.isEmpty()).thenReturn(true);
        when(list.size()).thenReturn(0);
        assertThat(list.isEmpty(),equalTo(true));
        assertThat(list.size(),equalTo(0));
    }
}

5 isA()和any()

stub用isA()时，assert会校验类型；stub用any()时，assert不会校验类型。

package com.lanshang.mockito.lesson7;

import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;

import static javafx.beans.binding.Bindings.when;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.isA;

public class Args {
    @Test
    public void test(){
        Foo foo = Mockito.mock(Foo.class);
        Mockito.when(foo.get(isA(Parent.class))).thenReturn(100);
        assertThat(foo.get(new Child1()),equalTo(100));
        assertThat(foo.get(new Child2()),equalTo(100));

        //any(Child1.class)不会真的校验Child1.class类型，只要assert里foo.get()的参数类型是对的就能成功
        Mockito.when(foo.get(any(Child1.class))).thenReturn(300);
        assertThat(foo.get(new Child2()),equalTo(300));
    }
}

class Foo{
    public int get(Parent parent){
        return parent.fun();
    }
}

interface Parent{
    public int fun();
}

class Child1 implements Parent{
    @Override
    public int fun() {
        throw new RuntimeException();
    }
}

class Child2 implements Parent{
    @Override
    public int fun() {
        throw new RuntimeException();
    }
}

6 参数通配

待测试类
注意：SimpleService simpleService已经mock。

class SimpleService{
    public int method1(int i, String s, Collection c, Serializable ser){
        throw new RuntimeException();
    }

    public void method2(int i, String s, Collection c, Serializable ser){
        throw new RuntimeException();
    }
}

6.1 有返回值的函数

有返回值的函数用assert验证执行结果。

    @Test
    public void test1Method1(){
        Mockito.when(simpleService.method1(anyInt(),anyString(),anyCollection(),anyObject()))
                .thenReturn(100);
        Mockito.when(simpleService.method1(anyInt(),eq("a"),anyCollection(),anyObject()))
                .thenReturn(1);
        Mockito.when(simpleService.method1(anyInt(),eq("b"),anyCollection(),anyObject()))
                .thenReturn(2);
        assertThat(simpleService.method1(1,"c", Collections.emptyList(),"aaaa"),equalTo(100));
        assertThat(simpleService.method1(1,"b", Collections.emptyList(),"aaaa"),equalTo(2));
        assertThat(simpleService.method1(1,"a", Collections.emptyList(),"aaaa"),equalTo(1));
    }

注意：按下面这种顺序的mock，第三个mock会覆盖前两个mock

    @Test
    public void testMethod1(){
        Mockito.when(simpleService.method1(anyInt(),eq("a"),anyCollection(),anyObject()))
                .thenReturn(1);
        Mockito.when(simpleService.method1(anyInt(),eq("b"),anyCollection(),anyObject()))
                .thenReturn(2);
        //注意，按这种顺序的mock，第三个mock会覆盖前两个mock
        Mockito.when(simpleService.method1(anyInt(),anyString(),anyCollection(),anyObject()))
                .thenReturn(100);
        assertThat(simpleService.method1(1,"c", Collections.emptyList(),"aaaa"),equalTo(100));
        assertThat(simpleService.method1(1,"b", Collections.emptyList(),"aaaa"),equalTo(100));
        assertThat(simpleService.method1(1,"a", Collections.emptyList(),"aaaa"),equalTo(100));
    }

6.2 无返回值的函数

无返回值的函数用verify验证执行结果。

    @Test
    public void test1Method2(){
        Mockito.doNothing().when(simpleService).method2(anyInt(),anyString(),anyCollection(),isA(Serializable.class));
        simpleService.method2(1,"a", Collections.emptyList(),"aaaa");
        Mockito.verify(simpleService,times(1)).method2(1,"a", Collections.emptyList(),"aaaa");
    }

7 assertThat一些用法

    @Test
    public void test(){
        int i=10;
        assertThat(i,equalTo(10));
        assertThat(i,not(equalTo(20)));
        assertThat(i,is(10));
        assertThat(i,is(not(20)));
    }

    @Test
    public void test2(){
        int i=10;
        assertThat(i,both(equalTo(10)).and(not(equalTo(20))));
        assertThat(i,either(equalTo(10)).or(equalTo(20)));
        assertThat(i,anyOf(is(10),is(20),not(30)));
        assertThat(i,allOf(is(10),not(is(20)),not(30)));

        assertThat(i,is(not(20)));

        assertThat(Stream.of(1,2,3).anyMatch(j->j<2),equalTo(true));
        assertThat(Stream.of(1,2,3).allMatch(j->j<5),equalTo(true));

    }

8 注意点

8.1 不能mock局部变量

可以mock被测试方法所属类的成员变量，也可以moke被测试方法的入参，但是不能moke被测试方法的局部变量。moke被测试方法的局部变量会失效。

8.2 被测试的类中调用的函数的参数不需要mock

以测试类为基础，直接写在测试类的代码搞不到的就要mock，比如下面代码的这两行
String name = request.getParameter("name"); String password = request.getParameter("password");

package com.lanshang.mockito.quickstart;

import javax.servlet.http.HttpServletRequest;

public class AccountLoginController {
    AccountDao accountDao;

    public AccountLoginController(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public String login(HttpServletRequest request){
        String name = request.getParameter("name");
        String password = request.getParameter("password");
        try {
            Account account = accountDao.findAccount(name,password);
            if(account == null){
                return "/login";
            }else{
                return "/index";
            }
        } catch (Exception e) {
            e.printStackTrace();
            return "/505";
        }

    }
}

测试类

package com.lanshang.mockito.quickstart;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;

import javax.servlet.http.HttpServletRequest;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;

@RunWith(MockitoJUnitRunner.class)
public class AccountLoginControllerTest {
    AccountDao dao ;
    AccountLoginController accountLoginController ;
    HttpServletRequest request;
    Account account = new Account();



    @Before
    public void init(){
        dao = Mockito.mock(AccountDao.class);
        accountLoginController = new AccountLoginController(dao);
        request = Mockito.mock(HttpServletRequest.class);

    }

    @Test
    public void loginTest(){
        Mockito.when(request.getParameter("name")).thenReturn("cat");
        Mockito.when(request.getParameter("password")).thenReturn("123456");
        Mockito.when(dao.findAccount(Mockito.anyString(),Mockito.anyString())).thenReturn(account);
        String login = accountLoginController.login(request);
        assertThat(login,equalTo("/index"));
    }
}

但如果String name = request.getParameter("name"); String password = request.getParameter("password");这两行代码没有单独写，而是作为被测试的代码中某个调用函数的入参，如下图： Account account = accountDao.findAccount(request.getParameter("name"),request.getParameter("password"));
则可以不用mock，测试到调用函数这一行时入参用any代替就好了
被测试代码：

package com.lanshang.mockito.quickstart;

import javax.servlet.http.HttpServletRequest;

public class AccountLoginController {
    AccountDao accountDao;

    public AccountLoginController(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public String login(HttpServletRequest request){

        try {
            Account account = accountDao.findAccount(request.getParameter("name"),request.getParameter("password"));
            if(account == null){
                return "/login";
            }else{
                return "/index";
            }
        } catch (Exception e) {
            e.printStackTrace();
            return "/505";
        }

    }
}

测试代码

package com.lanshang.mockito.quickstart;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;

import javax.servlet.http.HttpServletRequest;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;

@RunWith(MockitoJUnitRunner.class)
public class AccountLoginControllerTest {
    AccountDao dao ;
    AccountLoginController accountLoginController ;
    HttpServletRequest request;
    Account account = new Account();



    @Before
    public void init(){
        dao = Mockito.mock(AccountDao.class);
        accountLoginController = new AccountLoginController(dao);
        request = Mockito.mock(HttpServletRequest.class);

    }

    @Test
    public void loginTest(){

        Mockito.when(dao.findAccount(Mockito.anyString(),Mockito.anyString())).thenReturn(account);
        String login = accountLoginController.login(request);
        assertThat(login,equalTo("/index"));
    }
}

8.3 mock出的对象最好reset

mock出的对象最好reset下，在测试结束后清除stub造成的影响。下例simpleService是mock的对象。

    @After
    public void destroy(){
        Mockito.reset(simpleService);
    }
晒太阳的小猫咪
关注
专栏目录
mockito
03-28
Mockito 是一个流行的 Java 单元测试框架，用于模拟（mock）对象以便在测试中隔离被测代码。这个框架使得开发者能够创建虚拟对象，这些对象的行为可以被预先定义，以便在测试过程中控制依赖关系，避免了对真实环境的...
mockito中两种部分mock的实现，spy、callRealMethod
weixin_33755554的博客
01-05 505
  什么是类的部分mock（partial mock）？A：部分mock是说一个类的方法有些是实际调用，有些是使用mockito的stubbing（桩实现）。   为什么需要部分mock？ A：当需要测试一个组合方法（一个方法需要其它多个方法协作）的时候，某个叶子方法（只供别人调用，自己不依赖其它反复）已经被测试过，我们其实不需要再次测试这个叶子方法，so，让叶子打桩实现返回结果，上层方法...
mockito ， jmockit ，PowerMock
hui1350的博客
05-30 1356
1. mockito (1) org.mockito mockito-core 2.7.12 test (2) init 类前@RunWith(MockitoJUnitRunner.class) 或者 @Before public void initMocks() { MockitoAnnotations.initMocks(this); } (3) 注解 @Mock 该对象所有的方法被置空，...
Mockito常用方法
最新发布
武壮
07-24 1159
打桩可以理解为 mock 对象规定一行的行为，使其按照我们的要求来执行具体的操作。在 Mockito 中，常用的打桩方法为。验证是校验待验证的对象是否发生过某些行为，Mockito 中验证的方法是：verify。方法来 mock静态方法的所属类，此方法返回一个具有作用域的模拟对象。Verify 配合 time() 方法，可以校验某些操作发生的次数。spy() 方法与 mock() 方法不同的是。实例：使用 mock 方法 mock 一个类。thenReturn() 代码示例。快速 mock 的方法，使用。
PowerMockito踩坑指南
编程入不了 门
06-22 2703
好久没用PowerMockito了，最近使用踩了一堆的坑，记录一下1、对于测试类中包含@Autowired注解的变量可以使用@Mock注解，被测试类使用@InjectMock注解，注意此时被测试的类还是实例化后的，而不是mock出来的，如下： 2、对于局部变量的mock（new 出来的局部变量）方法一：在1的基础上，将被测试的类加入到@PrepareForTest中，这时再mock局部变量就会生效（mock一个对象，然后将局部变量的构造方法进行mock，返回mock出的对象），如下： 方法二：将被测
mock
Xiaowo
10-25 2406
mock的由来一开始，没有mock的时候，人们测试的时候只能自己mock。比如需要一个PersonDao类的对象，其中有连接数据库查询数据库当前存储人数的方法getPersonNum()。但是可能因为数据库不存在等问题，其中的操作并不能正确执行，这时候一般：public PerSonDaoMock extends PersonDao{ @Override public int get
成员变量 VS 局部变量
xinfeng777的博客
04-27 657
相同点：1.遵循变量声明的格式 数据类型 变量名 = 初始值 2.都有作用域 不同点：1.声明的位置不同 成员变量：声明在类内部 方法外 局部变量：声明在方法里 方法的形参部分 代码块内 2.修饰符：
PowerMock学习（三）之Mock局部变量
专研技术结交志同道合的朋友
11-20 276
编写powermock用例步骤： 类上面先写这两个注解@RunWith(PowerMockRunner.class)、@PrepareForTest(StudentService.class) 先模拟一个假对象即studentdao方法中的局部变量 用无参的方式new对象 再模拟这个对象被调用时，是否有返回，有返回值给出默认值，没有用doNothing() 验证有返回值使用assertEqua...
Mockito+Junit5测试方法实践
06-12
内容概要：参考Mockito官方API文档，实践框架每个特性。 适合人群：Mockito入门人员以及想全面熟悉Mockito特性的人员，做到了开箱即用。 能学到什么：“Mockito 4.6.0 + Junit 5”的组合编程。 使用建议：使用前安装...
Mockito Cookbook
10-10
《Mockito Cookbook》是一本专注于Java单元测试的实用指南，特别强调了Mockito框架的使用。Mockito是一款广泛应用于Java开发中的测试驱动开发（TDD）工具，它允许开发者创建和配置模拟对象，以便在测试中隔离代码并...
概述 Mockito
11-30
关 于 Mockito 的 概 述
Mockito加junit
05-28
Mockito加junit
Mockito在SpringBoot中的使用
焱宣的博客
12-12 528
https://www.bilibili.com/video/BV1My4y1x75U/?spm_id_from=autoNext
PowerMock 之进阶学习
汪小哥
05-06 3526
模拟局部变量 Mock Local Variable 有返回值得局部变量的模拟！ 这里的局部变量没有采取依赖注入的方式，而是采取了一种而是在方法内部 new出一个 EmployeeDao，我们通常都会写这样的代码，平时我们也可能或碰上这样的问题，那么我们怎么去解决这个问题呢！public class EmployeeService { public int getTotalEmployee() {
Mock单元测试使用
cj1140874158的博客
10-09 998
mock私有属性并赋值： private HttpServletRequest getRequest() { return RpcContext.getContext().getRequest(HttpServletRequest.class); } private HttpServletResponse getResponse() { return RpcContext.getContext().getResponse(HttpServletRes
《PowerMock实战手册》读书笔记及个人总结
jiege_best的博客
02-25 1193
文章目录前言依赖及注解mock local variablemock staticmock final class / methodmock constructorsmock private methods 前言 注：本文总结源自汪文君的e-book 《PowerMock 实战手册》, pdf不知道为何导入不了，以下是随书笔记。 pdf我保存在了百度云里，需要的可以自取 链接: https://pan.baidu.com/s/1WbZbHLjntUXK1BhDqmkiZQ 密码: 6hm4 本文目的：通过
PowerMock笔记-局部变量
Andy's Blog
05-13 5716
import lombok.Data; /** * @author chenjianfei */ @Data public class Employee { private String name; private Integer age; }import vip.fkandy.powermock.common.Employee; /** * @author chenji...
自动生成mock简单的测试
erlanp的专栏
11-08 1233
package com.areyoo.lok.controller; import com.areyoo.lok.vo.TestTwoVo; import java.lang.reflect.*; import java.util.HashSet; import java.util.ArrayList; import com.alibaba.fastjson.JSON; import com.areyoo.lok.service.api.WwService; import com.areyoo.lok.
Mock 及 Mockito 教程
ToBeMaybe_的博客
04-14 7261
Mockito 教程 Mockito框架官方地址mockito，文档地址，中文版文档。 Mockito库能够Mock对象、验证结果以及打桩(stubbing)。 1. Mock和Mockito的关系 在软件开发中提及mock，通常理解为模拟对象。 为什么需要模拟? 在我们一开始学编程时,我们所写的对象通常都是独立的，并不依赖其他的类，也不会操作别的类。但实际上，软件中是充满依赖关系的，比如我们会基于service类写操作类,而service类又是基于数据访问类(DAO)的，依次下去，形成复杂的依赖关系。 单
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值