SpringBoot + jackson 轻松搞定数据脱敏

最新推荐文章于 2024-07-22 14:00:43 发布
最新推荐文章于 2024-07-22 14:00:43 发布
阅读量45 收藏
点赞数
文章标签： spring boot 后端 java
原文链接：https://mp.weixin.qq.com/s/xzcwfLMo1xNa7VDIJAvc5w
版权

实际的业务开发过程中，我们经常需要对用户的隐私数据进行脱敏处理，所谓脱敏处理其实就是将数据进行混淆隐藏，例如下图，将用户的手机号、地址等数据信息，采用*进行隐藏，以免泄露个人隐私信息。

思考一下，我们可不可以在数据输出的阶段，进行统一数据脱敏处理，这样就可以省下不少体力活。

说到数据输出，很多同学可能会想到 JSON 序列化。是的没错，我们所熟悉的 web 系统，就是将数据通过 json 序列化之后展示给前端。

那么问题来了，如何在序列化的时候，进行数据脱敏处理呢？

废话不多说，代码直接撸上！

二、方案实践

2.1、首先添加依赖包

默认的情况下，如果当前项目已经添加了spring-web包或者spring-boot-starter-web包，因为这些jar包已经集成了jackson相关包，因此无需重复依赖。

如果当前项目没有jackson包，可以通过如下方式进行添加相关依赖包。

<!--jackson依赖-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.8</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.8</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>
2.2、编写脱敏类型枚举类，满足不同场景的处理
public enum SensitiveEnum {

    /**
     * 中文名
     */
    CHINESE_NAME,

    /**
     * 身份证号
     */
    ID_CARD,

    /**
     * 座机号
     */
    FIXED_PHONE,

    /**
     * 手机号
     */
    MOBILE_PHONE,

    /**
     * 地址
     */
    ADDRESS,

    /**
     * 电子邮件
     */
    EMAIL,

    /**
     * 银行卡
     */
    BANK_CARD,

    /**
     * 公司开户银行联号
     */
    CNAPS_CODE
}
2.3、编写脱敏注解类
import com.fasterxml.jackson.annotation.JacksonAnnotationsInside;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = SensitiveSerialize.class)
public @interface SensitiveWrapped {

    /**
     * 脱敏类型
     * @return
     */
    SensitiveEnum value();
}
2.4、编写脱敏序列化类
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import java.io.IOException;
import java.util.Objects;

public class SensitiveSerialize extends JsonSerializer<String> implements ContextualSerializer {

    /**
     * 脱敏类型
     */
    private SensitiveEnum type;

    
    @Override
    public void serialize(String s, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        switch (this.type) {
            case CHINESE_NAME: {
                jsonGenerator.writeString(SensitiveInfoUtils.chineseName(s));
                break;
            }
            case ID_CARD: {
                jsonGenerator.writeString(SensitiveInfoUtils.idCardNum(s));
                break;
            }
            case FIXED_PHONE: {
                jsonGenerator.writeString(SensitiveInfoUtils.fixedPhone(s));
                break;
            }
            case MOBILE_PHONE: {
                jsonGenerator.writeString(SensitiveInfoUtils.mobilePhone(s));
                break;
            }
            case ADDRESS: {
                jsonGenerator.writeString(SensitiveInfoUtils.address(s, 4));
                break;
            }
            case EMAIL: {
                jsonGenerator.writeString(SensitiveInfoUtils.email(s));
                break;
            }
            case BANK_CARD: {
                jsonGenerator.writeString(SensitiveInfoUtils.bankCard(s));
                break;
            }
            case CNAPS_CODE: {
                jsonGenerator.writeString(SensitiveInfoUtils.cnapsCode(s));
                break;
            }
        }
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider serializerProvider, BeanProperty beanProperty) throws JsonMappingException {
        // 为空直接跳过
        if (beanProperty != null) {
            // 非 String 类直接跳过
            if (Objects.equals(beanProperty.getType().getRawClass(), String.class)) {
                SensitiveWrapped sensitiveWrapped = beanProperty.getAnnotation(SensitiveWrapped.class);
                if (sensitiveWrapped == null) {
                    sensitiveWrapped = beanProperty.getContextAnnotation(SensitiveWrapped.class);
                }
                if (sensitiveWrapped != null) {
                    // 如果能得到注解，就将注解的 value 传入 SensitiveSerialize
                    return new SensitiveSerialize(sensitiveWrapped.value());
                }
            }
            return serializerProvider.findValueSerializer(beanProperty.getType(), beanProperty);
        }
        return serializerProvider.findNullValueSerializer(beanProperty);
    }

    public SensitiveSerialize() {}

    public SensitiveSerialize(final SensitiveEnum type) {
        this.type = type;
    }
}

其中createContextual的作用是通过字段已知的上下文信息定制JsonSerializer对象。

2.4、编写脱敏工具类
import org.apache.commons.lang3.StringUtils;

public class SensitiveInfoUtils {

    /**
     * [中文姓名] 只显示第一个汉字，其他隐藏为2个星号<例子：李**>
     */
    public static String chineseName(final String fullName) {
        if (StringUtils.isBlank(fullName)) {
            return "";
        }
        final String name = StringUtils.left(fullName, 1);
        return StringUtils.rightPad(name, StringUtils.length(fullName), "*");
    }

    /**
     * [中文姓名] 只显示第一个汉字，其他隐藏为2个星号<例子：李**>
     */
    public static String chineseName(final String familyName, final String givenName) {
        if (StringUtils.isBlank(familyName) || StringUtils.isBlank(givenName)) {
            return "";
        }
        return chineseName(familyName + givenName);
    }

    /**
     * [身份证号] 显示最后四位，其他隐藏。共计18位或者15位。<例子：420**********5762>
     */
    public static String idCardNum(final String id) {
        if (StringUtils.isBlank(id)) {
            return "";
        }

        return StringUtils.left(id, 3).concat(StringUtils
                .removeStart(StringUtils.leftPad(StringUtils.right(id, 4), StringUtils.length(id), "*"),
                        "***"));
    }

    /**
     * [固定电话] 后四位，其他隐藏<例子：****1234>
     */
    public static String fixedPhone(final String num) {
        if (StringUtils.isBlank(num)) {
            return "";
        }
        return StringUtils.leftPad(StringUtils.right(num, 4), StringUtils.length(num), "*");
    }

    /**
     * [手机号码] 前三位，后四位，其他隐藏<例子:138******1234>
     */
    public static String mobilePhone(final String num) {
        if (StringUtils.isBlank(num)) {
            return "";
        }
        return StringUtils.left(num, 3).concat(StringUtils
                .removeStart(StringUtils.leftPad(StringUtils.right(num, 4), StringUtils.length(num), "*"),
                        "***"));

    }

    /**
     * [地址] 只显示到地区，不显示详细地址；我们要对个人信息增强保护<例子：北京市海淀区****>
     *
     * @param sensitiveSize 敏感信息长度
     */
    public static String address(final String address, final int sensitiveSize) {
        if (StringUtils.isBlank(address)) {
            return "";
        }
        final int length = StringUtils.length(address);
        return StringUtils.rightPad(StringUtils.left(address, length - sensitiveSize), length, "*");
    }

    /**
     * [电子邮箱] 邮箱前缀仅显示第一个字母，前缀其他隐藏，用星号代替，@及后面的地址显示<例子:g**@163.com>
     */
    public static String email(final String email) {
        if (StringUtils.isBlank(email)) {
            return "";
        }
        final int index = StringUtils.indexOf(email, "@");
        if (index <= 1) {
            return email;
        } else {
            return StringUtils.rightPad(StringUtils.left(email, 1), index, "*")
                    .concat(StringUtils.mid(email, index, StringUtils.length(email)));
        }
    }

    /**
     * [银行卡号] 前六位，后四位，其他用星号隐藏每位1个星号<例子:6222600**********1234>
     */
    public static String bankCard(final String cardNum) {
        if (StringUtils.isBlank(cardNum)) {
            return "";
        }
        return StringUtils.left(cardNum, 6).concat(StringUtils.removeStart(
                StringUtils.leftPad(StringUtils.right(cardNum, 4), StringUtils.length(cardNum), "*"),
                "******"));
    }

    /**
     * [公司开户银行联号] 公司开户银行联行号,显示前两位，其他用星号隐藏，每位1个星号<例子:12********>
     */
    public static String cnapsCode(final String code) {
        if (StringUtils.isBlank(code)) {
            return "";
        }
        return StringUtils.rightPad(StringUtils.left(code, 2), StringUtils.length(code), "*");
    }

}
2.5、编写测试实体类

最后，我们编写一个实体类UserEntity，看看转换后的效果如何？

public class UserEntity {

    /**
     * 用户ID
     */
    private Long userId;

    /**
     * 用户姓名
     */
    private String name;

    /**
     * 手机号
     */
    @SensitiveWrapped(SensitiveEnum.MOBILE_PHONE)
    private String mobile;

    /**
     * 身份证号码
     */
    @SensitiveWrapped(SensitiveEnum.ID_CARD)
    private String idCard;

    /**
     * 年龄
     */
    private String sex;

    /**
     * 性别
     */
    private int age;

    //省略get、set...
}

测试程序如下：

public class SensitiveDemo {

    public static void main(String[] args) throws JsonProcessingException {
        UserEntity userEntity = new UserEntity();
        userEntity.setUserId(1l);
        userEntity.setName("张三");
        userEntity.setMobile("18000000001");
        userEntity.setIdCard("420117200001011000008888");
        userEntity.setAge(20);
        userEntity.setSex("男");

        //通过jackson方式，将对象序列化成json字符串
        ObjectMapper objectMapper = new ObjectMapper();
        System.out.println(objectMapper.writeValueAsString(userEntity));
    }
}

结果如下：

{"userId":1,"name":"张三","mobile":"180****0001","idCard":"420*****************8888","sex":"男","age":20}

很清晰的看到，转换结果成功！

如果你当前的项目是基于SpringMVC框架进行开发的，那么在对象返回的时候，框架会自动帮你采用jackson框架进行序列化。

@RequestMapping("/hello")
public UserEntity hello() {
    UserEntity userEntity = new UserEntity();
    userEntity.setUserId(1l);
    userEntity.setName("张三");
    userEntity.setMobile("18000000001");
    userEntity.setIdCard("420117200001011000008888");
    userEntity.setAge(20);
    userEntity.setSex("男");
    return userEntity;
}

请求网页http://127.0.0.1:8080/hello，结果如下：

图片

justDo0085
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot spring aop 拦截器注解方式实现脱敏
02-13
springboot spring aop 拦截器 注解方式实现脱敏（涉及到：pom.xml -->application.properties --->启动类-->拦截器）
SpringBoot+Security+Vue前后端分离开发权限管理系统
06-19
数据的工具Lombok简化对象封装工具?Druid???数据库连接池?【前端技术】Vue???????互联网最火的前端框架Vue?Router路由框架Vuex全局状态管理框架Axios前端?HTTP?框架Element?UI前端?UI?框架Vue?Element?Admin前端模板...
SpringBoot中敏感信息脱敏（一个注解搞定）
m0_75015491的博客
12-15 819
/ 脱敏类型// 前几位不脱敏// 最后几位不脱敏// 用什么打码/*** 序列化 数据处理*/@Override//判断是否为空脱敏类型//判断脱敏类型，进入对应类型的数据处理break;break;break;break;default:} else {//如果脱敏类型为空则赋值空，要不然会导致序列化错误/*** 读取自定义注解SensitivityEncrypt 创建上下文所需*/@Override。
SpringBoot修改Jackson序列化方式实现数据脱敏。
meser88的博客
07-10 694
对于某些接口返回的信息，涉及到敏感数据的必须进行脱敏操作，例如银行卡号、身份证号、手机号等，脱敏方式有多种方式。可以修改SQL语句，也可以写硬代码，也可以修改JSON序列化，这里介绍通过修改Jackson序列化方式实现数据脱敏。其中 OTHER类型为自定义类型，需在后面自定义脱敏的长度等。/***/@Getter/*** 中文名* *//*** 固话* *//*** 手机号* *//*** 住址* */ADDRESS,/*** 密码* */PASSWORD,
SpringBoot 使用自定义jackson注解实现数据脱敏
qinxun2008081的博客
01-09 459
SpringBoot 使用自定义jackson注解实现数据脱敏
Spring Boot 结合 jackson 实现数据脱敏
qq_21305943的专栏
07-24 230
这里使用jdk8函数式编程的特性，绑定函数操作/*名称脱敏*//*手机号脱敏*//*地址脱敏*/;//默认是手机号脱敏。
利用Jackson序列化实现数据脱敏
京东科技开发者
03-31 186
在项目中有些敏感信息不能直接展示，比如客户手机号、身份证、车牌号等信息，展示时均需要进行数据脱敏，防止泄露客户隐私。脱敏即是对数据的部分信息用脱敏符号（*）处理。
SpringBoot+hibernate+mysql+sqlserver双数据源
05-18
本项目"SpringBoot+Hibernate+MySQL+SQLServer双数据源"正为此目的设计，它利用SpringBoot的灵活性和便利性，结合Hibernate的ORM能力，实现了对MySQL和SQLServer两种主流数据库的支持，为数据迁移、读写分离、高可用...
微信小程序后台Springboot+Mysql
09-01
综上所述，"微信小程序后台Springboot+Mysql"的项目涉及到了Spring Boot的Web服务开发、数据库操作、微信小程序的用户认证和数据交互等多个方面。通过这样的组合，开发者可以快速构建稳定、高效的后台系统，支持微信...
SpringBoot + Mybatis + Redis 整合
06-27
在IT行业中，SpringBoot、Mybatis和Redis是三个非常重要的技术组件，它们分别代表了Java应用框架、持久层框架和高性能的键值存储系统。本文将深入探讨如何将这三个技术进行整合，以便在实际开发中构建高效、可扩展的...
springmvc log4j2 logback 注解 jackson 日志脱敏实现源码
12-30
几乎是网上 能找到的 日志脱敏的所有实现 1、基于正则表达式的 日志脱敏实现 ，扩展logback 、log4j 2、springmvc 返回报文脱敏。 3、基于注解方式的脱敏。 大家选择使用。
SpringBoot+MyBatis简单数据访问应用的实例代码
08-30
SpringBoot+MyBatis简单数据访问应用的实例代码 本文主要介绍了使用 SpringBoot 和 MyBatis 构建简单数据访问应用的实例代码，涵盖了从 Maven 依赖项到数据库连接的整个过程。 一、 Maven 依赖项 在 Pom 文件中，...
springboot常用脱敏器实例，基于Jackson序列化实现
zzztimes的博客
10-18 709
在开发中会遇到数据的展示需要做脱敏处理，两种方式：1. 让前端做脱敏处理，但是接口实际上返回了真实数据，所以该方案可行度比较低。2. 后端在序列化的时候做处理，这样既不会影响接口的逻辑，也避免了真实数据在网络中传输。
springboot 轻量及脱敏工具（Desensitization）
yyyyouuu的博客
02-24 474
简单好用，自己动手试试
【数据脱敏】⭐️SpringBoot 整合 Jackson 实现隐私数据加密
最新发布
没有简介、全是狠活
07-22 986
通过 Jackson 自定义序列化过程，实现统一全局数据脱敏处理
Spring Boot中的数据脱敏处理
技术研究中心
06-27 631
我们首先定义一个注解，用于标记需要脱敏的字段。Retention;Target;同时，我们定义一个枚举来表示不同的脱敏类型。本文介绍了在Spring Boot中如何进行数据脱敏处理。通过自定义注解和Jackson配置，我们可以轻松实现对敏感数据的脱敏，保护用户隐私。在实际应用中，我们可以根据具体需求灵活调整脱敏策略，确保数据安全。
SpringBoot实战：轻松实现接口数据脱敏
Z99263的博客
07-11 1014
本文深入探讨了在SpringBoot应用程序中实施数据脱敏策略的关键性，并提出了一种创新的解决方案，即通过集成自定义注解与Hutool脱敏工具类来高效地实现数据脱敏。此方案旨在精准地对敏感信息进行脱敏处理，确保用户隐私得到妥善保护，同时维护数据的安全性。我们期待这一方案能为开发者们提供有价值的参考，共同提升数据保护水平。😊。
springboot项目中实现数据脱敏
weixin_44727769的博客
06-08 2586
创建自定义脱敏枚举类：这里定义一个敏感字段的枚举，并设定各个字段的脱敏策略。/*** 用户名* 身份证* 手机号* 地址} }创建序列化类：SensitiveSerializer：} }定义SensitiveData注解定义返回结果实体类创建包含敏感数据字段的实体类，并在需要脱敏的字段上添加 @SensitiveData 注解。创建Conrtoller测试返回结果u . setUsername("张老三");
springboot+shiro+jwt+mybatisplus框架
06-09
这个框架整合可以分为以下几个步骤： 1. 集成 Spring Boot：在 pom.xml 文件中添加 Spring Boot 依赖，创建 Spring Boot 启动类。 2. 集成 MyBatis Plus：在 pom.xml 文件中添加 MyBatis Plus 依赖，配置数据源和 MyBatis Plus 相关配置。 3. 集成 Shiro：在 pom.xml 文件中添加 Shiro 依赖，创建 Shiro 配置类，配置 Shiro 的 Realm 和 SecurityManager。 4. 集成 JWT：在 pom.xml 文件中添加 jjwt 依赖，创建 JWT 工具类，用于生成和解析 JWT。 下面是一个简单的示例代码，你可以根据你的实际需求进行调整： 1. pom.xml 文件中添加依赖： ```xml <!-- Spring Boot --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- MyBatis Plus --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>${mybatis-plus.version}</version> </dependency> <!-- Shiro --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>${shiro.version}</version> </dependency> <!-- jjwt --> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>${jjwt.version}</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <version>${jjwt.version}</version> <scope>runtime</scope> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <version>${jjwt.version}</version> <scope>runtime</scope> </dependency> ``` 2. 创建 Spring Boot 启动类： ```java @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` 3. 配置 MyBatis Plus： ```java @Configuration @MapperScan("com.example.mapper") public class MyBatisPlusConfig { @Bean public PaginationInterceptor paginationInterceptor() { return new PaginationInterceptor(); } } ``` 4. 配置 Shiro： ```java @Configuration public class ShiroConfig { @Bean public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) { ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean(); shiroFilter.setSecurityManager(securityManager); shiroFilter.setUnauthorizedUrl("/401"); Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>(); filterChainDefinitionMap.put("/login", "anon"); filterChainDefinitionMap.put("/401", "anon"); filterChainDefinitionMap.put("/**", "jwt"); shiroFilter.setFilterChainDefinitionMap(filterChainDefinitionMap); Map<String, Filter> filters = new LinkedHashMap<>(); filters.put("jwt", new JwtFilter()); shiroFilter.setFilters(filters); return shiroFilter; } @Bean public DefaultWebSecurityManager securityManager(Realm realm) { DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(); securityManager.setRealm(realm); return securityManager; } @Bean public Realm realm() { return new UserRealm(); } } ``` 5. 创建 JWT 工具类： ```java public class JwtUtil { private static final String SECRET_KEY = "your_secret_key"; private static final long EXPIRATION_TIME = 3600_000; // 1 hour public static String generateToken(String username) { Date now = new Date(); Date expiration = new Date(now.getTime() + EXPIRATION_TIME); return Jwts.builder() .setSubject(username) .setIssuedAt(now) .setExpiration(expiration) .signWith(SignatureAlgorithm.HS512, SECRET_KEY) .compact(); } public static String getUsernameFromToken(String token) { Claims claims = Jwts.parser() .setSigningKey(SECRET_KEY) .parseClaimsJws(token) .getBody(); return claims.getSubject(); } public static boolean validateToken(String token) { try { Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token); return true; } catch (JwtException e) { return false; } } } ``` 6. 创建 JwtFilter： ```java public class JwtFilter extends AuthenticatingFilter { @Override protected AuthenticationToken createToken(ServletRequest servletRequest, ServletResponse servletResponse) { HttpServletRequest request = (HttpServletRequest) servletRequest; String token = request.getHeader("Authorization"); if (StringUtils.isBlank(token)) { return null; } return new JwtToken(token); } @Override protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception { HttpServletResponse response = (HttpServletResponse) servletResponse; response.setCharacterEncoding("UTF-8"); response.setContentType("application/json; charset=utf-8"); response.setStatus(HttpStatus.UNAUTHORIZED.value()); response.getWriter().write("{\"code\":401,\"message\":\"未登录或登录已过期，请重新登录\"}"); return false; } @Override protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception { HttpServletRequest request = (HttpServletRequest) servletRequest; String token = request.getHeader("Authorization"); if (StringUtils.isBlank(token)) { return false; } return JwtUtil.validateToken(token); } } ``` 7. 创建 JwtToken： ```java public class JwtToken implements AuthenticationToken { private final String token; public JwtToken(String token) { this.token = token; } @Override public Object getPrincipal() { return JwtUtil.getUsernameFromToken(token); } @Override public Object getCredentials() { return token; } } ``` 8. 创建 UserRealm： ```java public class UserRealm extends AuthorizingRealm { @Autowired private UserService userService; @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) { return null; } @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException { String username = (String) authenticationToken.getPrincipal(); User user = userService.getByUsername(username); if (user == null) { throw new UnknownAccountException("账号不存在"); } return new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName()); } } ``` 这样，简单的 Spring Boot + Shiro + JWT + MyBatis Plus 整合就完成了。你可以根据具体的需求，对代码进行修改和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值