MapStruct的使用详解与常见用法介绍

已于 2022-08-03 17:47:12 修改
阅读量1.1w 收藏 60
点赞数 13
分类专栏： mapStruct 文章标签： java
于 2022-08-03 17:45:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/compellingMan/article/details/126144301
版权

项目转换DTO使用总结，常用技巧

概要

mapstruct在当前轻量级框架开发中的重点使用，@Named注解使用示例，@AfterMapping与@BeforeMapping注解的详细常见用法，在转换DTO时，与过去常用的beanUtil转换有高性能的转换优势，编译期自动生成的mapper实现类能够更加优雅的来实现各种隐式类型转换，以实现快速而又敏捷的开发，告别臃肿的手动get、set与类型的强转

引入

当前core-service引入版本如下

<properties>
    <mapstruct.version>1.2.0.Final</mapstruct.version>
</properties>
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-jdk8</artifactId>
    <version>${mapstruct.version}</version>
</dependency>
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>${mapstruct.version}</version>
</dependency>
基本使用
  • 使用@Mapper注解，声明映射器，可以是接口，或者抽象类
  • 使用@Mapping注解，实现灵活的字段映射，定制映射的规则
注入方式
  • 工厂方式
@Mapper
public interface ItemMapper {
    //使用工厂方法获取Mapper实例
    ItemMapper INSTANCE = Mappers.getMapper(ItemMapper.class);
    ItemDTO toDTO(Item item);
}
  • 依赖注入方式
@Mapper(componentModel = "spring")
public interface ItemMapper {
    ItemDTO toDTO(Item item);
}
简单映射

代码可以自动生成的Mapper接口，可以自动转换相同属性的字段，无需其他声明。

@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface AwardMapper extends BaseMapper<AwardDTO, Award> {

}

需要注意的是：再不写任何转换代码的情况下，如果实体类中配置了其他关联的一对多或一对一的实体，DTO如果同样需要转换的话，就需要保证属性名一致才能正常转换。

自动类型转换

对于基础数据类型会进行自动隐式的转换如int、long、String，Integer、Long等；

//生成的实现类代码可以看出来
@Component
public class AssemblerImpl implements Assembler {
    @Override
    public ProductDTO toDTO(Product product) {
        if ( product == null ) {
            return null;
        }
        ProductDTO productDTO = new ProductDTO();
        if ( product.getProductId() != null ) {
            //String自动转int
            productDTO.setProductId( Integer.parseInt( product.getProductId() ) );
        }
        if ( product.getPrice() != null ) {
            //Long转String
            productDTO.setPrice( String.valueOf( product.getPrice() ) );
        }
        return productDTO;
    }
}
指定格式转换

查看mapping注解可以看到

@Retention(RetentionPolicy.CLASS)
@Target({ElementType.METHOD})
public @interface Mapping {
    String target();

    String source() default "";

    String dateFormat() default "";

    String numberFormat() default "";
    
    ...
}

dateFormat与numberFormat即可用来进行转换操作

  • dateFormat用于日期格式转换
@Mapper(componentModel = "spring")
public interface Demo4Assembler {
    @Mapping(target = "saleTime", dateFormat = "yyyy-MM-dd HH:mm:ss")  //Date转换成String
    @Mapping(target = "validTime", dateFormat = "yyyy-MM-dd HH:mm")    //String转换成Date
    ProductDTO toDTO(Product product);
}
  • 日期格式转换可以直接在DTO中注解形式转换，比mapper更为便捷
	// 活动开始时间
	@JsonFormat(pattern = "yyyy/MM/dd HH:mm:ss",timezone="GMT+8")
	private Timestamp startTime;
	
	// 活动结束时间
	@JsonFormat(pattern = "yyyy/MM/dd HH:mm:ss",timezone="GMT+8")
	private Timestamp endTime;
  • numberFormat用于数字格式转换【不常用】
   private String price;
   private Integer stock;
	@Mapper(componentModel = "spring")
	public interface Demo3Assembler {
    @Mapping(target = "price", numberFormat = "#.00元") 
    @Mapping(target = "stock", numberFormat = "#个") 
    ProductDTO toDTO(Product product);
}
不同参数映射
  • 基本不同属性名转换，需要使用@Mappings注解进行指定转换，参数为数组，支持多个字段转换
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface DrawRecordDetailMapper extends BaseMapper<DrawRecordDetailDTO, DrawRecord> {
    @Override
    @Mappings({
            @Mapping(target = "chanceId", source = "participationChanceId")
    })
    DrawRecordDetailDTO toDto(DrawRecord entity);

}
  • 对象属性提取和普通属性装载对象中
//将entity中activity实体中name属性装载至DrawRecordDetailDTO中activityName属性上
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface DrawRecordDetailMapper extends BaseMapper<DrawRecordDetailDTO, DrawRecord> {

    @Override
    @Mappings({
            @Mapping(target = "activityName", source = "activity.name")
    })
    DrawRecordDetailDTO toDto(DrawRecord entity);   
}

//将entity中活动规则属性，转换至ActivityDetailDTO中activityRule对象中
	@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
	public interface ActivityDetailMapper extends BaseMapper<ActivityDetailDTO, Activity> {
	    @Override
	    @Mappings({
	            @Mapping(target = "activityRule.voteOverlapAvailable", source = "voteOverlapAvailable"),
	            @Mapping(target = "activityRule.voteMultipleOnceAvailable", source = 		                                    "voteMultipleOnceAvailable")
	    })
    ActivityDetailDTO toDto(Activity entity);
}
自定义转换器
  • 基础映射方式，mapper接口中直接引入即可（对数据接口要求高）

一个自定义映射器可以定义多个映射方法，匹配时，是以方法的入参和出参进行匹配的

如果绑定的映射中，存在多个相同的入参和出参方法，将会报错

使用样例：将list中多个code在映射时，转换为String用逗号隔开

定义映射器：

@Component
public class MediaServiceFormater {
    public String format(List<String> serviceCodeList) {
        return String.join(",", serviceCode);
    }
}

mapper接口绑定映射器 【uses = {MediaServiceFormater.class}】

@Mapper(componentModel = "spring", uses = {MediaServiceFormater.class,unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MediaDetailMapper extends BaseMapper<MediaDetailDTO, Media> {

}
  • 基于named注解实现【常用】

映射器中使用注解来定义转换方法，使用时，具体属性绑定方法；

定义映射器：

@Component
public class MapStructConverterUtil {
    private static final Logger log = LoggerFactory.getLogger(MapStructConverterUtil.class);

    public MapStructConverterUtil() {
    }

    @Named("getNormalImage")
    public String getNormalImage(String images) {
        if (StringUtils.isEmpty(images)) {
            return null;
        } else {
            try {
                if (images.contains("normal")) {
                    JSONObject imageJson = JSON.parseObject(images);
                    JSONObject mapJson = imageJson.getJSONObject("map");
                    JSONArray normalJson = mapJson.getJSONArray("normal");
                    Integer index = normalJson.getInteger(0);
                    JSONObject object = imageJson.getJSONArray("list").getJSONObject(index);
                    return object.getString("fileUrl");
                }
            } catch (Exception var7) {
                log.error("normal图片解析出错，原images = [{}]", images);
            }

            return null;
        }
    }
  }

使用时绑定映射器：【uses = {MapStructConverterUtil.class}】

@Mapper(componentModel = "spring", uses = {MapStructConverterUtil.class}, unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface ActivityUserDetailMapper extends BaseMapper<ActivityUserDetailDTO, Activity> {

    @Override
    @Mappings({
            @Mapping(target = "img1", source = "images", qualifiedByName = "getNormalImage"),
            @Mapping(target = "img2", source = "images", qualifiedByName = "getBgImage"),
            @Mapping(target = "img3", source = "images", qualifiedByName = "getPosterImage")
    })
    ActivityUserDetailDTO toDto(Activity entity);

}
  • Map映射

mapStruct还支持map集合的转换，可以对map进行隐式转换，支持对Key与value进行隐式转换

例如：日期转字符串，字符串转日期；同样支持@name注解转换形式，或使用qualifiedBy指定一个转换类（类中默认使用相同入参出参来匹配）

@Mapper(componentModel = "spring", uses = {ConverterUtil.class}, unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface SourceTargetMapper {
   @MapMapping(keyQualifiedByName = "getValue", valueDateFormat = "dd.MM.yyyy")
   Map<String, String> longDateMapToStringStringMap(Map<Long, Date> source);
}
复杂映射实现

多个字段映射到一个字段，单个字段快速特殊处理

  • 自定义字段表达式映射
    • 单个字段特殊转换处理
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface GroupDetailOrderMapper extends BaseMapper<GroupDetailOrderDTO, GroupDetailOrder> {

    @Override
    @Mappings({
            @Mapping(target = "userName", expression = "java(entity.getUserName() == null ? \"\" : new String(java.util.Base64.getDecoder().decode(entity.getUserName()), java.nio.charset.StandardCharsets.UTF_8))")
    })
    GroupDetailOrderDTO toDto(GroupDetailOrder entity);
}
  • 多个字段处理为一个字段
@Mapper(componentModel = "spring", imports = DecimalUtils.class) 
public interface Demo16Assembler {
    @Mapping(target = "price", expression = "java(product.getPrice1() + product.getPrice2())") 
    @Mapping(target = "price2", expression = "java(DecimalUtils.add(product.getPrice1(), product.getPrice2()))") 
    ProductDTO toDTO(Product product);
}
  • 前后置处理实现复杂映射

使用@BeforeMapping与@AfterMapping注解来实现，需要定义默认方法在mapper接口中【java8后支持】

使用前注意：

​ 在调用上下文上的映射方法之前/之后，不执行空检查参数。调用方需要确保在这种情况下不传递null；

@Mapper(componentModel = “spring”, uses = {MapStructConverterUtil.class, MediaConverterUtil.class}, unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MediaDetailMapper extends BaseMapper<MediaDetailDTO, Media> {

 	//前置执行
    @BeforeMapping 
    default MediaDetailDTO setMediaName(Media media) {
        MediaDetailDTO mediaDetailDTO = new MediaDetailDTO();
        mediaDetailDTO.setName("默认名称");
        return mediaDetailDTO;
    }
    
    @Override
    @Mappings({
            @Mapping(target = "img1", source = "images", qualifiedByName = "getNormalImage"),
            @Mapping(target = "img2", source = "images", qualifiedByName = "getBgImage"),
            @Mapping(target = "img3", source = "images", qualifiedByName = "getPosterImage"),
            @Mapping(target = "cp", source = "contentProviderId", qualifiedByName = "getCP"),
            @Mapping(target = "audioTrack", source = "audioDescription")
    })
    MediaDetailDTO toDto(Media media);

	 //后置执行
    @AfterMapping
    default void setMediaType(@MappingTarget MediaDetailDTO mediaDetailDTO, Media media) {
        Integer type = media.getType();
        Integer contentType = media.getContentType();
        String contentTyp = String.format("%02d", contentType);
        mediaDetailDTO.setMediaType(type + contentTyp);
    }
}
隐式映射实现

利用继承关系，继承mapper自动生成的实现类，来重写增强

此转换方式，同样可以实现在dto转换后后置执行，实体真正实现类中代码简洁也较为优雅

需要注意的是，一定要先实现父类转换方法拿到结果后在进行后续增强转换

super.toDto(entity)
实现样例如下：

//实现类引入方式使用@Resource注解引入
 @Autowired
 @Resource(name = "activityDetailMapperImplPlus")
 private ActivityDetailMapper activityDetailMapper;

@Component("activityDetailMapperImplPlus")
@RequiredArgsConstructor
public class ActivityDetailMapperImplPlus extends ActivityDetailMapperImpl {

    private final VoteTargetRepository voteTargetRepository;

    @Override
    public ActivityDetailDTO toDto(Activity entity) {
        ActivityDetailDTO activityDetailDTO = super.toDto(entity);
        
        Long activityDetailDTOId = activityDetailDTO.getId();
        Integer type = activityDetailDTO.getType();
        boolean vote = LocalActConstant.ACT_TYPE_VOTE == type;
        if (vote) {
            Optional<List<VoteTarget>> voteOp = this.voteTargetRepository.findByActivityIdAndStatus(activityDetailDTOId, 1);
            if (voteOp.isPresent()) {
                List<VoteTarget> voteTargets = voteOp.get();
                //累积投票
                activityDetailDTO.setTotalVoteNum(voteTargets.stream()
                        .filter(voteTarget -> voteTarget.getCurrentNumber() != null)
                        .mapToInt(VoteTarget::getCurrentNumber).sum());
            }
        }
        return activityDetailDTO;
    }
}

隐式转换扩展

如果实体类中，关联了其他一对多或多对多的引用类型，JPA在mapper层自动转换后，又需要对引用对象增加出参或出参数据结构转换时，这时候利用转换生成是实现类继承强化后，再绑定到mapper中即可。这样就无需在接口实现层进行循环处理

使用样例如下：

MarketingActivityDetailDTO中有 private List registrationEvents;

需要在BaseRegistrationEventDTO对象中增加出参

//报名人数
private Long totalRegister;
接口侧转换使用的MarketingActivityDetailMapper接口如下:引用必须要包含RegistrationEventSimpleMapperImplPlus.class

uses = {MapStructConverterUtil.class, TemplateParamValueMapper1.class, RegistrationEventSimpleMapperImplPlus.class}

@Mapper(componentModel = "spring", uses = {MapStructConverterUtil.class, TemplateParamValueMapper1.class, RegistrationEventSimpleMapperImplPlus.class}, unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface MarketingActivityDetailMapper extends BaseMapper<MarketingActivityDetailDTO, MarketingActivity> {

    @Override
    @Mappings({
            @Mapping(target = "img1", source = "images", qualifiedByName = "getNormalImage"),
            @Mapping(target = "img2", source = "images", qualifiedByName = "getBgImage"),
            @Mapping(target = "img3", source = "images", qualifiedByName = "getPosterImage")
    })
    MarketingActivityDetailDTO toDto(MarketingActivity entity);
}

RegistationEventSimpleMapper如下

@Component("registrationEventSimpleMapperImplPlus")
@RequiredArgsConstructor
public class RegistrationEventSimpleMapperImplPlus extends RegistrationEventSimpleMapperImpl {
    private final UserRegistrationRepository userRegistrationRepository;
    @Override
    public BaseRegistrationEventDTO toDto(RegistrationEvent entity) {
        BaseRegistrationEventDTO baseRegistrationEventDTO = super.toDto(entity);
        Long registrationEventId = baseRegistrationEventDTO.getId();
      baseRegistrationEventDTO.setTotalRegister(
         this.userRegistrationRepository.countByRegistrationEventId(registrationEventId));
        return baseRegistrationEventDTO;
    }
}
compellingMan
关注
  • 13
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
MapStruct使用教程2024(高级版)
码到三十五
11-04 1万+
MapStruct是一个用于Java的代码生成库，它基于注解处理器在编译时生成类型安全且高性能的对象映射代码,MapStruct可以帮助开发者减少手动编写繁琐的JavaBean之间的转换代码，提高代码的可读性和维护性。
【开发规范】Mapstruct 转换器使用教程
JAVA开发区的博客
04-17 1668
MapStruct是一个代码生成器，它基于约定优于配置的方法，极大地简化了Java bean类型之间的映射实现。生成的映射代码使用普通的方法调用，因此速度快、类型安全且易于理解。MapStruct是一种注释处理器，可插入 Java 编译器，并可用于命令行构建（MavenGradle等）以及您喜欢的集成开发环境。MapStruct使用合理的默认设置，但在需要配置或实施特殊行为时，MapStruct会自动退出。
MapStruct的用法总结及示例
最新发布
小蜜蜂1010的博客
06-10 1576
比dozer更好用的java对象属性映射复制工具MapStuct的用法及代码示例
【转】MapStruct 用法
魂-淡
08-30 2266
org.mapstruct:mapstruct，它是专门用来处理 domin 实体类与 model 类的属性映射的
MapStruct使用及常用方式示例
qq_45105233的博客
12-21 2219
1.Mapstruct是实体类的映射框架，可以直接通过Java注解将一个实体类的属性高效的赋值给另一个实体类。2.实体类映射框架从实现原理上看大致可以分为两种，一种是基于反射动态映射实现(BeanUtils)，另一种就是基于编译期动态生成getter/setter(Mapstruct)./** * 映射. */ EntiyConverter INSTANCE = Mappers.getMapper(EntiyConverter.class);
关于MapStruct的使用
ABestRookie的博客
06-25 1503
mapstruct,全称是org.mapstruct.Mapper, 是将接口或抽象类标记为映射器，并通过MapStruct为这个接口或者抽象类生成一个实现类,大大简化了Java bean类型之间转换.优点:mapstruct是在编译时完成Bean转换,1 和传统相比,提升了服务性能2 编译后在target目录，生成对应的xxximp.java文件,方便定位问题缺点:1 必须添加一个接口或者抽象类，才能实现映射通过mapstruct的使用发现,和之前工具类的映射有很多不同.
MapStruct - 详细使用（一篇解决MapStruct ）
qq_65377318的博客
06-08 2588
mapstruct是一种实体类映射框架，能够通过Java注解将一个实体类的属性安全地赋值给另一个实体类。有了mapstruct，只需要定义一个映射器接口，声明需要映射的方法，在编译过程中，mapstruct会自动生成该接口的实现类，实现将源对象映射到目标对象的效果。.........
java mapstruct详解_java常用API -FILE+MapStruct
weixin_29334463的博客
02-24 416
java常用API -FILE+MapStructFILE文件上传原理解析FileItem解析DiskFileItemFactory解析默认的FileItemFactory实现此实现 创建FileItem实例，并将较小的items保存在内存中，将较大的items缓存到磁盘上的临时文件存储到磁盘上内容的大小阈值和创建临时文件的目录都是可以配置的如果没有配置，默认配置值如下：3.1 大小阈值为10KB...
MapStruct系列（7）-对象工厂
记录知识、锤炼自我
04-14 1005
文章目录前言1. 自定义对象工厂2. 具有更新方法的自定义对象工厂3. @ObjectFactory 前言 默认情况下，用于将类型映射到另一种类型时生成代码将调用默认构造函数来实例化目标类型。 我们可以使用自定义对象工厂来获取目标类型实例。 1. 自定义对象工厂 自定义对象工厂，创建对象。 public class EntityFactory { public <T extends BaseEntity> T createEntity(@TargetType Class<T&g
MapStruct
weixin_46061449的博客
10-16 132
MapStruct是用于生成类型安全的bean映射类的Java注解处理器，可以在model和实体类直接进行对象映射，通过注解的方式实现对javaBean的转换 注解处理器； 可以生成 JavaBean 之间那的映射代码； 类型安全， 高性能， 无依赖性； 依赖 <dependency> <groupId>org.mapstruct</groupId> <artifactId>mapstruct-jdk8</artifactId>
MapStruct 一文读懂
zhouzhiwengang的专栏
10-21 3447
MapStruct是基于JSR269规范的一个Java注解处理器，用于为Java Bean生成类型安全且高性能的映射。它基于编译阶段生成get/set代码，此实现过程中没有反射，不会造成额外的性能损失。= null?}}}}}温馨提示：可以使用多个类有时需要在某些映射方法之前或之后应用自定义逻辑。MapStruct提供了两种方法：装饰器允许对特定映射方法进行类型安全的自定义，而映射前和映射后生命周期方法则允许对具有给定源或目标类型的映射方法进行通用的自定义。
吐血整理MapStruct
罗罗的1024
12-19 1623
MapStruct MapSturct 是一个生成类型安全，高性能且无依赖的 JavaBean 映射代码的注解处理器（annotation processor） 1、产生背景 我们知道拷贝bean可以使用apache的BeanUtils和spring 提供的BeanUtils，阿里巴巴规范明确规定不要使用Apache的BeanUtils，不论是Apache或者是Spring，他们都是基于反射的，而反射的会有大量的属性拷贝，就会占据cpu，可以效率不是太高。而 MapStruct 是在编译时就已经生成了相应的
MapStruct使用教程，降低无用代码的神器
q_913246828的博客
10-27 1265
MapStruct使用教程，降低无用代码的神器
mapstruct
记录点滴
03-19 2878
大致四部： 第一步：引入依赖 第二步：新建一个抽象类或接口，并标注Mapper注解 第三步：编写转化方法 第四步：获取对象并调用方法 @Mapper注解 默认映射规则： （1）同名且同类型的属性，会自动映射，不同类型会尝试转化为同一类型。 （2）mapstruct会自动类型转化，支持的类型转化的类型如下： <1> 基本类型和他们对应的包装类型之间会自动转化； <2> 8中基本类型（包括他们的包装类型）和String类型之间的转化。 ...
MapStruct学习笔记
SIMBA1949的博客
09-11 1225
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 地址：
map和struct的多重嵌套
热门推荐
后台开发
03-11 1万+
之前聊到了map和struct的单重嵌套，总感觉不够刺激，今天来玩一下多重嵌套。 struct Node1 { int data1; int data2; }; struct Node { int key; map myMap1; }; //map中有Node,Node中有myMap1,myMap1中有Node1,则要想myMap中插入元素，必须由里到外赋值或插入 int main
Mapstruct使用介绍
0bug0warning的博客
10-24 2606
Mapstruct使用介绍 一：使用背景 我们在读库之后(po->dto)，返回前端数据(dto->vo)的需要转换函数，这时候我们一般会有以下几种方式 1：手动编写convert函数 2：利用反射工具进行映射(spring的BeanUtils, fastjson的JSON.parseObjec...
推荐一个 Java 实体映射工具 MapStruct
weixin_34162695的博客
06-14 1917
声明： 1、DO（业务实体对象），DTO（数据传输对象）。 2、我的代码中用到了 Lombok ，不了解的可以自行了解一下，了解的忽略这条就好。 在一个成熟的工程中，尤其是现在的分布式系统中，应用与应用之间，还有单独的应用细分模块之后，DO 一般不会让外部依赖，这时候需要在提供对外接口的模块里放 DTO 用于对象传输，也即是 DO 对象对...
mybatis 关于resultMap(多对一，一对多)
木子study的博客
03-18 734
为了防止遗忘mybatis的一些细节点，记录一下 首先我定义了两个实体类，一个是学生，一个是老师 建表时学生tid和老师外键关联 代码如下(为了代码简洁，使用了lombok依赖) 环境搭建 @Data @NoArgsConstructor @AllArgsConstructor //学生类 public class Student { private Integer id; private String name; //因为多个学生对应一个老师，设置一个teacher对应数据库字段t
MapStruct详解及代码示例
06-06
MapStruct是一个Java注解处理器，可以帮助开发者快速生成Java Bean之间的映射代码。通过注解和代码生成，MapStruct能够自动映射两个Java Bean之间的属性。 下面是一个使用MapStruct的示例： 首先，在Maven项目中添加以下依赖： ```xml <dependency> <groupId>org.mapstruct</groupId> <artifactId>mapstruct</artifactId> <version>1.4.2.Final</version> </dependency> <dependency> <groupId>org.mapstruct</groupId> <artifactId>mapstruct-processor</artifactId> <version>1.4.2.Final</version> <scope>provided</scope> </dependency> ``` 然后，我们需要定义两个Java Bean类，例如： ```java public class SourceBean { private String name; private int age; // getter and setter } public class TargetBean { private String name; private int age; // getter and setter } ``` 接下来，我们需要定义一个Mapper接口，用于映射两个Java Bean之间的属性。例如： ```java @Mapper public interface MyMapper { MyMapper INSTANCE = Mappers.getMapper(MyMapper.class); TargetBean sourceToTarget(SourceBean sourceBean); } ``` 在这个接口中，我们使用了MapStruct提供的@Mapper注解，表示这个接口是一个Mapper接口。同时，我们还定义了一个静态的INSTANCE实例，并使用了Mappers.getMapper方法来获取该实例。 接着，我们在这个接口中定义了一个sourceToTarget方法，用于将SourceBean映射到TargetBean。在这个方法中，我们只需要编写一个简单的映射规则即可，例如： ```java @Mapping(source = "name", target = "name") @Mapping(source = "age", target = "age") TargetBean sourceToTarget(SourceBean sourceBean); ``` 在这个方法中，我们使用了MapStruct提供的@Mapping注解，指定了SourceBean和TargetBean中属性之间的映射关系。例如，source = "name"表示SourceBean中的name属性映射到TargetBean中的name属性。 最后，在我们的代码中，我们可以使用MyMapper.INSTANCE.sourceToTarget方法来将SourceBean转换为TargetBean，例如： ```java SourceBean sourceBean = new SourceBean(); sourceBean.setName("张三"); sourceBean.setAge(18); TargetBean targetBean = MyMapper.INSTANCE.sourceToTarget(sourceBean); System.out.println(targetBean.getName()); // 输出：张三 System.out.println(targetBean.getAge()); // 输出：18 ``` 这样，我们就完成了两个Java Bean之间的属性映射。使用MapStruct能够让我们的代码更加简洁和可维护，特别是在处理复杂的Java Bean之间的映射时，MapStruct能够大大提高我们的开发效率。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值