mapstruct 用法详细介绍

最新推荐文章于 2024-06-10 13:31:24 发布
最新推荐文章于 2024-06-10 13:31:24 发布
阅读量1.6k 收藏 4
点赞数
分类专栏： java基础 文章标签： java spring maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lujia_loney/article/details/121703339
版权

mapstruct 用法

mapstruct 是什么

mapstruct一款是用于生成类型安全的bean映射类的Java注解处理器 JSR 269规范，只需要定义一个接口，配置字段映射规则，使用注解处理器，在代码编译阶段，生成对应的映射实现类，使用的是纯get/set方法，无反射调用，并且在编译阶段可校验错误

官网：https://mapstruct.org/documentation/stable/reference/html/#_apache_maven

JSR 269规范：http://www.jcp.org/en/jsr/detail?id=269

用法

  • 使用maven配置，引入相关依赖
      <properties>
     	<!-- 定义版本-->
        <org.mapstruct.version>1.4.2.Final</org.mapstruct.version>
    </properties>
  <dependency>
            <groupId>org.mapstruct</groupId>
      		<!-- 相关注解包 @mapping-->
            <artifactId>mapstruct</artifactId>
            <version>${org.mapstruct.version}</version>
        </dependency>
        <dependency>
            <groupId>org.mapstruct</groupId>
            <!--注解处理器-->
            <artifactId>mapstruct-processor</artifactId>
            <version>${org.mapstruct.version}</version>
        </dependency>

  • 定义mapping接口, 一些常见mapping映射用法基本都在下面类中，可参考

    /**
 * <h3>Title: </h3>
 * <p>Description: </p>
 *
 * @author : lujia
 * @date : 2021-12-02
 **/
@Mapper(componentModel = "spring")
/**
 * @DecoratedWith 自定义转换器，需要手动实现所有的方法，
 * 使用 @Autowired 注入时默认使用的就是自定义转换器，
 * 需要原始转换器 请使用 @Qualifier("delegate")注入
 */
@DecoratedWith(OrderMapperDecorator.class)
public interface OrderMapper {

    @Mappings({
            //表达式转换
            @Mapping(target = "createDate", expression = "java(com.baibu.framework2.base.Times.toLocalDateTime(orderMapTestVo.getCreateDate()))"),
            // 字段名不一致
            @Mapping(target = "orderId", source = "orderMapTestVo.orderCode"),
            //嵌套
            @Mapping(target = "item.name", source = "orderMapTestVo.item.name"),

            // 多个参数
            @Mapping(target = "item.name1", source = "yesOrNoEnum.code"),
            // 使用自定义的方法转换参数 getPrice 就是 @Named 定义的method name
            @Mapping(target = "price", source = "orderMapTestVo.price", qualifiedByName = "getPrice")
            /**
             * qualifiedBy 同上面 qualifiedByName 作用一样，只不过qualifiedBy 是通过注解定义的类来限定具体方法
             * @Mapping(target = "price", source = "price", qualifiedBy = "getPrice")
             */
    }
    )
    OrderMapTestDto voToDto(OrderMapTestVo orderMapTestVo, YesOrNoEnum yesOrNoEnum);


//    @BeanMapping( resultType = OrderMapTestVo.class )
    // resultType 指定一个返回结果类型，在结果存在多个继承关系的时候可以用到
    //  qualifiedBy
    /**
     * 自定义一个字段转换方法
     *
     * @param price
     * @return
     */
    @Named("getPrice")
    default String getPrice(BigDecimal price) {

        return price.toString();
    }

    @Mappings({
            //表达式转换
            @Mapping(target = "createDate", expression = "java(com.baibu.framework2.base.Times.toLocalDateTime(orderMapTestVo.getCreateDate()))"),
            // 字段名不一致
            @Mapping(target = "orderId", source = "orderCode"),
            //嵌套
            @Mapping(target = "item", source = "item"),

            //@Mapping(target = "stringList",constant = "jack-jill-tom"),
            @Mapping(target = "str", constant = "aaaa"),
            // number 格式化 Number转String或String转Number才可以，如果是Number转Number则无效
            @Mapping(target = "price", source = "price", numberFormat = "$#.00")
            // 多个参数
    }
    )
    /**
     * NullValuePropertyMappingStrategy.IGNORE 忽略空值，
     * NullValuePropertyMappingStrategy.SET_TO_NULL 覆盖设置成null
     * NullValuePropertyMappingStrategy.SET_TO_DEFAULT 设置成默认值
     */
    @BeanMapping(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.IGNORE)
    OrderMapTestDto voToDto(OrderMapTestVo orderMapTestVo);

    // 列表
    List<OrderMapTestDto> voToDtos(List<OrderMapTestVo> orderMapTestVos);

    /**
     * stream
     *
     * @param orderMapTestVos
     * @return
     */
    List<OrderMapTestDto> voToDtos(Stream<OrderMapTestVo> orderMapTestVos);

    /**
     * 反向，字段名不一致还是需要单独配置mapping ，日期类型会自动转换成默认格式的string
     *
     * @param orderMapTestDto
     * @return
     */
    //指定日期格式化
    @Mapping(target = "createDate", dateFormat = "yyyy-MM-dd")
    OrderMapTestVo fromDtoToVo(OrderMapTestDto orderMapTestDto);


    @InheritInverseConfiguration(name = "voToDto")
    OrderMapTestVo inverseDtoToVo(OrderMapTestDto orderMapTestDto);
}

//---------------- dto
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrderMapTestDto {

    /**
     * 供应商订单主键id
     */
    private Long supplierOrderId;

    /**
     * 主键id
     */
    @NotNull(message = "主订单id 不可为空")
    private Long orderId;

    /**
     * 码单备注不可为空
     */
    @NotNull(message = "备注不可为空")
    private String poDetailRemark;


    private LocalDateTime createDate;

    private Item item;

    private String str;

    private List<Item> items;


    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Item{

        private String name;

        private String name1;


        private String name2;
    }

}

//--------  vo
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrderMapTestVo {

    /**
     * 供应商订单主键id
     */
    private Long supplierOrderId;

    /**
     * 主键id
     */
    @NotNull(message = "主订单id 不可为空")
    private Long orderCode;

    /**
     * 码单备注不可为空
     */
    @NotNull(message = "备注不可为空")
    private String poDetailRemark;


    private String createDate;


    private Item item;


    private List<Item> items;

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Item{

        private String name;
    }

}

  • 编译过后自动生成的mapping实现类

    @Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2021-12-03T16:52:47+0800",
    comments = "version: 1.4.2.Final, compiler: javac, environment: Java 11.0.10 (AdoptOpenJDK)"
)
@Component
@Qualifier("delegate")
public class OrderMapperImpl_ implements OrderMapper {

    @Override
    public OrderMapTestDto voToDto(OrderMapTestVo orderMapTestVo, YesOrNoEnum yesOrNoEnum) {
        if ( orderMapTestVo == null && yesOrNoEnum == null ) {
            return null;
        }

        OrderMapTestDto orderMapTestDto = new OrderMapTestDto();

        if ( orderMapTestVo != null ) {
            if ( orderMapTestVo.getItem() != null ) {
                if ( orderMapTestDto.getItem() == null ) {
                    orderMapTestDto.setItem( new Item() );
                }
                itemToItem( orderMapTestVo.getItem(), orderMapTestDto.getItem() );
            }
            orderMapTestDto.setOrderId( orderMapTestVo.getOrderCode() );
            orderMapTestDto.setPrice( getPrice( orderMapTestVo.getPrice() ) );
            orderMapTestDto.setSupplierOrderId( orderMapTestVo.getSupplierOrderId() );
            orderMapTestDto.setPoDetailRemark( orderMapTestVo.getPoDetailRemark() );
            orderMapTestDto.setItems( itemListToItemList( orderMapTestVo.getItems() ) );
        }
        if ( yesOrNoEnum != null ) {
            if ( orderMapTestDto.getItem() == null ) {
                orderMapTestDto.setItem( new Item() );
            }
            yesOrNoEnumToItem( yesOrNoEnum, orderMapTestDto.getItem() );
        }
        orderMapTestDto.setCreateDate( com.baibu.framework2.base.Times.toLocalDateTime(orderMapTestVo.getCreateDate()) );

        return orderMapTestDto;
    }

    @Override
    public OrderMapTestDto voToDto(OrderMapTestVo orderMapTestVo) {
        if ( orderMapTestVo == null ) {
            return null;
        }

        OrderMapTestDto orderMapTestDto = new OrderMapTestDto();

        orderMapTestDto.setOrderId( orderMapTestVo.getOrderCode() );
        orderMapTestDto.setItem( itemToItem1( orderMapTestVo.getItem() ) );
        if ( orderMapTestVo.getPrice() != null ) {
            orderMapTestDto.setPrice( createDecimalFormat( "$#.00" ).format( orderMapTestVo.getPrice() ) );
        }
        orderMapTestDto.setSupplierOrderId( orderMapTestVo.getSupplierOrderId() );
        orderMapTestDto.setPoDetailRemark( orderMapTestVo.getPoDetailRemark() );
        orderMapTestDto.setItems( itemListToItemList( orderMapTestVo.getItems() ) );

        orderMapTestDto.setCreateDate( com.baibu.framework2.base.Times.toLocalDateTime(orderMapTestVo.getCreateDate()) );
        orderMapTestDto.setStr( "aaaa" );

        return orderMapTestDto;
    }

    @Override
    public List<OrderMapTestDto> voToDtos(List<OrderMapTestVo> orderMapTestVos) {
        if ( orderMapTestVos == null ) {
            return null;
        }

        List<OrderMapTestDto> list = new ArrayList<OrderMapTestDto>( orderMapTestVos.size() );
        for ( OrderMapTestVo orderMapTestVo : orderMapTestVos ) {
            list.add( voToDto( orderMapTestVo ) );
        }

        return list;
    }

    @Override
    public List<OrderMapTestDto> voToDtos(Stream<OrderMapTestVo> orderMapTestVos) {
        if ( orderMapTestVos == null ) {
            return null;
        }

        return orderMapTestVos.map( orderMapTestVo -> voToDto( orderMapTestVo ) )
        .collect( Collectors.toCollection( ArrayList<OrderMapTestDto>::new ) );
    }

    @Override
    public OrderMapTestVo fromDtoToVo(OrderMapTestDto orderMapTestDto) {
        if ( orderMapTestDto == null ) {
            return null;
        }

        OrderMapTestVo orderMapTestVo = new OrderMapTestVo();

        if ( orderMapTestDto.getCreateDate() != null ) {
            orderMapTestVo.setCreateDate( DateTimeFormatter.ofPattern( "yyyy-MM-dd" ).format( orderMapTestDto.getCreateDate() ) );
        }
        orderMapTestVo.setSupplierOrderId( orderMapTestDto.getSupplierOrderId() );
        if ( orderMapTestDto.getPrice() != null ) {
            orderMapTestVo.setPrice( new BigDecimal( orderMapTestDto.getPrice() ) );
        }
        orderMapTestVo.setPoDetailRemark( orderMapTestDto.getPoDetailRemark() );
        orderMapTestVo.setItem( itemToItem2( orderMapTestDto.getItem() ) );
        orderMapTestVo.setItems( itemListToItemList1( orderMapTestDto.getItems() ) );

        return orderMapTestVo;
    }

    @Override
    public OrderMapTestVo inverseDtoToVo(OrderMapTestDto orderMapTestDto) {
        if ( orderMapTestDto == null ) {
            return null;
        }

        OrderMapTestVo orderMapTestVo = new OrderMapTestVo();

        orderMapTestVo.setOrderCode( orderMapTestDto.getOrderId() );
        orderMapTestVo.setItem( itemToItem2( orderMapTestDto.getItem() ) );
        try {
            if ( orderMapTestDto.getPrice() != null ) {
                orderMapTestVo.setPrice( (BigDecimal) createDecimalFormat( "$#.00" ).parse( orderMapTestDto.getPrice() ) );
            }
        }
        catch ( ParseException e ) {
            throw new RuntimeException( e );
        }
        orderMapTestVo.setSupplierOrderId( orderMapTestDto.getSupplierOrderId() );
        orderMapTestVo.setPoDetailRemark( orderMapTestDto.getPoDetailRemark() );
        if ( orderMapTestDto.getCreateDate() != null ) {
            orderMapTestVo.setCreateDate( DateTimeFormatter.ISO_LOCAL_DATE_TIME.format( orderMapTestDto.getCreateDate() ) );
        }
        orderMapTestVo.setItems( itemListToItemList1( orderMapTestDto.getItems() ) );

        return orderMapTestVo;
    }

    private DecimalFormat createDecimalFormat( String numberFormat ) {

        DecimalFormat df = new DecimalFormat( numberFormat );
        df.setParseBigDecimal( true );
        return df;
    }

    protected void itemToItem(com.baibu.order.application.vo.req.OrderMapTestVo.Item item, Item mappingTarget) {
        if ( item == null ) {
            return;
        }

        mappingTarget.setName( item.getName() );
    }

    protected void yesOrNoEnumToItem(YesOrNoEnum yesOrNoEnum, Item mappingTarget) {
        if ( yesOrNoEnum == null ) {
            return;
        }

        mappingTarget.setName1( yesOrNoEnum.getCode() );
    }

    protected Item itemToItem1(com.baibu.order.application.vo.req.OrderMapTestVo.Item item) {
        if ( item == null ) {
            return null;
        }

        Item item1 = new Item();

        item1.setName( item.getName() );

        return item1;
    }

    protected List<Item> itemListToItemList(List<com.baibu.order.application.vo.req.OrderMapTestVo.Item> list) {
        if ( list == null ) {
            return null;
        }

        List<Item> list1 = new ArrayList<Item>( list.size() );
        for ( com.baibu.order.application.vo.req.OrderMapTestVo.Item item : list ) {
            list1.add( itemToItem1( item ) );
        }

        return list1;
    }

    protected com.baibu.order.application.vo.req.OrderMapTestVo.Item itemToItem2(Item item) {
        if ( item == null ) {
            return null;
        }

        com.baibu.order.application.vo.req.OrderMapTestVo.Item item1 = new com.baibu.order.application.vo.req.OrderMapTestVo.Item();

        item1.setName( item.getName() );

        return item1;
    }

    protected List<com.baibu.order.application.vo.req.OrderMapTestVo.Item> itemListToItemList1(List<Item> list) {
        if ( list == null ) {
            return null;
        }

        List<com.baibu.order.application.vo.req.OrderMapTestVo.Item> list1 = new ArrayList<com.baibu.order.application.vo.req.OrderMapTestVo.Item>( list.size() );
        for ( Item item : list ) {
            list1.add( itemToItem2( item ) );
        }

        return list1;
    }
}

  • 自定义装饰者

    /**
 * <h3>Title: </h3>
 * <p>Description: </p>
 *
 * @author : lujia
 * @date : 2021-12-02
 * 这里其实算是一个装饰器的模式，OrderMapperDecorator 包装了原来的OrderMapper ，
 * 提供额外的能力，然后再委托原来的OrderMapper的处理
 **/
@Slf4j
@RequiredArgsConstructor
public abstract class OrderMapperDecorator implements OrderMapper {

    @Autowired
    @Qualifier("delegate")
    private  OrderMapper delegate;

    @Override
    public OrderMapTestDto voToDto(OrderMapTestVo orderMapTestVo, YesOrNoEnum yesOrNoEnum) {
        log.info("自定义转换器");
        return delegate.voToDto(orderMapTestVo, yesOrNoEnum);

    }

    @Override
    public OrderMapTestDto voToDto(OrderMapTestVo orderMapTestVo) {
        return delegate.voToDto(orderMapTestVo);
    }

    @Override
    public List<OrderMapTestDto> voToDtos(List<OrderMapTestVo> orderMapTestVos) {
        return delegate.voToDtos(orderMapTestVos);
    }

    @Override
    public List<OrderMapTestDto> voToDtos(Stream<OrderMapTestVo> orderMapTestVos) {
        return delegate.voToDtos(orderMapTestVos);
    }

    @Override
    public OrderMapTestVo fromDtoToVo(OrderMapTestDto orderMapTestDto) {
        return null;
    }
}

  • 编译过后自定义装饰类实现

    @Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2021-12-03T16:52:47+0800",
    comments = "version: 1.4.2.Final, compiler: javac, environment: Java 11.0.10 (AdoptOpenJDK)"
)
@Component
@Primary
public class OrderMapperImpl extends OrderMapperDecorator implements OrderMapper {

    @Autowired
    @Qualifier("delegate")
    private OrderMapper delegate;

    @Override
    public OrderMapTestVo inverseDtoToVo(OrderMapTestDto orderMapTestDto)  {
        return delegate.inverseDtoToVo( orderMapTestDto );
    }
}

  • 使用

      	 /**
     * 如果使用@DecoratedWith(OrderMapperDecorator.class)自定义了 转换器，此处默认注入的就是自定义的OrderMapperDecorator ，
     * 如果需要注入OrderMapper 请使用 @Qualifier("delegate")注解注入
     */
 	@Autowired
    private OrderMapper orderMapper;

    @PostMapping("/testMapstruct")
    public OrderMapTestDto testMapstruct(@RequestBody OrderMapTestVo orderMapTestVo) {

        OrderMapTestDto orderMapTestDto = orderMapper.voToDto(orderMapTestVo, YesOrNoEnum.YES);

        OrderMapTestVo orderMapTestVo1 = new OrderMapTestVo();
        BeanUtils.copyProperties(orderMapTestVo,orderMapTestVo1);

        List<OrderMapTestVo> list=new ArrayList<>();
        list.add(orderMapTestVo);
        list.add(orderMapTestVo1);
        List<OrderMapTestDto> orderMapTestDtos = orderMapper.voToDtos(list);

        log.info(Json.serialize(orderMapTestDtos));

        OrderMapTestVo orderMapTestVo2 = orderMapper.fromDtoToVo(orderMapTestDto);
        log.info(Json.serialize(orderMapTestVo2));
        OrderMapTestVo orderMapTestVo3 = orderMapper.inverseDtoToVo(orderMapTestDto);
        log.info(Json.serialize(orderMapTestVo3));

        return orderMapTestDto;
    }

总结

优点

  • 相比BeanUtils的反射，使用mapstruct性能肯定更好，相比手动set也减轻一丢丢工作量
  • mapstruct 在编译阶段就会校验一些错误，列如字段不存在，方法不存在
  • 包装类型自动转换，自动格式化

缺点

  • 当字段名称，类型不一致时，同样需要定义一堆映射关系，比较繁琐，同时这种映射只会在编译阶段校验，发现
  • 多了很多class文件，如果使用spring注入方式，也会多了一堆 spring bean 定义，占用jvm内存空间
  • 复杂映射支持不足，比如多重嵌套list ，map 等，这里可能是我使用的还比较少，没发现什么比较好的方法
LuTshoes
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mapstruct 使用教程
菜鸡的博客
08-28 9万+
Mapstruct 版本1.5.0.Beta1 官方文档 案例-github 前言 MapStruct是一个Java注释处理器，用于生成类型安全的bean映射类。 您要做的就是定义一个映射器接口，该接口声明任何必需的映射方法。在编译期间，MapStruct将生成此接口的实现。此实现使用简单的Java方法调用在源对象和目标对象之间进行映射，即没有反射或类似内容。 与手动编写映射代码相比，MapStruct通过生成繁琐且易于出错的代码来节省时间。遵循配置方法上的约定，MapStruct使用合理的默认值，但在配置
MapStruct的使用详解与常见用法介绍
compellingMan的博客
08-03 1万+
mapstruct在当前轻量级框架开发中的重点使用，@Named注解使用示例，@AfterMapping与@BeforeMapping注解的详细常见用法，在转换DTO时，与过去常用的beanUtil转换有高性能的转换优势，编译期自动生成的mapper实现类能够更加优雅的来实现各种隐式类型转换，以实现快速而又敏捷的开发，告别臃肿的手动get、set与类型的强转......
MapStruct的用法总结及示例
最新发布
小蜜蜂1010的博客
06-10 1630
比dozer更好用的java对象属性映射复制工具MapStuct的用法及代码示例
在mapstruct中使用spring中的bean进行复杂逻辑转换
激进的工程师的博客
01-29 1419
在mapstruct中，可以使用expression方式进行简单的逻辑转换，也可以调用一些工具类的静态方法，但是有很多场景的逻辑更加复杂，会需要使用spring中已经存在的bean中的逻辑或者数据进行处理，其实mapstruct也提供一种非常巧妙的方式支持这种场景。
【转】MapStruct 用法
魂-淡
08-30 2271
org.mapstruct:mapstruct，它是专门用来处理 domin 实体类与 model 类的属性映射的
Mapstruct 基本用法
weixin_43549350的博客
03-30 1204
MapStruct 简介 在实际开发中我们在项目中经常要在 DTO、VO、DO、Entity 等实体之间进行转换，这种类型的框架也有很多，比如 Spring 框架中的 BeanUtils 工具类 ，但这个工具类是通过反射来实现的，性能相对低下且存在类型转换异常的问题，所以这个工具在有些公司是禁止使用的。下面简单说一下MapStruct,MapStruct 是一个代码生成器，它基于约定优于配置的方法极大地简化了Java bean类型之间映射的实现。与其他映射框架相比，MapStruct在编译时生成Bean映
Java编码辅助工具Mapstruct用法详解
08-25
Java编码辅助工具Mapstruct用法详解 Mapstruct是一个Java编码辅助工具，主要用于简化Java Bean之间的转换工作。通过使用Mapstruct框架，可以简洁方便地完成Bean之间的转换工作，免去了手动编码setter/getter的烦恼...
mapstruct-idea:IntelliJ IDEA插件，可与MapStruct一起使用
05-02
IntelliJ IDEA插件，可与MapStruct一起使用 什么是MapStruct？ MapStruct是一个Java用于为Java Bean类生成类型安全和高性能的映射器。 要了解有关MapStruct的更多信息，请查看存储库或 特征 代码完成 完成@Mapping...
MapStruct实体间转换的简单用法
08-26
MapStruct实体间转换的简单用法 MapStruct是一个功能强大且广泛应用的对象转换工具，能够帮助开发者快速地将实体间的数据进行转换。下面是关于MapStruct实体间转换的简单用法的知识点： 一、为什么需要MapStruct？...
mapstruct-1.2.0.Final-API文档-中文版.zip
07-13
赠送jar包：mapstruct-1.2.0.Final.jar； 赠送原API文档：mapstruct-1.2.0.Final-javadoc.jar； 赠送源代码：mapstruct-1.2.0.Final-sources.jar； 赠送Maven依赖信息文件：mapstruct-1.2.0.Final.pom； 包含翻译后...
mapstruct-1.1.0.Final-API文档-中文版.zip
07-12
赠送jar包：mapstruct-1.1.0.Final.jar； 赠送原API文档：mapstruct-1.1.0.Final-javadoc.jar； 赠送源代码：mapstruct-1.1.0.Final-sources.jar； 赠送Maven依赖信息文件：mapstruct-1.1.0.Final.pom； 包含翻译后...
MapStruct使用教程2024(高级版)
热门推荐
码到三十五
11-04 1万+
MapStruct是一个用于Java的代码生成库，它基于注解处理器在编译时生成类型安全且高性能的对象映射代码,MapStruct可以帮助开发者减少手动编写繁琐的JavaBean之间的转换代码，提高代码的可读性和维护性。
mapstruct使用详解
浮生未歇的博客
07-29 2650
概述 MapStruct 是一个代码生成器，它基于约定优于配置方法极大地简化了 Java bean 类型之间映射的实现。生成的映射代码使用简单的方法调用，因此速度快、类型安全且易于理解。 为什么使用它？ 多层应用程序通常需要在不同的对象模型（例如实体和 DTO）之间进行映射。编写这样的映射代码是一项乏味且容易出错的任务。MapStruct 旨在通过尽可能自动化来简化这项工作。 与其他映射框架相比，MapStruct 在编译时生成 bean 映射，以确保高性能，允许快速的开发人员反馈和彻底的错误检查。
mapstruct使用随记
BohouZhang的博客
12-08 630
mapstruct使用随记 在工作中，应自己参与的项目要求接触到了mapstruct这个框架，在踩了一些坑之后，学习到了有关实体类转换的一些新知识。 getset，BeanUtils和mapstruct 我所接触的所有工程都涉及到分层的设计，这就不可避免的要对不同层之间传输的数据进行转换。 最简单的转换方式，莫过于使用get和set方法。但是这样做有一个弊端，即代码量实在太大。尤其是某个实体类有十几个甚至更多的成员变量时，我们要写大量的get和set方法。机械工作太多，而也容易忙中出错。 之后接触到了一些工
MapStruct使用及常用方式示例
qq_45105233的博客
12-21 2229
1.Mapstruct是实体类的映射框架，可以直接通过Java注解将一个实体类的属性高效的赋值给另一个实体类。2.实体类映射框架从实现原理上看大致可以分为两种，一种是基于反射动态映射实现(BeanUtils)，另一种就是基于编译期动态生成getter/setter(Mapstruct)./** * 映射. */ EntiyConverter INSTANCE = Mappers.getMapper(EntiyConverter.class);
lombok java: 找不到符号
asp.net爱好
07-11 440
lombok java: 找不到符号
MapStruct：将数据从一个bean传输到另一个bean
最佳 Java 编程
06-05 991
将数据从一种形式转换为另一种形式在IT行业中是一种被高度利用的概念。 MapStruct通过在编译时生成映射器实现，允许基于注释的Bean转换。 这样可以确保在运行时没有性能开销。 什么是MapStruct？ MapStruct是一个代码生成器，它基于约定优于配置的方法大大简化了Java Bean类型之间的映射的实现。 生成的映射代码使用简单的方法调用，因此速度快，类型安全且易于理解...
Mapstruct
m0_54365908的博客
02-20 529
mapstruct
mapstruct使用方法
11-30
以下是使用MapStruct的步骤： 1.添加MapStruct依赖项到你的项目中。你可以在Maven或Gradle中添加以下依赖项： ```xml <groupId>org.mapstruct <artifactId>mapstruct <version>1.4.2.Final ``` 2.创建一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值