Spring cloud搭建HSF框架，整合mybatis、redis、rabbit

最新推荐文章于 2025-07-02 18:43:07 发布
原创 最新推荐文章于 2025-07-02 18:43:07 发布 · 2.8k 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring cloud #hsf #mybatis #redis

环境

一、搭建HSF框架

新建一个普通maven项目作为父项目
在这里插入图片描述
然后新建moudle作为生产者，这里直接新建spring项目会比较方便，这里阿里官网文档里的HSF版本不支持太高的boot版本，所以要选低版本
在这里插入图片描述

在这里插入图片描述
添加HSF依赖

		<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hsf</artifactId>
            <version>1.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-pandora</artifactId>
            <version>1.3</version>
        </dependency>

创建接口

public interface EchoService {
    String echo(String string);
}

实现接口

import com.alibaba.boot.hsf.annotation.HSFProvider;
import com.example.redis.RedisUtil;

@HSFProvider(serviceInterface = EchoService.class)
public class EchoServiceImpl implements EchoService{

    @Override
    public String echo(String string) {
        return "hello "+string;
    }
}

启动类

import com.taobao.pandora.boot.PandoraBootstrap;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ScHsfProviderApplication {

    public static void main(String[] args) {

        // 启动 Pandora Boot 用于加载 Pandora 容器
        PandoraBootstrap.run(args);
        SpringApplication.run(ScHsfProviderApplication.class, args);
        // 标记服务启动完成,并设置线程 wait。防止业务代码运行完毕退出后，导致容器退出。
        PandoraBootstrap.markStartupAndWait();
    }
}

application.properties配置文件

 spring.application.name=hsf-provider
 server.port=18081
 #统一管理服务版本
 spring.hsf.version=1.0.0
 spring.hsf.timeout=3000

启动ScHsfProviderApplication，这里要保证EDAS服务打开了，否则会报错，如果启动不了，可能是权限不够，在命令前加sudo。如果启动报错hostName is null，在启动参数里添加-Dhsf.server.ip=你的IP。这里的IP是指你网络里的IP，一般是192.168.xx.xx这种的。
打开http://localhost:8080/#/dsConfig可以看到刚刚发布的服务
在这里插入图片描述
在这里插入图片描述

再新建一个moudle作为消费者，依赖与生产者一样，把接口类复制过来，包名也要一样

public interface EchoService {
    String echo(String string);
}

新建HSF配置类，所有服务都要在此配置

import com.alibaba.boot.hsf.annotation.HSFConsumer;
import org.springframework.context.annotation.Configuration;

@Configuration
public class HsfConfig {
    @HSFConsumer
    private EchoService echoService;
}

启动类与生产者一样

import com.taobao.pandora.boot.PandoraBootstrap;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ScHsfConsumerApplication {

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

application.properties配置文件

spring.application.name=hsf-consumer
#端口要与生产者不同
server.port=18082
#版本号要一样
spring.hsf.version=1.0.0
spring.hsf.timeout=1000

新建Controller类测试，这里的echoServiceIDEA会飘红，不用管


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SimpleController {
    @Autowired
    private EchoService echoService;
    @RequestMapping(value = "/hsf-echo/{str}", method = RequestMethod.GET)
    public String echo(@PathVariable String str) {
        return echoService.echo(str);
    }
}

启动ScHsfConsumerApplication,这时候在配置中心也能看到消费者了，访问http://localhost:18082/hsf-echo/my
在这里插入图片描述
搭建成功。

集成redis

启动redis服务
在这里插入图片描述
添加redis依赖

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

修改application.yml，使用application.properties也行，只是风格不一样，两个可以共存，默认reids是没有密码的

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password:
    timeout: 0
    pool:
      max-active: 8
      max-idle: 8
      max-wait: 10000

RedisConfig.java配置类

import java.lang.reflect.Method;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    /**
     * 生成key的策略
     *
     * @return
     */
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
    /**
     * 管理缓存
     */
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
        return rcm;
    }
    /**
     * RedisTemplate配置
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

RedisUtil.java工具类

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;
@Service
public class RedisUtil {
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }
    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }
    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        ValueOperations operations = redisTemplate.opsForValue();
        return operations.get(key);
    }
    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }
    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }
    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }
    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List lRange(String k, long l, long l1) {
        ListOperations list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }
    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations set = redisTemplate.opsForSet();
        set.add(key, value);
    }
    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set setMembers(String key) {
        SetOperations set = redisTemplate.opsForSet();
        return set.members(key);
    }
    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }
    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

修改EchoServiceImpl.java

import com.alibaba.boot.hsf.annotation.HSFProvider;
import com.example.redis.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;

@HSFProvider(serviceInterface = EchoService.class)
public class EchoServiceImpl implements EchoService{
    @Autowired
    private RedisUtil redisUtil;
    @Override
    public String echo(String string) {
        redisUtil.set("hi",string);
        return "hello "+string;
    }
}

重启生产者，消费者不用改动，重新访问http://localhost:18082/hsf-echo/my
在这里插入图片描述
查询redis库
在这里插入图片描述
集成成功。

集成mybatis

添加依赖

		<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>

添加配置application.properties

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.max-idle=10
spring.datasource.max-wait=10000
spring.datasource.min-idle=5
spring.datasource.initial-size=5

#路径为你存mybatis的xml配置的路径
mybatis.mapperLocations=classpath:com/example/dao/mapper/*.xml

具体类和xml我就不放了，上一个路径图好了，我是通过工具直接生成的
在这里插入图片描述
修改EchoServiceImpl.java

import com.alibaba.boot.hsf.annotation.HSFProvider;
import com.example.dao.User;
import com.example.dao.UserMapper;
import com.example.redis.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;

@HSFProvider(serviceInterface = EchoService.class)
public class EchoServiceImpl implements EchoService{
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private UserMapper userMapper;
    @Override
    public String echo(String string) {
        User user = userMapper.selectByPrimaryKey(1);
        redisUtil.set("my",user);
        User user1 = (User) redisUtil.get("my");
        System.out.println(user1.getCname());

        return "hello "+string;
    }
}

重启生产者，消费者不用动，继续访问http://localhost:18082/hsf-echo/my，后台打印
在这里插入图片描述
查询redis
在这里插入图片描述
整合完毕。

整合Rabbit

自行安装erlang。由于RabbitMQ是基于erlang开发的，所以要安装RabbitMQ先必须安装erlang
安装RabbitMQ并启动RabbitMQ
在这里插入图片描述
添加依赖

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

添加配置

mq.rabbit.host=127.0.0.1
mq.rabbit.port=5672
mq.rabbit.virtualHost=/
mq.rabbit.username=guest
mq.rabbit.password=guest

新增配置类RabbitConfig

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitConfig {
    @Bean
    public Queue Queue() {
        return new Queue("hello");
    }
}

接收消息类，这里休眠和打印时间是为了确认消息的异步性。

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@RabbitListener(queues = "hello")
public class HelloReceiver {
    @RabbitHandler
    public void process(String hello) {
        try {
            new Thread().sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("消息接受为："+hello+"------"+new Date());
    }
}

修改EchoServiceImpl

import com.alibaba.boot.hsf.annotation.HSFProvider;
import com.example.dao.User;
import com.example.dao.UserMapper;
import com.example.redis.RedisUtil;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Date;
@HSFProvider(serviceInterface = EchoService.class)
public class EchoServiceImpl implements EchoService{
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private AmqpTemplate amqpTemplate;
    @Override
    public String echo(String string) {
        User user = userMapper.selectByPrimaryKey(1);
        redisUtil.set("my",user);
        User user1 = (User) redisUtil.get("my");
        System.out.println(user1.getCname());
        amqpTemplate.convertAndSend("hello", "hello rabbitMQ");
        System.out.println(new Date());
        return "hello "+string;
    }
}

重启生产者，消费者还是不用动。访问http://localhost:18082/hsf-echo/my
在这里插入图片描述
整合完毕。

谈谈HSF在Spring中的应用
zhangxing
02-05 961
谈谈HSF在Spring中的应用HSF简介HSF的应用场景什么是二方包服务提供方怎么提供服务？服务调用方怎么订阅服务？ HSF简介 HSF即高可用服务框架（High-speed Service Framework），是在阿里巴巴广泛使用的分布式RPC服务框。 HSF的应用场景 HSF调用链包括服务调用方及服务提供方，服务提供方需要提供可用服务并提供二方包给服务调用方，服务调用方需要订阅提供方的服务，通过二方包调用相应的API完成请求。 什么是二方包 公司内部的依赖库，一般指公司内部的其他项目发布的
（四）、为什么选择SpringCloud作为微服务架构（各微服务框架的对比）
w1316022737的博客
12-23 1209
为什么选择SpringCloud作为微服务架构 一、BAT公司用的微服务架构有哪些？ 阿里Dubbo/HSF Dubbo是阿里以梁飞为核心的团队开发的，但是在2012年团队走的走，散的散，从那时起Dubbo不再有人维护，直到2017年阿里才开始重拾Dubbo，开始维护Dubbo，升级Dubbo，相隔5年，现在阿里开发的HSF（江湖人称：好舒服） 京东JSF 新浪微博Motan 当当网DubboX...
Spring cloud HSF 集成 HSF 高级特性
ontheroad1875的专栏
09-17 4649
链接地址：https://helpcdn.aliyun.com/document_detail/63868.html 本页目录 单元测试 异步调用 在之前的文档中，HSF 开发已经介绍了如何使用 Spring Cloud 来开发 HSF 应用。 本文将介绍一下 HSF 的一些高级特性在 Spring Cloud 开发方式下的使用方式。目前内容包含 单元测试 和 异步调用 两部分，后续会有更...
springcloud自学，结合springcloud组件
最新发布
zhangshihao11的博客
07-02 764
Springcloud 及其组件自学
分布式服务框架HSF学习
googitest的博客
06-09 891
  HSF提供的是分布式服务开发框架，taobao内部使用较多，总体来说其提供的功能及一些实现基础：1.标准Service方式的RPC  1）、Service定义：基于OSGI的Service定义方式  2）、TCP/IP通信：   IO方式：nio,采用mina框架   连接方式：长连接   服务器端有限定大小的连接池   WebService方式  3）、序列化：Hessian序列化机制2...
EDAS入门-springcloud+HSF开发实战
My Blog My Style
10-24 6154
该系列博文旨在整理阿里云帮助文档中有关EDAS开发相关知识，自己在写学习了解时，个人在理解阿里帮助文档之后，整理代码使其更适合企业级应用，顺便做个备忘录。 前言 目前 EDAS 已经完全支持 Spring Cloud 应用了，您可以将 Spring Cloud 应用直接部署到 EDAS 中。 Spring Boot 提出的概念是 Build Anything，解决...
hsf
u013165852的博客
03-27 634
hsf 参考文章： 1.HSF源码剖析 2.Http和RPC区别 3.分布式服务框架HSF 4.高并发架构系列：如何从0到1设计一个类Dubbo的RPC框架 5.HSF的原理分析 6.阿里云 https://help.aliyun.com/video_detail/45223.html?spm=a2c4g....
spring cloud是不是HSF
07-20
不，Spring Cloud 和 HSF 是两个不同的框架。 Spring Cloud 是基于 Spring Boot 的开源微服务框架，它提供了一套简化分布式系统开发的解决方案。Spring Cloud 提供了丰富的组件和工具，例如服务注册与发现、负载...
springcloud集成调用跟踪.docx
11-20
首先，Spring Cloud Sleuth 是 Spring Cloud 的一个子项目，它为 Spring Boot 应用提供了分布式追踪的支持。通过 Sleuth，可以在微服务架构中自动插入追踪信息，如 Span 和 Trace ID，这些信息对于理解服务间的调用...
Dubbo vs SpringCloud：微服务双雄争霸，深度剖析优劣对决与实战抉择
MicandJava的博客
04-26 2453
但是，两者的业务部署方式相同，都需要前置一个网关来隔绝外部直接调用原子服务的风险。Dubbo服务依赖比较重，需要有完善的版本管理机制，但是程序入侵少，而SpringCloud是自有生态，省略了版本管理的问题，它使用JSON进行交互，为跨平台调用奠定了基础（如图）。Dubbo还支持其他各种通信协议，而SpringCloud使用HTTP协议的RESTAPI，因此，在通信速度上Dubbo略胜（如图）。Dubbo的每个组件都是需要部署在单独的服务器上，用来接收前端请求、聚合服务，并批量调用后台原子服务。
Spring Cloud 注册中心整合配置中心
qq_19404533的博客
12-01 3176
Spring Cloud 注册中心整合配置中心背景实现 背景 实现
HSF项目例子IDEA 与 eclipse 开发环境说明
03-19
HSF 官网Demo、IDEA 与 eclipse 开发环境说明；HSF，包结构等等
HSF (RPC远程调用框架)
苏老师的博客
12-21 4163
HSFHSF概述概述HSF架构功能应用开发方式使用 Ali-Tomcat 开发Ali-Tomcat概述安装及开发环境配置安装Ali-Tomcat和Pandora配置IntelliJ IDEA开发环境开发HSF应用定义服务接口开发服务提供者开发服务消费者本地运行服务部署到SAE使用Pandora Boo HSF概述 高速服务框架HSF（High-speed Service Framework），是在阿里巴巴广泛使用的分布式RPC服务框架。 官方文档: https://help.aliyun.com/docu
dubbo&hsf&spring-cloud简单介绍
dongfangbubai1012的博客
07-31 207
Dubbo： 简介：Dubbo是一个分布式服务框架，以及SOA治理方案。其功能主要包括：高性能NIO通讯及多协议集成，服务动态寻址与路由，软负载均衡与容错，依赖分析与降级等。 底部NIO基于netty框架； HSF： 简介：HSF提供的是分布式服务开发框架，taobao内部使用较多，总体来说其提供的功能及一些实现基础：1.标准Service方式的RP...
自己搭建阿里的hsf
weixin_33701564的博客
06-19 1108
2019独角兽企业重金招聘Python工程师标准>>> ...
阿里云 EDAS-HSF 环境搭建及例子编写
我是小黑，我要发发。
04-25 3621
阿里云 EDAS-HSF 环境搭建及例子编写 例子编写是参考EDAS_DEVELOPER_GUIDE.pdf文档配置的。原文档为2个项目，为了能更好体现接口的耦合度， 我拆分成三个项目分别是：Edas_service_provider、Edas_hsf_web、Edad_api。 1）Edas_service_provider是服务的提供者。目录如下图。SampleSer
淘宝HSF通信框架，集成spring 启动流程分析
Heihei 's note
06-07 1982
刚入职新公司，公司内部通信框架用的是淘宝的HSF，用法大概是在xml配置好一个接口，以及其他等待信息之类的。。注入即可，我就没看明白他这是咋回事。我猜应该是有注册中心，从注册中心拉取消费者实例然后去调用。 配置大概就是这么用的： <hsf:consumer id="accountCompanyService" interface="com.service.AccountCompanyService" group="${spring.hsf.accou...
HSF + EDAS 搭建微服务项目
weixin_56018532的博客
07-29 1944
HSF + EDAS 搭建微服务项目
@HSFProvider与Mybatisplus实现类兼容问题 @HSFProvider class: ***.impl.*** implements more than one interface:
qq_31839075的博客
12-15 895
项目开发中，使用@HSFProvider在继承mybatisplus的ServiceImpl时项目启动报错java.lang.IllegalArgumentException: @HSFProvider class: com.qdport.im.service.impl.ImConversationContentServiceImpl implements more than one interface 此时@HSFProvider认为有两个接口需要注册！ 需在@HSFProvider后添加指定接.
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值