【微服务系列】eureka结合Ribbon进行负载均衡搭建

最新推荐文章于 2024-07-07 11:08:51 发布
最新推荐文章于 2024-07-07 11:08:51 发布
阅读量1.8k 收藏 9
点赞数 2
分类专栏： java 文章标签： 微服务 SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36313726/article/details/86599901
版权

【微服务系列】eruka结合Ribbon进行负载均衡

一、Eureka

  1. Eureka 是 Netflix 出品的用于实现服务注册和发现的工具。
  2. Eureka是一个基于REST(Representational State Transfer)的服务，主要用于AWS cloud， 提供服务定位(locating services)、负载均衡(load balancing)、故障转移(failover of middle-tier servers)。我们把它叫做Eureka Server.
  3. Eureka也提供了基于Java的客户端组件，Eureka Client,内置的负载均衡器可以实现基本的round-robin负载均衡能力。

二、Ribbon

  1. Ribbon是Netflix发布的负载均衡器，它有助于控制HTTP和TCP的客户端的行为。
  2. 在给Ribbon配置服务提供地址后，Ribbon就可基于某种负载均衡算法，自动地帮助服务消费者去请求
    eureka与ribbon结合进行负载均衡

三、SpringBoot集成eureka与Ribbon示例代码：

1、创建eureka注册中心：

创建eureka注册中心
目录结构
配置application.yml


server:
  port: 3333

eureka:
  instance:
    hostname: localhost

  server:
    enable-self-preservation: false #关闭自我保护
    #eviction-interval-timer-in-ms: 8000 #清理间隔（单位毫秒，默认是60*1000）
    # 此处不开启缓存
    use-read-only-response-cache: false

  #不要向注册中心注册自己
  client:
    #设置是否向注册中心注册，默认是true
    register-with-eureka: false
    #禁止检索服务
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka

对启动类添加**@EnableEurekaServer**注解

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

新建一个listener包并在其内创建EurekaStateListener类(监听服务注册与下线)


package com.example.demo.listener;

import com.netflix.appinfo.InstanceInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.netflix.eureka.server.event.*;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class EurekaStateListener {

    private final static Logger logger = LoggerFactory.getLogger(EurekaStateListener.class);

    @EventListener
    public void listen(EurekaInstanceCanceledEvent event) {
        logger.info("服务{}已下线", event.getAppName());
        logger.info("server地址信息{}", event.getServerId());
    }

    @EventListener
    public void listen(EurekaInstanceRegisteredEvent event) {
        InstanceInfo instanceInfo = event.getInstanceInfo();
        logger.info("服务{}进行注册", instanceInfo.getAppName()+ instanceInfo.getHostName() +"  "+ instanceInfo.getIPAddr() +"  "+ instanceInfo.getPort());
    }

    @EventListener
    public void listen(EurekaInstanceRenewedEvent event) {
        logger.info("服务{}进行续约", event.getServerId() +"  "+ event.getAppName());
    }

    @EventListener
    public void listen(EurekaRegistryAvailableEvent event) {
        logger.info("注册中心启动,{}", System.currentTimeMillis());
    }

    @EventListener
    public void listen(EurekaServerStartedEvent event) {
        logger.info("注册中心服务端启动,{}", System.currentTimeMillis());
    }

}

2、创建ribbon

在这里插入图片描述
application.yml配置信息

eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:3333/eureka
    healthcheck:
      enabled: true
  instance:
    lease-expiration-duration-in-seconds: 90
    lease-renewal-interval-in-seconds: 30
    appname: ribbon-client


server:
  port: 8092
spring:
  application:
    name: ribbon-client
  #必须加下面，否则ribbon重试机制开启不了
  cloud:
    loadbalancer:
      retry:
        enabled: true

#重试机制
  ribbon:
    MaxAutoRetries: 1
    MaxAutoRetriesNextServer: 1
    OkToRetryOnAllOperations: true
    ConnectTimeout: 250
    ReadTimeout: 1000
#熔断
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 4500

pom.xml里面加入重试机制依赖：feign、retry、hystrix并且加入监控依赖：actuator
依赖信息

<!-- 引入Actuator监控依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- 重试机制 ，必须配，否则重试不生效 -->
        <dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
        </dependency>

完整的配置pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.RC2</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- 引入Actuator监控依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- 重试机制 ，必须配，否则重试不生效 -->
        <dependency>
            <groupId>org.springframework.retry</groupId>
            <artifactId>spring-retry</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

创建config包，并且创建RibbonConfig类

package com.example.demo.config;

import com.netflix.loadbalancer.BestAvailableRule;
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RoundRobinRule;
import feign.Retryer;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RibbonConfig {
    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @Primary
    @Bean(name="lbcRestTemplate")
    RestTemplate lbcRestTemplate() {
        return new RestTemplate();
    }


    /**自定义配置ribbon负载均衡算法
     * @return
     */
    @Bean
    public IRule myRule(){
        return new RoundRobinRule();//轮询
        //return new RetryRule();//重试
        //return new RandomRule(); //随机负载
        //return new BestAvailableRule();//选择一个最小的并发请求的server
    }
}

创建controller包并创建HelloController类

package com.example.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.net.URI;

@RestController
public class HelloController {
    @Autowired
    @Qualifier(value = "restTemplate")
    private RestTemplate restTemplate;

    @Autowired
    @Qualifier(value = "lbcRestTemplate")
    private RestTemplate lbcRestTemplate;

    @Autowired
    private LoadBalancerClient loadBalancerClient;
    @CrossOrigin
    @RequestMapping(value = "/hello" ,method = RequestMethod.GET)
    public String hello(){
        String url="http://hello/hello";
        ServiceInstance instance = this.loadBalancerClient.choose("hello");
        URI helloUri = URI.create(String.format("http://%s:%s/hello", instance.getHost(), instance.getPort()));
        System.out.println("Target service uri =  "+helloUri.toString());
        return restTemplate.getForObject(url,String.class);
    }
}

3、创建服务提供者Hello

Hello的配置
在pom.xml添加actuator依赖

 <!-- 引入Actuator监控依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

即完整的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Greenwich.RC2</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 引入Actuator监控依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

创建controller包并创建HelloController类

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class HelloController {
    @ResponseBody
    @RequestMapping(value = "hello")
    public Object hello()
    {
        return "HelloWorld";
    }
    
}

编写application.yml内容

spring:
  application:
    name: hello
server:
  port: 8089
eureka:
  client:                                                   #客户端注册进eureka服务列表内
    service-url:
      defaultZone: http://127.0.0.1:3333/eureka
    healthcheck:
      enabled: true #开启健康检查（需要spring-boot-starter-actuator依赖）

  instance:
    lease-expiration-duration-in-seconds: 90 #服务过期时间配置,超过这个时间没有接收到心跳EurekaServer就会将这个实例剔除
    lease-renewal-interval-in-seconds: 30 #服务刷新时间配置，每隔这个时间会主动心跳一次
    appname: hello

management:
  endpoints:
    web:
      exposure:
        include: "*"
  server:
    port: 8089
    servlet:
      context-path: /
    ssl:
      enabled: false
  endpoint:
    health:
      show-details: always
  shutdown:
    enabled: true
    #禁用密码验证
    sensitive: false

访问http://localhost:3333出现eureka的界面(hello应用中只有一个url有效，另外一个是我一开始没设置应用名后来添加，eureka还没进行刷新的原因)
在这里插入图片描述
访问http://localhost:8092/hello
在这里插入图片描述
附上三个demo的目录
在这里插入图片描述
完整项目下载地址：https://download.csdn.net/download/qq_36313726/10933212

cocohao715
关注
专栏目录
Eureka和Ribbon整合
qq_44507798的博客
12-09 729
简述 三大角色 Eureka Server：提供服务的注册与发现 Service Provider：服务生产方，将自身服务注册到Eureka中，从而使服务消费方能狗找到 Service Consumer：服务消费方，从Eureka中获取注册服务列表，从而找到消费服务 设计图： 整合的编码套路： 1、导入依赖 2、编写yml配置文件 3、在启动类上启动服务，@EnableXXX 4、编写配置类 一、注册中心 1、导入依赖 <!--导包~--> &l.
Eureka+Ribbon搭建微服务
越自律越自由
05-11 2204
Eureka注册中心 springcloud Eureka是基于Netflix Eureka做了二次封装，主要负责完成微服务架构中的服务治理功能。 Eureka服务端即服务注册中心; Eureka客户端，主要处理服务的注册与发现。客户端服务通过注解和参数配置方式，嵌入在客户端应用程序中，应用启动时向注册中心注册自身服务，并周期性的发送心跳来更新他的服务； <!--springcloud工...
Spring Boot与Netflix Eureka的集成
最新发布
聚娃科技开发者博客
07-07 906
Eureka Server用作服务注册中心，而Eureka Client则是一个注册到Eureka Server上的服务。通过本文，我们了解了如何在Spring Boot中集成Netflix Eureka，从创建Eureka Server和Eureka Client开始，到使用Feign Client进行服务发现和调用。运行Eureka Client项目，稍等片刻，然后刷新Eureka仪表盘，你应该能够看到Eureka Client已经注册到Eureka Server。，你应该能够看到Eureka仪表盘。
Eureka+Ribbon实现
qq_41895699的博客
08-20 732
本人最近看了Spring Cloud微服务实战 在对Eureka这个微服务注册中心莫名的感兴趣 我使用的工具是IDEA2018版，所以会遇到第一个坑，那就是 版本的坑，在IDEA中Spring Boot的版本，已经到了2.0x，如果你想全手工配置的话，那么这个坑就会存在，你会说在pom里把母版版本改掉，但是，如果你没把之前版本的springboot关联的包去掉，那么，你配置完eureka也会...
Ribbon 和 Eureka 的集成
GY的的专栏
04-18 1746
Ribbon 是 Netflix 发布的云中间层服务开源项目，其主要功能是提供客户侧软件负载均衡算法，将 Netflix 的中间层服务连接在一起。Eureka 是一个 RESTful 服务，用来定位运行在 AWS 域（Region）中的中间层服务。本文介绍 Eureka 和 Ribbon 的集成，附带 Ribbon 自定义负载均衡算法示例。         Ribbon 和 Eureka 的集成
eureka+Ribbon实现负载均衡（二）
weixin_41979002的博客
08-16 1607
Ribbon简述 是什么 spring cloud ribbon 是一套客户端的负载均衡工具 主要用来：客户端的软件负载均衡算法和服务的调用 做什么 负载均衡+RestTemplate调用 LB负载均衡：将用户请求平摊到多个服务器上，从而达到系统的HA（高可用） ribbon是本地负载均衡：在调用微服务接口时，会在注册中心中获取注册信息服务列表之后缓存到jvm本地，从而在本地实现rpc的远程调用； nginx是服务器负载均衡：客户端所用请求交给nginx，然后由nginx实现转发请求.即负载均衡是由服务端实
「微服务系列」Eureka和Ribbon
yameing在努力学习中... ...
12-09 127
如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule规则的客户端也会将其忽略。并发连接数的上限，可以由客户端的..ActiveConnectionsLimit属性进行配置。（1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。以区域可用的服务器为基础进行服务器的选择。这个规则会随机选择服务器，这个权重值会影响服务器的选择。忽略那些短路的服务器，并选择并发数较低的服务器。
学习日志day74（2021-11-16）（1、微服务架构 2、Eureka服务搭建 3、Ribbon负载均衡 4、Feign简化服务间的调用）
huzige_的博客
11-16 505
学习内容：学习SpringCloud（Day74） 1、微服务架构 2、Eureka服务搭建 3、Ribbon负载均衡 4、Feign简化服务间的调用 1、微服务架构 （1）微服务架构是⼀种架构模式，它提倡将单⼀应⽤程序划分成⼀组⼩的服务，服务之间互相协调、互相配合，为⽤户提供最终价值。每个服务运⾏在其独⽴的进程中，服务与服务间采⽤轻量级的通信机制互相协作（通常是基于HTTP协议的RESTful API）。每个服务都围绕着具体业务进⾏构建，并且能够被独⽴的部署到⽣产环境、类⽣产环境等。另外，应当尽量避免统
eureka结合Ribbon进行负载均衡搭建
01-23
在Spring Cloud中，当Ribbon与Eureka配合使用时，Ribbon可自动从Eureka Server获取服务提供者地址列表，并基于负载均衡算法，请求其中一个服务提供者实例。展示了Ribbon与Eureka配合使用时的架构。
Spring-Cloud之Eurka微服务注册中心集群和Ribbon负载均衡的搭建
Zzzzzzz的博客
10-22 198
文章目录说明：springcloud-api的搭建springcloud-consumer-dept-80消费者的搭建application.yamlRestTemplateConfigConsumerDeptConsumerspringcloud-enureka-7001集群的搭建依赖EurekaServerPort7001application.yamlspringcloud-enureka-7002集群的搭建application.yamlspringcloud-enureka-7003集群的搭建ap
Spring Cloud微服务、eureka注册中心、ribbon负载均衡和重试
xiaolu_0的博客
10-24 688
1、springcloud微服务 2、eureka注册中心 3、ribbon负载均衡和重试
Spring Cloud整合Eureka整合Ribbon
05-31
Spring Cloud微服务,Eureka整合Ribbon做负载均衡, 此项目需要配合文章使用.....
springcloud+eureka+ribbon整合
11-02
springcloud+eureka+ribbon 整合，ribbon+restTemplate实现服务调用
springcloud-搭建微服务（聚合工程）及配置Eureka(搭建Eureka集群)+负载均衡(Ribbon)调用eureka服务
04-15
本文将深入探讨如何使用Spring Cloud搭建微服务，特别是配置Eureka服务发现以及集成Ribbon实现负载均衡。 首先，我们来看标题中的“搭建微服务（聚合工程）”。在Spring Cloud中，聚合工程通常指的是一个包含了多...
SpringCloud之Eureka集群以及Ribbon负载均衡包含自定义负载均衡策略初体验
LeBronJJJ的博客
03-20 1054
本篇紧接着上一篇, 在搭好了我们微服务整体体系的情况下, 将Eureka增加为集群的工作模式, 以及加入Ribbon的客户端负载均衡配置以及进行自定义负载均衡策略的操作. 回顾上篇我们是如何搭建微服务架构的 :SpringCloud之Eureka初接触 为何需要配置Eureka集群,这里有我们需要掌握的一些知识点: 首先要了解CAP原则,即: 强一致性 可用性 分区容错性 我们之前聊过Zookeeper,这是一种专注AP(强一致性和分区容错性)服务治理与发现工具,而Eureka则是一种专注于CP(可用性和分
【Ribbon】Eureka整合了Ribbon
AloneYueCSDN
09-04 424
没有引入spring-cloud-starter-ribbon也可以使用ribbon <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-ribbon</artifactId> </dependency> 猜测spring-cloud-starter-netflix-eure
Eureka 整合Ribbon 实现客户端侧负载均衡
街角有人祝福,巷口有人哭~
05-31 350
前言: 一般来说,在生成环境中,各个微服务都会部署多个实例,那么服务消费者要如何将请求分摊到多个服务提供者实例上呢? 1.Ribbon 简介 Ribbon 是Netflix 发布的负载均衡器,它有助于HTTP和TCP客户端的行为。为Ribbon配置服务提供者地址列表后,Ribbon就可以基于某种负载均衡算法,自动地帮助服务消费者去请求。Ribbon默认提供了很多的负载均衡算法,例如: 轮询丶随机等。当然也可以为Ribbon实现自定义的负载均衡算法。 在Spring C...
SpringCloud-Eureka Ribbon
weixin_45701868的博客
07-12 1004
SpringCloud-Eureka Ribbon
Ribbon整合Eureka组件，以实现负载均衡
weixin_33724659的博客
05-06 725
1整体框架的说明     在本案例的框架里，我们将配置一个Eureka服务器，搭建三个提供相同服务的Eureka服务提供者，同时在Eureka服务调用者里引入Ribbon组件，这样，当有多个url向服务调用者发起调用请求时，整个框架能按配置在IRule和IPing中的“负载均衡策略“和“判断服务器是否可用的策略”，把这些url请求合理地分摊到多台机器上。     在下图里，我们能看到本系统的结...
SpringCloud微服务实战：Eureka与客户端负载均衡
SpringCloud LoadBalancer是SpringCloud提供的客户端负载均衡工具，它与Ribbon一起工作，允许客户端决定如何从服务列表中选择一个服务实例进行请求。在SpringCloud中， Ribbon是一个内置的HTTP客户端，可以配合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值