mapstruct详解

于 2023-11-02 15:54:32 发布
阅读量179 收藏
点赞数
分类专栏： java排坑之路 文章标签： java 开发语言

目录

  • 没有提供对应的对象，自己实现，提高认识
  • 学习方式：最好是对class进行一个反编译，看看他生成的代码。如果发现一些类型没设置成功也可以通过反编译查看。
  • 反编译工具：java-decompiler
<!--导入的版本，参考官网-->
<dependency>
  <groupId>org.mapstruct</groupId>
  <artifactId>mapstruct</artifactId>
  <version>${org.mapstruct.version}</version>
</dependency>
<dependency>
  <groupId>org.mapstruct</groupId>
  <artifactId>mapstruct-processor</artifactId>
  <version>${org.mapstruct.version}</version>
</dependency>

映射器定义

// 测试方法，后续都是这样测试
@Test
void test() {
  BasicMapper instance = BasicMapper.INSTANCE;
	BasicUserDTO convert = instance.convert(user);
}

基本映射

  • 如果两个字段名称相同会自动映射。
  • 如果两个字段名称不相同则需要使用@Mapping进行映射，参考 - 从多个源对象映射
@Mapper
public interface BasicMapper {
  // 使用入口
  BasicMapper INSTANCE = Mappers.getMapper(BasicMapper.class);
  BasicUserDTO convert(BasicUser user);
}

自定义映射方法

// 接口方式
@Mapper
public interface BasicMapper {
  BasicMapper INSTANCE = Mappers.getMapper(BasicMapper.class);
  BasicUserDTO convert(BasicUser user);
  default PersonDTO convertCustom(BasicUser user) {
    return PersonDTO
             .builder()
             .id(String.valueOf(user.getId()))
             .firstName(user.getName().substring(0, user.getName().indexOf(" ")))
             .lastName(user.getName().substring(user.getName().indexOf(" ") + 1))
             .build();
  }
}

// 抽象类方式，好处：可以直接在映射器类中声明附加字段
@Mapper
public abstract class BasicMapper {

  public abstract BasicUserDTO convert(BasicUser user);

  public PersonDTO convertCustom(BasicUser user) {
    return PersonDTO
             .builder()
             .id(String.valueOf(user.getId()))
             .firstName(user.getName().substring(0, user.getName().indexOf(" ")))
             .lastName(user.getName().substring(user.getName().indexOf(" ") + 1))
             .build();
  }
}

从多个源对象映射

  • 当入参和返回的参数不匹配时，或者 有多个入参对象时，可以通过该方式指定需要映射到哪个字段
  • source：传入进来的参数
  • target：返回的参数
@Mapping(source = "user.id", target = "id")
@Mapping(source = "user.name", target = "firstName")
@Mapping(source = "education.degreeName", target = "educationalQualification")
@Mapping(source = "address.city", target = "residentialCity")
@Mapping(source = "address.country", target = "residentialCountry")
PersonDTO convert(BasicUser user, Education education, Address address);

映射嵌套对象

  • 当有嵌套对象时，可以采用@Mapper的uses指定一个嵌套对象对应的映射类
@Data
@Builder
@ToString
public class BasicUser {
  private int id;
  private String name;
  // 嵌套对象
  private List<Manager> managerList;
}

// 指定一个嵌套对象的映射类
@Mapper(uses = {ManagerMapper.class})
public interface UserMapper {
  UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);
  
  @Mapping(source = "user.id", target = "id")
  @Mapping(source = "user.name", target = "firstName")
  @Mapping(source = "education.degreeName", target = "educationalQualification")
  @Mapping(source = "address.city", target = "residentialCity")
  @Mapping(source = "address.country", target = "residentialCountry")
  PersonDTO convert(BasicUser user, Education education, Address address);
}
  • 在生成方法时，会通过指定的嵌套类对这个嵌套对象进行映射，如下所示
// 生成了一个managerListToManagerDTOList对嵌套类进行解析

更新现有实例

  • 使用映射更新现有的 DTO
  • 对需要更新的映射添加一个 @MappingTarget注解，就会对其进行更新
@Mapping(source = "address.city", target = "residentialCity")
@Mapping(source = "address.country", target = "residentialCountry")
void updateExisting(Address address, @MappingTarget PersonDTO personDTO);

// 生成了一个DTO
PersonDTO personDTO = UserMapper.INSTANCE.convert(address);
// 对这个personDTO进行了更新
UserMapper.INSTANCE.updateExisting(address,personDTO);

继承配置

  • 对于重复的配置，使用 @InheritConfiguration，MapStruct 会查找已配置的方法，并且进行应用
@Mapper
public interface ManagerMapper {
  ManagerMapper INSTANCE = Mappers.getMapper(ManagerMapper.class);
  // 故意吧这两个顺序弄反，在测试看是否生效
  @Mapping(source = "address.city", target = "residentialCountry")
	@Mapping(source = "address.country", target = "residentialCity")
  ManagerDTO convert(Manager manager);

  @InheritConfiguration
  void updateExisting(Manager manager, @MappingTarget ManagerDTO managerDTO);
}

逆映射

  • 想定义一个双向映射
    如：

    • Entity 映射 DTO
    • DTO 映射 Entity

  • 使用 @InheritInverseConfiguration 会自动的反转配

    @Mapper
public interface UserMapper {
 UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);
 // mapping的配置效果，也会被下面的反转映射所使用
 BasicUserDTO convert(BasicUser user);

 @InheritInverseConfiguration // 反转映射
 BasicUser convert(BasicUserDTO userDTO);
}

映射期间的异常处理

  • 自定义校检规则，映射期间如果发现跟校检的要求不匹配，则抛出异常（自定义）
  • 步骤：

    • 自定义异常

      public class ValidationException extends RuntimeException {

  public ValidationException(String message, Throwable cause) {
    super(message, cause);
  }

  public ValidationException(String message) {
    super(message);
  }
}

    • 自定义校检规则

      • 方法名要求：validate字段名(字段类型)
      • 注意事项：校检的字段类型要和形参以及异常进行匹配，否则的话匹配不到则不会生效
      public class Validator {
  public int validateId(int id) throws ValidationException {
    if(id < 0){
      throw new ValidationException("Invalid ID value");
    }
    return id;
  }
}

    • 使用

      // 导入校检规则
@Mapper(uses = { Validator.class})
public interface UserMapper {
  UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);
  // 抛出对应的异常
  BasicUserDTO convert(BasicUser user) throws ValidationException;

}

数据类型转换

隐式类型转换

  • 数值

    @Mapping(source = "employment.salary",
         target = "salary",
         numberFormat = "$#.00") 
PersonDTO convert(BasicUser user,
                  Education education,
                  Address address,
                  Employment employment);
// 会自动转换，如下：
personDTO.setSalary( new DecimalFormat( "$#.00" ).format(
                employment.getSalary() ) );

  • 日期

    @Mapping(source = "dateOfBirth",
         target = "dateOfBirth",
         dateFormat = "dd/MMM/yyyy") 
ManagerDTO convert(Manager manager);

// 会自动转换，如下：
managerDTO.setDateOfBirth(
    new SimpleDateFormat( "dd/MMM/yyyy" )
    .parse( manager.getDateOfBirth() ) );

// 如果没自定义转换, 则生成如下：
managerDTO.setDateOfBirth( new SimpleDateFormat().parse(
    manager.getDateOfBirth() ) );

映射集合

  • 通过循环遍历，进行映射。

  • 如果使用了@Mapping的uses则会自动调用此对应的映射方法来执行元素转换。

  • 简单使用

    @Mapper
public interface CollectionMapper {
  CollectionMapper INSTANCE = Mappers.getMapper(CollectionMapper.class);

  Set<String> convert(Set<Long> ids);
  
  Set<EmploymentDTO> convertEmployment(Set<Employment> employmentSet);
}

  • 需要对实体进行自定义映射，则需要先定义实体之间的转换方法。

    @Mapper
public interface CollectionMapper {
  CollectionMapper INSTANCE = Mappers.getMapper(CollectionMapper.class);
	
  // 自定义映射
  @Mapping(source = "degreeName", target = "degree")
  @Mapping(source = "institute", target = "college")
  @Mapping(source = "yearOfPassing", target = "passingYear")
  EducationDTO convert(Education education);
  // 会去匹配自定义映射进行转换
  List<EducationDTO> convert(List<Education> educationList);
}

// 会生成如下代码：
educationDTO.degree( education.getDegreeName() );
educationDTO.college( education.getInstitute() );
educationDTO.passingYear( education.getYearOfPassing() );

  • 对map进行映射

    • 可以通过 keyNumberFormat 和 valueDateFormat 对转入的键值做一个转换
      @Mapper
public interface CollectionMapper {
  CollectionMapper INSTANCE = Mappers.getMapper(CollectionMapper.class);

  @MapMapping(keyNumberFormat = "#L", valueDateFormat = "dd.MM.yyyy")
  Map<String, String> map(Map<Long, Date> dateMap);
}

// 生成如下代码：
String key = new DecimalFormat( "#L" ).format( entry.getKey() );
String value = new SimpleDateFormat( "dd.MM.yyyy" ).format( entry.getValue() );

映射策略

  • 默认值为 ACCESSOR_ONLY
    // 使用ADDER_PREFERRED策略
@Mapper(collectionMappingStrategy = CollectionMappingStrategy.ADDER_PREFERRED)
public interface PersonMapperAdderPreferred {
  PersonDTO map(Person person);
}

映射流

  • 和映射集合相同，只是 Stream会从提供的返回 Iterable：
    @Mapper
public interface CollectionMapper {
  CollectionMapper INSTANCE = Mappers.getMapper(CollectionMapper.class);

  Set<String> convertStream(Stream<Long> ids);

  @Mapping(source = "degreeName", target = "degree")
  @Mapping(source = "institute", target = "college")
  @Mapping(source = "yearOfPassing", target = "passingYear")
  EducationDTO convert(Education education);
  List<EducationDTO> convert(Stream<Education> educationStream);
}

// 生成如下：
return ids.map( long1 -> String.valueOf( long1 ) )
  .collect( Collectors.toCollection( HashSet<String>::new ) );

映射枚举

  • 名字相同，则直接映射即可
  • 名字不相同，使用 @ValueMapping进行映射,无法识别源值，抛出 IllegalStateExceptio
  • 如果有前缀，则使用如下4个属性进行映射
    • suffix- 在源枚举上应用后缀
    • stripSuffix- 从源枚举中去除后缀
    • prefix- 在源枚举上应用前缀
    • stripPrefix- 从源枚举中去除前缀
    public enum DegreeStream {MATHS}
public enum DegreeStreamPrefix {MSC_MATHS}


@Mapper
public interface UserMapper {
  UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);
        
  @EnumMapping(nameTransformationStrategy = "prefix", configuration = "MSC_")
  DegreeStreamPrefix convert(DegreeStream degreeStream);

  @EnumMapping(nameTransformationStrategy = "stripPrefix", configuration = "MSC_")
  DegreeStream convert(DegreeStreamPrefix degreeStreamPrefix);
}

定义默认值或常量

  • defaultValue：当值不存在时，则使用默认值
  • constant：映射到目标枚举类型中具有相同名称的常量
@Mapper(collectionMappingStrategy = CollectionMappingStrategy.ADDER_PREFERRED,
        uses = {CollectionMapper.class, ManagerMapper.class, Validator.class},
        imports = UUID.class )
public interface UserMapper {
  UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);

  @Mapping(source = "education.yearOfPassing", target = "education.passingYear",
           defaultValue = "2001")
  @Mapping(source = "employment", target = ".")
  @Mapping(target = "residentialCountry", constant = "US")
  PersonDTO convert(BasicUser user,
                    Education education,
                    Address address,
                    Employment employment);
}

定义默认表达式

  • 用于使用java表达式
  • 在源属性为 null时使用，才会触发。
  • 还需要导入对应的类
    @Mapper( imports = UUID.class )
public interface UserMapper {
  UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);

  @Mapping(source = "user.id", target = "id",
           defaultExpression = "java( UUID.randomUUID().toString() )")
  PersonDTO convert(BasicUser user,
                    Education education,
                    Address address,
                    Employment employment);
}

映射器检索策略

  • 不使用依赖注入框架，使用 Mappers获取映射器实例
    @Mapper
public interface UserMapper {
  UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);
}
// 使用
PersonDTO personDTO = UserMapper.INSTANCE.convert(user);
  • 使用 @componentModel注解导入依赖注入
    • 支持CDI和Spring框架
      @Mapper(componentModel = "spring")
public interface UserMapper {}

// 生成如下：
@Component
public class UserMapperImpl implements UserMapper {}

// 使用
@Controller
public class UserController() {
  @Autowired
  private UserMapper userMapper;
}

映射定制

  • 使用装饰器模式，进行自定义
  • 使用 @BeforeMapping / @AfterMapping，进行通用的设置

装饰器

  • 定义一个Decorator类，在使用 @DecoratedWith使其生效
  • 对需要自定义映射的方法进行实现，其他的方法用默认实现生成对原始映射器的委托。
public abstract class UserMapperDecorator implements UserMapper {

  private final UserMapper delegate;

  protected UserMapperDecorator (UserMapper delegate) {
      this.delegate = delegate;
  }

  @Override
  public PersonDTO convert(BasicUser user,
                           Education education,
                           Address address,
                           Employment employment) {
    // 委托
    PersonDTO dto = delegate.convert(user, education, address, employment);
    if (user.getName().split("\\w+").length > 1) {
       dto.setFirstName(user.getName().substring(0, user.getName().lastIndexOf(' ')));
       dto.setLastName(user.getName().substring(user.getName().lastIndexOf(" ") + 1));
     }
     else {
        dto.setFirstName(user.getName());
     }
     return dto;
  }
}

// 使用
@Mapper
@DecoratedWith(UserMapperDecorator.class)
public interface UserMapper {
  UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);
    
  PersonDTO convert(BasicUser user, Education education, Address address, Employment employment);
}

@BeforeMapping和@AfterMapping

  • @BeforeMapping用于执行前，运行指定的逻辑
  • @AfterMapping用于执行后，运行指定的逻辑
@Mapper
@DecoratedWith(UserMapperDecorator.class)
public interface UserMapper {
  UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);

  // 执行前, 如果manager为null则设置一个空集合
  @BeforeMapping
  default void validateMangers(BasicUser user) {
    if (Objects.isNull(user.getManagerList())) {
       user.setManagerList(new ArrayList<>());
    }
  }

  @Mapping(target = "residentialCountry", constant = "US")
  void updateExisting( Address address );

  // 执行后，对firstName和LastName进行一个字符转换
  @AfterMapping
  default void updateResult(BasicUser user, 
                            @MappingTarget PersonDTO personDTO) {
      personDTO.setFirstName(personDTO.getFirstName().toUpperCase());
      personDTO.setLastName(personDTO.getLastName().toUpperCase());
  }
}

reflectoring.io-> 文章
官网

离别又见离别
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java编码辅助工具Mapstruct用法详解
08-25
主要介绍了Java编码辅助工具Mapstruct用法详解，手动编码setter/getter各个对应属性，会显得臃肿繁琐。通过Mapstruct框架可简单方便地完成这一工作。,需要的朋友可以参考下
MapStruct的基础用法详解
yqw1401的博客
09-20 8688
MapStruct 的一般理念是生成的代码看起来尽可能像您自己亲手编写的代码。特别是这意味着通过简单的 getter/setter 调用而不是反射或类似方法将值从源复制到目标。
MapStruct的使用详解与常见用法介绍
compellingMan的博客
08-03 1万+
mapstruct在当前轻量级框架开发中的重点使用，@Named注解使用示例，@AfterMapping与@BeforeMapping注解的详细常见用法，在转换DTO时，与过去常用的beanUtil转换有高性能的转换优势，编译期自动生成的mapper实现类能够更加优雅的来实现各种隐式类型转换，以实现快速而又敏捷的开发，告别臃肿的手动get、set与类型的强转......
秒懂Java之实体转化利器MapStruct详解
ShuSheng007的程序人生
01-12 1288
由于现代程序在追求扩展和维护性时很多采用分层的设计结构，所以在写程序时候需要在各种实体之间互相转换，而他们之间很多时候在业务或者技术架构上区别较大，在具体的属性上差别却很小。例如将Programer转换为由于这些是繁琐易错且没有技术含量的编码工作，所以聪明的程序员就会寻求不断简化它的方法，MapStruct就是其中的一个利器。MapStruct是一个用于Java的Bean的映射器，是它是基于注解的，而且是编译时APT（annotation processor tool）。
Java实体映射工具MapStruct使用详解
guanshengg的博客
08-26 8770
通常在后端开发中经常不直接返回实体Entity类，经过处理转换返回前端，前端提交过来的对象也需要经过转换Entity实体才做存储；通常使用的BeanUtils.copyProperties方法也比较粗暴，不仅效率低下（使用反射）而且仅映射相同名的属性，多数情况下还需要手动编写对应的转换方法实现。 插件MapStruct以接口方法结合注解优雅实现对象转换，MapStruct生成器生成代码以更贴近原生的Setter、Getter方法处理属性映射更为高效...
mapstruct学习及使用详解
qq_42191033的博客
08-19 887
mapstruct正确使用、含大部分常用
详解Go开发Struct转换成map两种方式比较
09-20
本篇文章主要介绍了详解Go开发Struct转换成map两种方式比较，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
hash_map的详解
02-10
关于hash_map的用法与解释： #include <hash_map> #include #include using namespace std; //define the class class ClassA{ public: ClassA(int a):c_a(a){} int getvalue()const { return c_a;} void ...
基于C++ map中key使用指针问题的详解
01-01
C++实际开发的过程会经常使用到map。map是一个key-value值对，key唯一，可以用find进行快速的查找。其时间复杂度为O(logN)，如果采用for循环进行遍历...本文讨论的是map中存储的数据结构struct情况。1、如果map中的key
Go语言用map实现堆栈功能的方法
12-31
type Stack struct {  quenu map[int]int } func New() *Stack{  s := new(Stack)  s.quenu = make(map[int]int)  return s } func (s *Stack) Push(i int) {  s.quenu[len(s.quenu)] = i } func (s *Stack) P
Mapstruct的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
01-12 2万+
mapstruct是一种实体类映射框架，能够通过Java注解将一个实体类的属性安全地赋值给另一个实体类。有了mapstruct，只需要定义一个映射器接口，声明需要映射的方法，在编译过程中，mapstruct会自动生成该接口的实现类，实现将源对象映射到目标对象的效果。在实体类下面创建即可，方便查找。
mapstruct 之 类型转换
大杂烩
09-18 1万+
参考链接：mapstruct的基本使用 背景介绍 是不是有时候发现明明source和target不是同一个类型，但是却转换成功了，这是因为mapstruct有一套自己的类型转换机制 类型转换的流程 首先尝试自动进行类型转换 若是无法支持的类型转换，则是尝试调用已经存在的类型转换方法 不存在可用的方法则是尝试自己创建一个类型转换方法 类型转换分类 自动转换 以下的类型之间是mapstruct自动...
MapStruct系列（5）-映射器数据类型转换详解
记录知识、锤炼自我
04-14 1万+
数据类型转换 源对象和目标对象中的映射属性并不总是具有相同的类型。例如，属性可能int属于源 bean 中的类型Long，但属于目标 bean 中的类型。 MapStruct 如何处理此类数据类型转换的呢？ 1. 隐式类型转换 在许多情况下，MapStruct 会自动处理类型转换。例如，如果源 bean 中一个属性类型为int，但在目标 bean 中属于String类型，则生成的代码将分别通过调用String#valueOf(int)和Integer#parseInt(String)透明地执行转换。 目前支
原型对象prototype和对象实例的__proto__属性
cake_eat的博客
09-26 1052
原型对象 我们创建的每个函数都有一个 prototype（原型）属性，这个属性是一个指针，指向一个对象， 而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。如果按照字面意思来理解，那 么 prototype 就是通过调用构造函数而创建的那个对象实例的原型对象。使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。换句话说，不必在构造函数中定义对象实例的信息，而是 可以将这些信息直接添加到原型对象中。 对象的__proto__属性 Firefox、Safari 和 Chrome 在每个
mapstruct使用详解
浮生未歇的博客
07-29 2587
概述 MapStruct 是一个代码生成器，它基于约定优于配置方法极大地简化了 Java bean 类型之间映射的实现。生成的映射代码使用简单的方法调用，因此速度快、类型安全且易于理解。 为什么使用它？ 多层应用程序通常需要在不同的对象模型（例如实体和 DTO）之间进行映射。编写这样的映射代码是一项乏味且容易出错的任务。MapStruct 旨在通过尽可能自动化来简化这项工作。 与其他映射框架相比，MapStruct 在编译时生成 bean 映射，以确保高性能，允许快速的开发人员反馈和彻底的错误检查。
MapStruct实体间转换快速入门
水煮三国的博客
04-09 239
https://blog.csdn.net/lx_yoyo/article/details/75061614
MapStruct 详解
热门推荐
chenshun123的博客
10-27 3万+
GitHub 访问地址 : https://github.com/mapstruct/mapstruct/ 使用例子 : https://github.com/mapstruct/mapstruct-examples   MapStrcut与其它工具对比以及使用说明 : http://www.tuicool.com/articles/uiIRjai   BeanUtils.copyPro...
MapStruct学习笔记
SIMBA1949的博客
09-11 1186
MapStruct学习笔记 前言 版本说明 mapstruct = 1.3.1.Final 相关链接： MapStruct 官网：https://mapstruct.org/ MapStruct 官方文档：https://mapstruct.org/documentation/reference-guide/ MapStruct maven 地址：https://mvnrepository.com/artifact/org.mapstruct/mapstruct MapStruct github 地址：
MapStruct详解及代码示例
最新发布
06-06
MapStruct是一个Java注解处理器，可以帮助开发者快速生成Java Bean之间的映射代码。通过注解和代码生成，MapStruct能够自动映射两个Java Bean之间的属性。 下面是一个使用MapStruct的示例： 首先，在Maven项目中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值