Mock 测试技术

于 2024-07-09 16:44:43 发布
阅读量653 收藏 16
点赞数 31
分类专栏： 软件测试 文章标签： java 单元测试 Mockito junit
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LEE180501/article/details/140273583
版权

一、Mock 类框架的使用场景

在实际软件开发中，要进行测试的方法存在外部依赖（如 db，redis，第三方接口调用等），这些外部依赖可能存在各种问题，例如不稳定、缺乏数据、难以模拟等等，所以为了能够专注于对该方法（单元）的 逻辑 进行测试，就希望能虚拟出外部依赖，避免外部依赖成为测试的阻塞项，一般都是测试 service 层即可。

使用 Mock 就可以解决这些问题，Mock 框架他本是是不依赖于其他任何外部依赖的，使用 Mock 对象可以模拟外部依赖的行为和状态，所以相当于将测试方法和外部依赖隔离，能够更好的对单元方法的逻辑测试。

二、Mockito

1、Mockito 简介

Java 中主流的 Mock 框架

Mockito 支持情况：
限制： 老版本对于 final class、final method、staticmethod、private method 均不能被 mockitomock，目前已支持 final class、final method、staticmethod 的 mock
官网文档： https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html


spring-boot-starter-test 已经集成了mockito，所以 SpringBoot 项目无需另外引入依赖。

mock 对象与 spy 对象

Mock 对象是一个完全模拟的对象，用于单元测试中替代真实对象。它允许开发者定义方法的预期行为，而不执行任何实际的业务逻辑。这种对象常用于隔离被测类的依赖，以确保测试的独立性和纯粹性。Mock 对象在方法调用时会返回预设的结果，帮助测试者验证方法调用的正确性和交互行为。

Spy 对象是一个部分模拟的对象，用于单元测试中模拟部分行为，同时保留对象的其他真实行为。Spy 对象在未定义行为的方法调用时，会执行真实对象的方法。它允许开发者在某些方法上插桩，而在其他方法上执行真实逻辑。

作用对象方法插桩方法不插桩备注
mock 对象执行插桩逻辑返回 mock 对象的默认值接口或实现类，用于创建完全虚拟的 mock 对象，无需实际实现
spy 对象执行插桩逻辑调用真实方法类，用于创建部分 mock、部分真实的 spy 对象，需要实际实例

插桩： 指定调用某个方法时的行为，一般是指调用某个方法时的返回值。

不插桩： 使用模拟对象的方法默认行为（mock 对象返回默认值，spy 对象调用真实方法）

2、初始化 mock 和 spy 对象的三种方式

  • junit4：@RunWith（MockitoJUnitRunner.class）+@Mock 等注解
  • junit5：@Extendwith（MockitoExtension.class）+@Mock 等注解
@ExtendWith(MockitoExtension.class)
public class InitMockito {
    @Mock
    private IUserService mockUserService;
    @Spy
    private IUserService spyUserService;

    @Test
    public void testMock1() {
        // 判断某对象是不是 mock 对象 -- true
        Assertions.assertTrue(Mockito.mockingDetails(mockUserService).isMock());
        // 判断某对象是不是 spy 对象 -- false
        Assertions.assertFalse(Mockito.mockingDetails(mockUserService).isSpy());
        // 判断某对象是不是 mock 对象 -- true -- spy 对象是另一种不同类型的 mock 对象
        Assertions.assertTrue(Mockito.mockingDetails(spyUserService).isMock());
        // 判断某对象是不是 spy 对象 -- true
        Assertions.assertTrue(Mockito.mockingDetails(spyUserService).isSpy());
    }
}
  • Mockito.mock（X.class） 等静态方法
public class InitMockito2 {
    private IUserService mockUserService;

    private IUserService spyUserService;

    @BeforeEach
    public void init() {
        mockUserService = Mockito.mock(IUserService.class);
        spyUserService = Mockito.spy(IUserService.class);
    }

    @Test
    public void testMock1() {
        // 判断某对象是不是 mock 对象 -- true
        Assertions.assertTrue(Mockito.mockingDetails(mockUserService).isMock());
        // 判断某对象是不是 spy 对象 -- false
        Assertions.assertFalse(Mockito.mockingDetails(mockUserService).isSpy());
        // 判断某对象是不是 mock 对象 -- true -- spy 对象是另一种不同类型的 mock 对象
        Assertions.assertTrue(Mockito.mockingDetails(spyUserService).isMock());
        // 判断某对象是不是 spy 对象 -- true
        Assertions.assertTrue(Mockito.mockingDetails(spyUserService).isSpy());
    }
}
  • MockitoAnnotations.openMocks（this）+@Mock 等注解
public class InitMockito3 {
    @Mock
    private IUserService mockUserService;
    @Spy
    private IUserService spyUserService;

    @BeforeEach
    public void init() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testMock1() {
        // 判断某对象是不是 mock 对象 -- true
        Assertions.assertTrue(Mockito.mockingDetails(mockUserService).isMock());
        // 判断某对象是不是 spy 对象 -- false
        Assertions.assertFalse(Mockito.mockingDetails(mockUserService).isSpy());
        // 判断某对象是不是 mock 对象 -- true -- spy 对象是另一种不同类型的 mock 对象
        Assertions.assertTrue(Mockito.mockingDetails(spyUserService).isMock());
        // 判断某对象是不是 spy 对象 -- true
        Assertions.assertTrue(Mockito.mockingDetails(spyUserService).isSpy());
    }
}

3、参数匹配

在 Mockito 中，参数匹配器（ArgumentMatchers）用于指定在模拟对象的方法被调用时匹配某些参数的规则。这样可以灵活地定义方法行为，而不必精确匹配所有参数。Mockito 提供了多种参数匹配器，可以匹配各种类型和条件的参数。

测试参数匹配

@ExtendWith(MockitoExtension.class)
public class MockitoMatchParamsTest {
    @Mock
    private IUserService mockUserService;
    @Test
    public void test1() {
        // 方法插桩
        Mockito.when(mockUserService.login("lee","123")).thenReturn(new User());
        Mockito.doReturn(new User()).when(mockUserService).login("boy","456");
        // 调用方法
        mockUserService.login("lee","123");
        mockUserService.login("boy","456");
        // 验证 mock 方法是否按预期被调用次数
        Mockito.verify(mockUserService,Mockito.times(1)).login(ArgumentMatchers.eq("lee"),ArgumentMatchers.anyString());
        Mockito.verify(mockUserService,Mockito.times(1)).login(ArgumentMatchers.anyString(),ArgumentMatchers.eq("456"));
        Mockito.verify(mockUserService,Mockito.times(2)).login(ArgumentMatchers.anyString(),ArgumentMatchers.anyString());
    }
}

注意： Mockito 的参数匹配器需要与非匹配器参数分开使用，不能混合。

// 错误：混合使用匹配器和非匹配器参数         
when(myService.performAction(anyString(), "fixed value")).thenReturn("Mocked Result");

正确写法：

// 正确：所有参数都使用匹配器         
when(myService.performAction(anyString(), eq("fixed value"))).thenReturn("Mocked Result");

 // 正确：所有参数都不使用匹配器         
 when(myService.performAction("specific input", "fixed value")).thenReturn("Mocked Result");

4、方法插桩

插桩： 指定调用某个方法时的行为，一般是指调用某个方法时的返回值。

不插桩： 使用模拟对象的方法默认行为（mock 对象返回默认值，spy 对象调用真实方法）。
在 Mockito 中，mock 和 spy 对象在不进行方法插桩的情况下有不同的默认行为。下面是对它们默认值行为的详细说明。

下表，展示了在不插桩的情况下，mock 和 spy 对象的默认值情况：

对象类型Mock 对象默认值Spy 对象默认值
对象类型null调用真实对象的方法返回值
booleanfalse调用真实对象的方法返回值
int0调用真实对象的方法返回值
short0调用真实对象的方法返回值
byte0调用真实对象的方法返回值
long0L调用真实对象的方法返回值
float0.0f调用真实对象的方法返回值
double0.0d调用真实对象的方法返回值
集合类型空集合或数组调用真实对象的方法返回值
void 方法什么都不做调用真实对象的方法（有副作用）

（1）Mockito 提供了两种插桩方式

  1. when(obj.someMethod().thenXxx()–其中 obj 可以是 mock 对象，不适用无返回值的方法
  2. doXxx().when(obj).someMethod()–其中 obj 可以是 mock/spy 对象，也适用于没有返回值的方法 注意：spy 对象写在 when 中会先执行一次原方法，即使插桩也起不到 mock 的目的
@ExtendWith(MockitoExtension.class)
public class MockitoStubbingTest {
    @Mock
    private IUserService mockUserService;
    @Spy
    private UserServiceImpl spyUserService; // spy 作用于实现类

    @Test
    public void testStubbing() {
        // 1. mock 和 spy 对象都使用 when-then 进行插桩
        when(mockUserService.realMethod()).thenReturn("test-mockMethod!");
        when(spyUserService.realMethod()).thenReturn("test-spyMethod!");
        // 结果：spy 对象写在 when 中会先执行一次原方法，即使插桩也起不到 mock 的目的
        System.out.println(mockUserService.realMethod());
        System.out.println(spyUserService.realMethod());
    }
}

正确写法：

@Test
public  void testStubbing2() {
    // 1. mock 和 spy 对象都使用 when-then 进行插桩
    when(mockUserService.realMethod()).thenReturn("test-mockMethod!");
    doReturn("test-spyMethod!").when(spyUserService).realMethod();
    // 结果：spy 对象写在 when 中会先执行一次原方法，及时插桩也起不到 mock 的目的
    System.out.println(mockUserService.realMethod());
    System.out.println(spyUserService.realMethod());
}


（2）void 返回值方法插桩

使用 doNothing().when().yourMethod()：

@Test
public void testStubbing3() {
    doNothing().when(mockUserService).modefyPwd(anyString(),anyString(),any(User.class));
    mockUserService.modefyPwd("123","456",new User());
}

（3）抛异常

两种方式：

  1. doThrow - when
  2. when - thenThrow
@Test
public void testThrowException() {
    // 方法一：使用 doThrow-when
    doThrow(RuntimeException.class).when(mockUserService).realMethod();
    try {
        mockUserService.realMethod();
        // 如果未抛出异常，这 mock 失败
        Assertions.fail();
    } catch (Exception e) {
        // 断言异常类型
        Assertions.assertTrue(e instanceof RuntimeException);
    }

    // 方法二：使用 when-throw
    when(mockUserService.login("boy","123")).thenThrow(RuntimeException.class);
    try {
        mockUserService.login("boy","123");
        // 如果未抛出异常，这 mock 失败
        Assertions.fail();
    } catch (Exception e) {
        // 断言异常类型
        Assertions.assertTrue(e instanceof RuntimeException);
    }
}

（4）多次插桩

    @Test
    public void multiStubbing() {
        // 第一次调用返回 1，第二次调用返回 2，第三次调用返回 3，第四次调用返回 3 ...
//        doReturn(1l).doReturn(2l).doReturn(3l).when(mockUserService).count();
//        doReturn(1l,2l,3l).when(mockUserService).count();
        
//        when(mockUserService.count()).thenReturn(1l).thenReturn(2l).thenReturn(3l);
        when(mockUserService.count()).thenReturn(1l,2l,3l);
        Assertions.assertEquals(1,mockUserService.count());
        Assertions.assertEquals(2,mockUserService.count());
        Assertions.assertEquals(3,mockUserService.count());
        Assertions.assertEquals(3,mockUserService.count());
    }

（5）thenAnswer 指定插桩逻辑

  1. 调用 thenAnswer 方法，重写 Answer
  2. 调用 doAnswer 方法，重写 Answer 使用 thenAnswer 时

注意： 泛型表示[插桩方法的返回值]

@Test
public void thenAnswerStubbing() {
    when(mockUserService.login(anyString(),anyString())).thenAnswer(new Answer<User>() {
        /**
         * 泛型表示[插桩方法的返回值]
         */
        @Override
        public User answer(InvocationOnMock invocationOnMock) throws Throwable {
            // getArgument 表示获取插桩方法的第几个参数值
            String name = invocationOnMock.getArgument(0, String.class);
            String pasw = invocationOnMock.getArgument(1, String.class);
            // 重组数据
            User user = new User();
            user.setUsername("用户名："+name);
            user.setPassword("密码："+pasw);
            return user;
        }
    });
    // 或者使用 doAnswer()
    
    // 调用方法
    User user = mockUserService.login("lee", "123");
    // 断言
    Assertions.assertEquals("用户名：lee",user.getUsername());
    Assertions.assertEquals("密码：123",user.getPassword());
}

（6）执行真正的原始方法

  1. 调用 thenCallRealMethod 方法
  2. 调用 doCallRealMethod 方法

注意： 要求此时 @Mock 注解标记的是 实现类。

    @Test
    public void testMockRealMethod() {
        when(mockUserService.realMethod()).thenCallRealMethod();
//        doCallRealMethod().when(mockUserService).realMethod();
        // 调用
        String res = mockUserService.realMethod();
        // 断言
        Assertions.assertEquals("service-realMethod!",res);
    }

（7）verify 的使用

verify 方法主要用于验证 mock 对象的方法是否按预期被调用。也可以验证方法的调用次数、顺序和参数。

@Test
public void testMockVerify() {
    // 默认返回 null （没有插桩）
    User user = mockUserService.login("lee", "123");
    Assertions.assertNull(user);

    // 验证调用过 1 次 login 方法，且参数是 "lee","123"
    verify(mockUserService).login("lee","123");
    // 等价于上面 vetify
    verify(mockUserService,times(1)).login("lee","123");

    // 校验没有调用的两种方式
    verify(mockUserService,times(0)).count();
    verify(mockUserService,never()).count();

    // 校验最少或最多调用了多少次
    verify(mockUserService,atLeast(1)).login("lee","123");
    verify(mockUserService,atMost(1)).login("lee","123");
}

5、@InjectMocks 注解使用

@InjectMocks 注解的主要作用是将使用 @Mock 或 @Spy 注解创建的 mock 对象或 spy 对象注入到被测试对象中，以便在测试中使用这些对象。它可以自动识别和匹配需要注入的字段，无论是通过构造函数、字段注入还是方法注入。

注意： 被 @InjectMocks 标注的属性必须是实现类，因为 mockito 会创建对应的实例对象，默认创建的对象就是未经过 mockito 处理的普通对象，因此常配合 @Spy 注解使其变为默认调用真实方法的 mock 对象。一般被测试的类，都需要标注这两个注解。

// 被测试的服务类
class MyService {
    private final MyDependency myDependency;

    // 构造函数注入依赖
    public MyService(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    public String performAction() {
        return myDependency.someMethod();
    }
}

// 依赖类
class MyDependency {
    public String someMethod() {
        return "Real Response";
    }
}

public class MyServiceTest {

    @Mock
    private MyDependency myDependency; // 创建 mock 对象

    @InjectMocks
    @Spy
    private MyService myService; // 自动注入 mock 对象

    @Before
    public void setUp() {
        // 初始化注解标注的对象
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testPerformAction() {
        // 设置 mock 对象的行为
        when(myDependency.someMethod()).thenReturn("Mocked Response");

        // 调用被测试对象的方法
        String result = myService.performAction();

        // 验证结果
        assertEquals("Mocked Response", result);
    }
}

三、实际编写单元测试注意事项

  1. 在实际测试中，mock 不全，可能会出现空指针情况，这个时候不要慌，先看报错，再根据报错将为空的对象 mock 到测试类中。
  2. 实际代码中，每个 service 接口方法都可能有多个 return，此时要想保证代码覆盖率，就需要为每个方法构造合适插桩，多写几个 Test 测试，确保覆盖到每个 return。

四、Mockito 在 SpringBoot 环境使用（不推荐，慢）

  1. @MockBean：类似 @Mock 用于通过类型或名字替换 spring 容器中已经存在的 bean， 从而达到对这些 bean 进行 mock 的目的。
  2. @SpyBean：作用类似 @Spy 用于通过类型或名字包装 spring 容器中已经存在的 bean，当需要 mock 被测试类的某些方法时可以使用。
  3. Spring 中生成的对象受 spring 管理，上述 Bean 被 mock 或 spy 后，依然受 Spring 容器管理。
不摸鱼的程序员
关注
  • 31
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mock技术
qq_35653145的博客
08-14 317
一、moco jar包下载及运行  1、访问https://repo1.maven.org/maven2/com/github/dreamhead/moco-runner/1.1.0/，下载moco-runner-1.1.0-standalone.jar，将下载下来的jar包拷贝至指定路径  2、在jar所在的路径下，新建json文件，输入以下代码，进行保存 [ { "description" : "Mock技术模拟", "request" :{ "uri" : "/mock_demo"
mock技术
热门推荐
qq_40132294的博客
10-27 1万+
常用mock工具:charles,fiddler,moco,wiremock,browsermod-proxy,mitmproxy. 1.moco: GitHub - dreamhead/moco: Easy Setup Stub Server Stub(桩)实现: moco.json文件内容: [ { "response" : { "text" : "Hello, Moco" } }, { "request......
面向开发的测试技术（一）：Mock
weixin_33699914的博客
05-01 196
引子：自上世纪末Kent Beck提出TDD(Test-Driven Development)开发理念以来，开发和测试的边界变的越来越模糊，从原本上下游的依赖关系，逐步演变成你中有我、我中有你的互赖关系，甚至很多公司设立了新的QE(Quality Engineer)职位。和传统的QA(Quality Assurance)不同，QE的主要职...
软件测试 | 测试开发 | 如何模拟真实使用场景？mock 技术来帮你
慕漓的博客
07-25 170
比如在工作中，可能需要mock第三方的回调给到测试人员测试的环境，从而更顺利的开展测试工作，也使得测试环境更接近真实的使用场景。设置charles进行maplocal，右键点击MapLocal->进入EditMapping->点击choose->选择修改后的html->点击OK。1.打开Tools->Rewrite，对内容进行替换，下面把页面中“我的关注”替换为霍格沃兹。2.再次申请百度，同样，“我的关注”变为了“霍格沃兹”是将指定的网络请求重定向到另一个网址请求地址。...
初学测试驱动的MOCK技术，展示一下牛逼的成果！
daxi1047的博客
02-22 140
前言手头的项目越来越大，很多以前不会出现的问题开始浮现。比如：我修改了一个基础的类库，却意外的影响了九重天外的客户项目，直接导致一个功能无法实现。我郁闷啊！！！因此开始要有组织、有预谋、有计划的对项目过程进行测试驱动了。最终目标是，我修改了底层某个dll的某个方法，测试框架能够自动帮我找出来所有收到影响的类，全部执行一次回归测试，并发送一份漂亮的报告到我手里。这个目标估计1、2个星...
mock 测试.pptx
12-23
Mock 测试技术详解与 Fiddler AutoResponder 面板介绍 Mock 测试是一种软件测试方法，旨在模拟一些难以构造或获取的对象，以便进行测试。在测试过程中，Mock 对象可以帮助开发者更好地测试单元测试、集成测试和系统...
python mock测试的示例
12-16
Python中的Mock测试是一种重要的单元测试技术，用于模拟代码中依赖的外部组件，以便在测试时专注于测试目标函数或类的行为，而不是它们的依赖。在Python 2中，Mock作为一个独立的第三方库，需要通过`pip install ...
Mock模拟测试使用
10-12
Mock是一种软件测试技术，它涉及使用模拟对象来代替实际对象，以简化测试过程中的依赖性管理。在软件开发中，特别是面向对象编程中，类通常与其他类有复杂的交互。为了有效地测试这些类的功能，而不受其依赖项的影响...
mock
04-16
Mock技术在软件开发中扮演着重要的角色，尤其是在测试阶段。它允许开发者在真实环境尚未准备好或不可用时，创建模拟对象来替代实际依赖，以便进行功能验证和性能测试。本项目涉及的内容是关于如何在Windows或Linux...
mock技术以及其优缺点
m0_53396342的博客
04-19 2117
软件测试面试题：mock技术以及其优缺点
Mock技术_Mock与Moco技术介绍
lkr
04-17 1944
Mock技术_Mock与Moco技术介绍 1、什么是mock技术？ 2、mock技术（测试桩/挡板）使用场景？ 3、实现mock方案 4、 moco介绍
10-Mock技术
小咸鱼er
01-29 607
文章目录一、Mock技术简介Moco框架二、Moco服务环境搭建1、Moco服务搭建2、Moco服务运行三、Moco技术构建请求1、约定URI2、约定请求参数3、约定请求方法4、约定请求头5、约定请求体参数-form6、约定请求体参数-json7、uri-startsWith匹配、uri-endsWith匹配、uri-contain包含8、返回状态码9、返回响应头10、重定向11、返回JSON格式的数据四、测试接口实战 一、Mock技术简介  在软件测试过程中，对于一些不容易构造、获取的对象，用一个虚拟的对
mock技术之moco
qq_41714308的博客
09-16 768
1、mock：制造一个虚拟的接口，模拟接口返回的数据，用来测试 2、moco 实现mock的技术很多，分为两类，mock数据和mock服务： mock数据：即 mock 一个对象，写入一些预期的值，通过它进行自己想要的测试。常见的有： EasyMock、Mockito 、WireMock、JMockit。主要适用于单元测试。 mock 服务：即mock 一个 sever，构造一个依赖的服务并给予他预期的服务返回值，适用范围 广，更加适合集成测试。如 moco框架。 Moco 是类似一个 Mock
深入接口测试之Mock技术
最新发布
软件测试技术交流分享
11-16 1027
服务端与客户端约定了接口，但服务端还没有完成开发时，客户端一般由如下处理方式：
mock技术使用
qq_34139239的博客
08-14 420
什么情况下会使用mock技术 1.1.需要将当前被测单元和其依赖模块独立开来，构造一个独立的测试环境，不关注被测单元的依赖对象，只关注被测单元的功能逻辑 ----------比如被测代码中需要依赖第三方接口返回值进行逻辑处理，可能因为网络或者其他环境因素，调用第三方经常会中断或者失败，无法对被测单元进行测试，这个时候就可以使用mock技术来将被测单元和依赖模块独立开来，使得测试可以进行下去。 1...
技术分享 | 如何模拟真实使用场景？mock 技术来帮你
霍格沃兹测试学院的博客
09-27 242
mock 是一种通过代理修改请求与响应，从而辅助构造更多应用场景的工具。比如在工作中，可能需要 mock 第三方的回调给到测试人员测试的环境，从而更顺利的开展测试工作，也使得测试环境更接近真实的使用场景。Charles 修改请求与响应MapLocal将指定的网络请求重定向到本地文件。1、先保存接口返回数据，右键单击某接口->点击 SaveResponse ->选择 html 格式2、对本地的 html 进行修改，将“百度一下”改为“霍格沃兹”3、设置 charles 进行 map local，右键点击 Ma
Mock技术在测试领域的应用
Ant Ren的专栏
01-18 4879
什么是Mock? 我想Mock这个词对于经常写单元测试的开发来说肯定不默生。如今在测试驱动开发的思想下，单元测试被推到了一个很重要的位置。因为它是直接能覆盖到所有代码逻辑的最佳测试手段。在单元测试的过程中，复杂业务逻辑需要跟外部资源通信交互，例如获得一个数据库连接对象，例如发送一个HTTP请求并获得实时回复的一些数据等等。当复杂业务从这些与外部对象的交互开始时，单元测试往往需要借助给力的Mock
Mock技术_异步接口介绍与案例演示_多线程并发
lkr
04-19 1824
Mock技术_异步接口介绍与案例演示_多线程并发 一、异步接口介绍 1、同步与异步说明 2、异步接口应用场景 3、异步接口一般流程 4、异步接口处理方法 二、案例业务场景介绍1、案例业务场景介绍 2、技术方案 3、取对应的接口详情 4、技术实施 启动Mock：https://blog.csdn.net/weixin_44801980/article/details/115784377 三、编写Python代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不摸鱼的程序员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值