mapstruct详解

最新推荐文章于 2024-08-16 18:50:36 发布
最新推荐文章于 2024-08-16 18:50:36 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： Java中间件 文章标签： mapstruct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/demon7552003/article/details/117086605
版权

文章目录

功能介绍

mapStruct是什么

MapStruct是基于JSR 269的Java注解处理器，因此可以在命令行构建中使用（javac、Ant、Maven等等），可以在IDE内使用。用于生成类型安全的bean映射类的Java注解处理器。属于编译时注解，如果转换bean内容有变化。需要手动clean下才能将变化的内容体现到class文件中。说白了就是通过注解的形式帮我们生成set,get方法。

mapStruct有哪些功能

最大的功能就是为我们转换两个不同的bean，或者List,比如拿java的代码规范来说。客户端入参–>系统的业务层入参—>db数据库的入参；就对这3个层次来说。一个req绝对是不能透传到db层的。为什么呢？就是为了降低耦合。提高业务的单一性，那么某一层参数有改变不会影响其他层。

整合到spring中

基本使用

接口注入和静态方法调用

引入

 <!-- https://mvnrepository.com/artifact/org.mapstruct/mapstruct -->
<dependency>
  <groupId>org.mapstruct</groupId>
  <artifactId>mapstruct</artifactId>
  <version>1.3.1.Final</version>
</dependency>
<dependency>
  <groupId>org.mapstruct</groupId>
  <artifactId>mapstruct-processor</artifactId>
  <version>1.3.1.Final</version>
</dependency>

示例

基础映射
@Data
public class PersonDto {
    private String name;
    private String sex;
    private Date birthday;
    private int age;
    private Double money;
    private String password;
    private Date createTime;

}
//-----------------------------------
@Data
public class PersonVo {
    private String fullName;
    private String sex;
    private String birthday;
    private int age;
    private Double money;
    private String password;
}
//-----------------------------------
@Mapper
public interface PersonMapper {

    PersonMapper INSTANCE = Mappers.getMapper( PersonMapper.class );

    @Mapping( source = "fullName",target ="name")
    @Mapping( target ="birthday", dateFormat = "yyyy-MM-dd")
    PersonDto vo2dto(PersonVo vo);

    @Mapping( source = "name",target ="fullName")
    @Mapping( target ="birthday", dateFormat = "yyyy-MM-dd")
    @Mapping( target ="password",ignore = true)
    PersonVo dto2vo(PersonDto dto);

}

//-----------------------------------
ublic static void test1() {
        PersonDto dto = new PersonDto();
        dto.setAge(10);
        dto.setBirthday(Date.from(Instant.now()));
        dto.setMoney(2.543D);
        dto.setName("john");
        dto.setSex("F");
        dto.setPassword("password");
        dto.setCreateTime(new Date());

        System.out.println("dto:::" + dto.toString());
        PersonVo vo = PersonMapper.INSTANCE.dto2vo(dto);
        System.out.println("vo:::" + vo.toString());
        PersonDto dto2 = PersonMapper.INSTANCE.vo2dto(vo);
        System.out.println("dto2:::" + dto2.toString());

    }
//--------------OUTPUT:
dto:::PersonDto(name=john, sex=F, birthday=Wed Apr 07 11:53:05 CST 2021, age=10, money=2.543, password=password, createTime=Wed Apr 07 11:53:05 CST 2021)
vo:::PersonVo(fullName=john, sex=F, birthday=2021-04-07, age=10, money=2.543, password=null)
dto2:::PersonDto(name=john, sex=F, birthday=Wed Apr 07 00:00:00 CST 2021, age=10, money=2.543, password=null, createTime=null)

处理了以下几种情况：

  • 相同属性名称自动隐式映射
  • 属性名不同，需要指定@mapping
  • 类型不同，需要指定转换格式
  • 不需要设置的字段，使用ignore。如果字段在目标对象上不匹配的，则会自动忽略。

自动生成代码

package demon.study.mapstruct;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import javax.annotation.Generated;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2021-04-07T11:51:35+0800",
    comments = "version: 1.3.1.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
public class PersonMapperImpl implements PersonMapper {

    @Override
    public PersonDto vo2dto(PersonVo vo) {
        if ( vo == null ) {
            return null;
        }

        PersonDto personDto = new PersonDto();

        personDto.setName( vo.getFullName() );
        personDto.setSex( vo.getSex() );
        try {
            if ( vo.getBirthday() != null ) {
                personDto.setBirthday( new SimpleDateFormat( "yyyy-MM-dd" ).parse( vo.getBirthday() ) );
            }
        }
        catch ( ParseException e ) {
            throw new RuntimeException( e );
        }
        personDto.setAge( vo.getAge() );
        personDto.setMoney( vo.getMoney() );
        personDto.setPassword( vo.getPassword() );

        return personDto;
    }

    @Override
    public PersonVo dto2vo(PersonDto dto) {
        if ( dto == null ) {
            return null;
        }

        PersonVo personVo = new PersonVo();

        personVo.setFullName( dto.getName() );
        personVo.setSex( dto.getSex() );
        if ( dto.getBirthday() != null ) {
            personVo.setBirthday( new SimpleDateFormat( "yyyy-MM-dd" ).format( dto.getBirthday() ) );
        }
        personVo.setAge( dto.getAge() );
        personVo.setMoney( dto.getMoney() );

        return personVo;
    }
}
多个对象转换为1个对象
@Data
public class A1 {
    private String a;
    private String b;
}

@Data
public class A2 {
    private String c;
}

@Data
public class A {
    private String a;
    private String b;
    private String c;
}


@Mapper
public interface AMapper {

    AMapper INSTANCE = Mappers.getMapper( AMapper.class );
    @Mapping(source = "a1.a", target = "a")
    @Mapping(source = "a1.b", target = "b")
    @Mapping(source = "a2.c", target = "c")
    A two2one(A1 a1,A2 a2 );
}

//-----------------output：

自动生成代码

public class AMapperImpl implements AMapper {

    @Override
    public A two2one(A1 a1, A2 a2) {
        if ( a1 == null && a2 == null ) {
            return null;
        }

        A a = new A();

        if ( a1 != null ) {
            a.setA( a1.getA() );
            a.setB( a1.getB() );
        }
        if ( a2 != null ) {
            a.setC( a2.getC() );
        }

        return a;
    }
}
自定义转换器

枚举与Integer型不能互相转换，需要自定义（枚举与String 可能会转换正确，Int向枚举也可能转换正确）。

不兼容的类型需要自定义转换。

可以使用@mapper(uses),@mapping(expression)实现

@mapping(expression) 主要用于多个属性与一个属性的映射


public class Custom {
    @Getter
    public enum CustomType {
        EMPTY(0, "EMPTY"),
        A(1, "A"),
        B(2, "B");

        private Integer code;
        private String desc;

        CustomType(Integer code, String desc) {
            this.code = code;
            this.desc = desc;
        }

        @Override
        public String toString() {
            return String.format("{%s,%s}", code, desc);
        }

        public static CustomType from(Integer code) {
            switch (code) {
                case 1:
                    return CustomType.A;
                case 2:
                    return CustomType.B;
                default:
                    return CustomType.EMPTY;
            }
        }
    }

    @Data
    public static class CustomDto {
        private Date birthday;
        private CustomType customA;
        private CustomType customB;
        private CustomType customC;
    }

    @Data
    public static class CustomVo {
        private long birthday;
        private String customA;
        private Integer customB;
        private Integer customC;
        private int all;
    }

    @Mapper(uses = {Date2IntHandler.class})
    public interface CustomMapper {
        CustomMapper INSTANCE = Mappers.getMapper(CustomMapper.class);

        @Mapping(target = "all", expression = "java(enum2Int(dto.getCustomB()) + enum2Int(dto.getCustomA())  )")
        CustomVo dto2vo(CustomDto dto);

        CustomDto vo2dto(CustomVo vo);

        default CustomType int2Enum(Integer code) {

            return CustomType.from(code);
        }

        default Integer enum2Int(CustomType type) {

            return type.getCode();
        }

    }

    public static class Date2IntHandler {

        public static Date int2Date(long i) {
            return new Date(i);
        }

        public static long date2Int(Date date) {
            return date.getTime();
        }
    }

    public static void main(String[] args) {
        test();
    }

    public static void test() {

        CustomDto dto = new CustomDto();
        dto.setBirthday(Date.from(Instant.now().minus(Period.ofDays(1000))));
        dto.setCustomA(CustomType.A);
        dto.setCustomB(CustomType.B);
        dto.setCustomC(CustomType.B);

        System.out.println("dto:::" + dto.toString());
        CustomVo vo = CustomMapper.INSTANCE.dto2vo(dto);
        System.out.println("vo:::" + vo.toString());
        CustomDto dto2 = CustomMapper.INSTANCE.vo2dto(vo);
        System.out.println("dto2:::" + dto2.toString());

    }
}

输出：

dto:::Custom.CustomDto(birthday=Thu Jul 12 14:38:04 CST 2018, customA={1,A}, customB={2,B}, customC={2,B})
vo:::Custom.CustomVo(birthday=1531377484863, customA=A, customB=2, customC=2, all=3)
dto2:::Custom.CustomDto(birthday=Thu Jul 12 14:38:04 CST 2018, customA={1,A}, customB={2,B}, customC={2,B})

自动生成代码

public class Custom$CustomMapperImpl implements CustomMapper {

    @Override
    public CustomVo dto2vo(CustomDto dto) {
        if ( dto == null ) {
            return null;
        }

        CustomVo customVo = new CustomVo();

        customVo.setBirthday( Date2IntHandler.date2Int( dto.getBirthday() ) );
        if ( dto.getCustomA() != null ) {
            customVo.setCustomA( dto.getCustomA().name() );
        }
        customVo.setCustomB( enum2Int( dto.getCustomB() ) );
        customVo.setCustomC( enum2Int( dto.getCustomC() ) );

        customVo.setAll( enum2Int(dto.getCustomB()) + enum2Int(dto.getCustomA()) );

        return customVo;
    }

    @Override
    public CustomDto vo2dto(CustomVo vo) {
        if ( vo == null ) {
            return null;
        }

        CustomDto customDto = new CustomDto();

        customDto.setBirthday( Date2IntHandler.int2Date( vo.getBirthday() ) );
        if ( vo.getCustomA() != null ) {
            customDto.setCustomA( Enum.valueOf( CustomType.class, vo.getCustomA() ) );
        }
        customDto.setCustomB( int2Enum( vo.getCustomB() ) );
        customDto.setCustomC( int2Enum( vo.getCustomC() ) );

        return customDto;
    }
}

注意：

@mapping的属性，source 和 expression 不能同时定义，因为expression中使用了表达式。

Maper中定义的转换函数 ，会被自动应用到相同类型属性的转换上，可能会导致非期望结果。

mapper使用方式

1、接口注入方式

mapStruct接口类的声明

//使用@Mapper(componentModel = "spring") 整合
@Mapper(componentModel = "spring") 
public interface ItemInfoConvert {

}
//------------------------------------------------------
//调用：
//直接接口注入，方法调用即可
 @Autowired
 private ItemInfoConvert itemInfoConvert;
 Person person = itemInfoConvert.deliveryDO2DTO(cart);

2、静态方法调用

mapStruct接口类的声明

public interface ItemInfoConvert {
   //静态方法
    ItemInfoConvert INSTANCE = Mappers.getMapper(ItemInfoConvert.class);
}
//---------------------------------------------
//调用：
Person person= ItemInfoConvert.INSTANCE.deliveryDO2DTO(cart);
建议按以下方式使用
@Data
public class PersonDto {
    ......

    /**
     * 输入为null，输出则为null
     * 为什么名字为toVo0？其实类是支持重载（overload），但是在使用stream时，区分不了是想用实例方法，还是类方法。
     * @param dto
     * @return
     */
    public static PersonVo toVo0(PersonDto dto) {
        return PersonMapper.INSTANCE.dto2vo(dto);
    }

    public PersonVo toVo() {
        return PersonMapper.INSTANCE.dto2vo(this);
    }

    public static PersonDto from(PersonVo vo) {
        if (vo == null) {
            return null;
        }
        return PersonMapper.INSTANCE.vo2dto(vo);

    }
}
//------------------------------------
@Data
public class PersonVo {
... ... 


    public static PersonDto toDto0(PersonVo vo) {
        if (vo == null)
        {
            return null;
        }
        return PersonMapper.INSTANCE.vo2dto(vo);
    }

    public   PersonDto toDto(){
        return PersonMapper.INSTANCE.vo2dto(this);
    }

    public static PersonVo from(PersonDto dto){
        if (dto == null)
        {
            return null;
        }
        return PersonMapper.INSTANCE.dto2vo(dto);
    }
}

//------------------------------------
 public static void test0() {
        PersonDto dto1 = new PersonDto();
        dto1.setAge(10);
        dto1.setBirthday(Date.from(Instant.now()));
        dto1.setMoney(2.543D);
        dto1.setName("john");
        dto1.setSex("F");
        dto1.setPassword("password");
        dto1.setCreateTime(new Date());

        PersonDto dto2 = new PersonDto();
        dto2.setAge(20);
        dto2.setBirthday(Date.from(Instant.now()));
        dto2.setMoney(7.543D);
        dto2.setName("tom");
        dto2.setSex("M");
        dto2.setPassword("password");
        dto2.setCreateTime(new Date());

        List<PersonDto> list = Arrays.asList(dto1, null, dto2);

        //未考虑空引用
        List<PersonVo> list2 = list.stream().map(dto -> dto.toVo()).collect(Collectors.toList());
        //考虑了空引用
        List<PersonVo> list3 = list.stream().map(PersonDto::toVo0).collect(Collectors.toList());

    }
//------------------------------------

更多控制

见官方文档，可以实现：

  • 内嵌属性
  • collection，maps，list，stream等
  • defaultvalue等

问题总结

  1. 保证相同的数据结构，即参数的类型相同，同string 或者同Integer，类型不同无法转换

    Exception in thread "main" java.lang.NoSuchMethodError: demon.study.mapstruct.PersonVo.setBirthday(Ljava/util/Date;)V

    必须要使用@Mapping来解决此类问题。

  2. 避开关键字，比如：delete等

  3. 如果项目中也同时使用到了 Lombok，一定要注意 Lombok的版本要等于或者高于1.18.10，否则会有编译不通过的情况发生

注解说明

  • @Mapper：注解在接口、类上，这样 MapStruct 才会去实现该接口

    属性componentModel：该属性用于指定实现类的类型，有几个属性值：

    • default：默认，不使用任何组建类型，可以通过Mappers.getMapper(Class) 方式获取实例对象
    • spring：在实现类上注解 @Component，可通过 @Autowired 方式注入
    • jsr330：实现类上添加@javax.inject.Named 和@Singleton注解，可以通过 @Inject注解获取。

  • @Mappings：配置多个@Mapping

  • @Mapping：配置属性映射，若源对象属性与目标对象名字一致，会自动映射对应属性

    • source：源属性、target：目标属性
    • dateFormat：可将 String 到 Date 日期之间相互转换，通过 SimpleDateFormat，该值为 SimpleDateFormat 的日期格式
    • ignore: 忽略这个字段

精细控制

控制拷贝属性时，源字段为null时，是否覆盖目标对象。

@Mapper(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE,
nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)   //进行null 检查，如果为null，则不复制属性值。


nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_DEFAULT //赋值 默认值
nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE         //忽略，保持目标对象属性值

The strategy works in a hierarchical fashion. @Mapping#nullValueCheckStrategy will override @BeanMapping#nullValueCheckStrategy, @BeanMapping#nullValueCheckStrategy will override @Mapper#nullValueCheckStrategy and @Mapper#nullValueCheckStrategy will override @MaperConfig#nullValueCheckStrategy.

NullValuePropertyMappingStrategy also applies when the presence checker returns not present.

参考

  • MapStruct 官网：https://mapstruct.org/
  • MapStruct 官方文档：https://mapstruct.org/documentation/reference-guide/ ， https://mapstruct.org/documentation/1.3/reference/html/#expressions
  • MapStruct maven 地址：https://mvnrepository.com/artifact/org.mapstruct/mapstruct
  • MapStruct github 地址：https://github.com/mapstruct/mapstruct/
  • https://www.cnblogs.com/javaguide/p/11861749.html
demon7552003
关注
专栏目录
【微服务】springboot整合对象映射工具MapStruct使用详解
congge
08-25 3933
springboot 整合 MapStruct 使用详解
高性能实体类转换工具MapStruct 使用教程
CharlesYooSky的博客
07-26 1638
高性能实体类转换工具MapStruct 使用教程
MapStruct使用详解
hellozhxy的博客
11-18 1万+
阅读目录： 序 一、准备工作 1.1、了解@Mapper 注解 1.2、依赖包 二、先简单玩一把 2.1、定义实体类以及被映射类 2.2、定义接口： 2.3、使用 2.4、查看编译结果 2.5、浏览器查看结果 三、不简单的情况 3.1、类型不一致 3.2、字段名不一致 3.3、属性是枚举类型 源代码 阅读正文： 我们都知道，随着一个工程的越来越成熟，模块划分会越来越细，其中实体类一般存于 domain 之中，但 domain 工程最好不要被其他工
MapStruct系列（10）-注解汇总大全
记录知识、锤炼自我
04-15 5863
文章目录前言@Mapper@Mapping@Mappings@BeforeMapping @AfterMapping@BeanMapping@InheritConfiguration @InheritInverseConfiguration@IterableMapping@ValueMapping @ValueMappings@SubclassMapping @SubclassMappings@TargetType@Named@MapperConfig@EnumMapping@DecoratedWith@C
mapstruct
最新发布
weixin_46455069的博客
08-16 808
MapStruct 核心概念MapStruct是一个Java注解处理器，它的主要功能是自动生成类型安全、高性能且无依赖的bean映射代码。这个工具基于“约定优于配置”的原则，极大地简化了Java Bean类型之间的映射实现过程。在多层架构的应用中，经常需要在不同的对象模型之间进行转换，例如在持久层的实体和传输层的DTO（Data Transfer Object，数据传输对象）之间。手动编写这种映射代码是一项繁琐且容易出错的任务。
mapstruct学习及使用详解
qq_42191033的博客
08-19 1329
mapstruct正确使用、含大部分常用
MapStruct的使用详解与常见用法介绍
compellingMan的博客
08-03 1万+
mapstruct在当前轻量级框架开发中的重点使用，@Named注解使用示例，@AfterMapping与@BeforeMapping注解的详细常见用法，在转换DTO时，与过去常用的beanUtil转换有高性能的转换优势，编译期自动生成的mapper实现类能够更加优雅的来实现各种隐式类型转换，以实现快速而又敏捷的开发，告别臃肿的手动get、set与类型的强转......
Java编码辅助工具Mapstruct用法详解
08-25
Java编码辅助工具Mapstruct用法详解 Mapstruct是一个Java编码辅助工具，主要用于简化Java Bean之间的转换工作。通过使用Mapstruct框架，可以简洁方便地完成Bean之间的转换工作，免去了手动编码setter/getter的烦恼...
MapStruct详解及代码示例
06-06
MapStruct是一个Java注解处理器，可以帮助开发者快速生成Java Bean之间的映射代码。通过注解和代码生成，MapStruct能够自动映射两个Java Bean之间的属性。 下面是一个使用MapStruct的示例： 首先，在Maven项目中...
mapstruct使用详解
weixin_46244775的博客
12-08 489
我们都知道，随着一个工程的越来越成熟，模块划分会越来越细，其中实体类一般存于 domain 之中，但 domain 工程最好不要被其他工程依赖，所以其他工程想获取实体类数据时就需要在各自工程写 model，自定义 model 可以根据自身业务需要映射相应的实体属性。这样一来，这个映射工程貌似并不简单了。阿森差点就犯难了…… 回到顶部 序 所以阿淼今天就要给大家安利一款叫 mapstruct 的插件，它就是专门用来处理 domin 实体类与 model 类的属性映射的，我们只需定义 mapper 接口，map
MapStruct 一文读懂
zhouzhiwengang的专栏
10-21 3760
MapStruct是基于JSR269规范的一个Java注解处理器，用于为Java Bean生成类型安全且高性能的映射。它基于编译阶段生成get/set代码，此实现过程中没有反射，不会造成额外的性能损失。= null?}}}}}温馨提示：可以使用多个类有时需要在某些映射方法之前或之后应用自定义逻辑。MapStruct提供了两种方法：装饰器允许对特定映射方法进行类型安全的自定义，而映射前和映射后生命周期方法则允许对具有给定源或目标类型的映射方法进行通用的自定义。
Mapstruct的具体介绍
qq_41903500的博客
03-01 1105
官方文档往往是最好的学习参考资料官网地址要创建映射器，只需使用所需的映射方法定义一个 Java 接口，然后使用/*** 1. 用于像静态方式使用* 2. 用于spring方式注入使用*/@Mapper// 用于静态导入@Mapper(componentModel = "spring") //用于spring方式注入// 用于静态导入@Data@Builder@Data@Builder效果@Override。
MapStruct的基础用法详解
yqw1401的博客
09-20 9185
MapStruct 的一般理念是生成的代码看起来尽可能像您自己亲手编写的代码。特别是这意味着通过简单的 getter/setter 调用而不是反射或类似方法将值从源复制到目标。
秒懂Java之实体转化利器MapStruct详解
ShuSheng007的程序人生
01-12 1480
由于现代程序在追求扩展和维护性时很多采用分层的设计结构，所以在写程序时候需要在各种实体之间互相转换，而他们之间很多时候在业务或者技术架构上区别较大，在具体的属性上差别却很小。例如将Programer转换为由于这些是繁琐易错且没有技术含量的编码工作，所以聪明的程序员就会寻求不断简化它的方法，MapStruct就是其中的一个利器。MapStruct是一个用于Java的Bean的映射器，是它是基于注解的，而且是编译时APT（annotation processor tool）。
Java实体映射工具MapStruct使用详解
guanshengg的博客
08-26 1万+
通常在后端开发中经常不直接返回实体Entity类，经过处理转换返回前端，前端提交过来的对象也需要经过转换Entity实体才做存储；通常使用的BeanUtils.copyProperties方法也比较粗暴，不仅效率低下（使用反射）而且仅映射相同名的属性，多数情况下还需要手动编写对应的转换方法实现。 插件MapStruct以接口方法结合注解优雅实现对象转换，MapStruct生成器生成代码以更贴近原生的Setter、Getter方法处理属性映射更为高效...
mapstruct原理解析
begefefsef的博客
08-20 1689
mapstruct是一种实体类映射框架，能够通过Java注解将一个实体类的属性安全地赋值给另一个实体类。有了mapstruct，只需要定义一个映射器接口，声明需要映射的方法，在编译过程中，mapstruct会自动生成该接口的实现类，实现将源对象映射到目标对象的效果。
java 注解 map_java注解处理器之MapStruct
weixin_39980575的博客
02-13 817
介绍MapStruct是一个可以生成类型安全的，高性能的且无依赖的 JavaBean 映射代码的注解处理器，可以在编译期生成对应的mapping，既没有BeanUtils等工具使用反射的性能问题，又免去了自己写映射代码的繁琐。使用简单转换maven依赖org.mapstructmapstruct-jdk81.3.0.Finalorg.mapstructmapstruct-processor1.3....
mapstruct使用的正确姿势
热门推荐
Java学习之道
04-22 10万+
我们都知道，随着一个工程的越来越成熟，模块划分会越来越细，其中实体类一般存于 domain 之中，但 domain 工程最好不要被其他工程依赖，所以其他工程想获取实体类数据时就需要在各自工程写 model，自定义 model 可以根据自身业务需要映射相应的实体属性。这样一来，这个映射工程貌似并不简单了。阿森差点就犯难了…… 序　 所以阿淼今天就要给大家安利一款叫 mapstruct 的插件，它就...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值