MapStruct - 让java实体映射更容易

最新推荐文章于 2024-05-10 13:40:26 发布
最新推荐文章于 2024-05-10 13:40:26 发布
阅读量1.3k 收藏 5
点赞数
分类专栏： 开发准备 springboot 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34453866/article/details/130712019
版权

MapStruct - 让java实体映射更容易

一、什么是MapStruct？

MapStruct 是一个 Java 注释处理器，用于为 Java Bean 类生成类型安全和高性能的映射器。它使您免于手动编写映射代码，这是一项繁琐且容易出错的任务。该生成器具有合理的默认值和许多内置类型转换，也可以通过配置实现一些特殊行为。

与在运行时工作的映射框架相比，MapStruct具有以下优点：

  • 通过使用普通方法调用而不是反射赋值
  • 编译时类型安全。只能映射彼此映射的对象和属性，不会意外地将订单实体映射到客户 DTO 等。
  • 自包含代码 — 无运行时依赖关系
  • 在以下情况下，在构建时清除错误报告：
    • 映射不完整（并非所有目标属性都已映射）
    • 映射不正确（找不到正确的映射方法或类型转换）
  • 易于调试的映射代码（或可手动编辑 - 例如，在生成器中出现错误的情况下）

若要在两种类型之间创建映射，请声明如下所示的映射器接口：

@Mapper
public interface CarMapper {

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

    @Mapping(target = "seatCount", source = "numberOfSeats")
    CarDto carToCarDto(Car car);
}

在编译时，MapStruct将生成此接口的实现。生成的实现使用纯 Java 方法调用来映射源对象和目标对象，即不涉及反射。默认情况下，如果属性在源和目标中具有相同的名称，则会映射它们，但也可以使用一些其他注释来控制此方面和许多其他方面。

二、要求

MapStruct 需要 Java 1.8 或更高版本。

三、引入 MapStruct

Maven

对于基于 Maven 的项目，请将以下内容添加到您的 POM 文件中以使用 MapStruct（依赖项可在 Maven Central 获得）：

...
<properties>
    <org.mapstruct.version>1.5.5.Final</org.mapstruct.version>
</properties>
...
<dependencies>
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>${org.mapstruct.version}</version>
    </dependency>
</dependencies>
...
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <annotationProcessorPaths>
                    <path>
                        <groupId>org.mapstruct</groupId>
                        <artifactId>mapstruct-processor</artifactId>
                        <version>${org.mapstruct.version}</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>
...

IntelliJ

确保至少具有 IntelliJ 2018.2.x。 在 IntelliJ 中启用注释处理（生成、执行、部署 -> 编译器 -> 注释处理器）annotationProcessors``maven-compiler-plugin。

idea 插件(可选)：MapStruct Support。

springboot集成及常见使用方法

pom.xml
...
		<properties>
			<org.mapstruct.version>1.4.1.Final</org.mapstruct.version>
 		</properties>
...

...
		<dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>${org.mapstruct.version}</version>
        </dependency>
...

...
	<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                    <annotationProcessorPaths>
                   	<!--兼容lombok-->
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${lombok.version}</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok-mapstruct-binding</artifactId>
                            <version>${lombok-mapstruct-binding.version}</version>
                        </path>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${org.mapstruct.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
    	</plugins>
    </build>
...
创建转换接口类

使用注解@Mapper(componentModel = “spring”)标记接口类，编译将生成实现类；生成的实现类一般是在target目录下的对应接口类的包中。

@Mapper(componentModel = "spring")
public interface CustomerConvert {
    
}

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2023-05-08T19:50:07+0800",
    comments = "version: 1.4.1.Final, compiler: javac, environment: Java 1.8.0_333 (Oracle Corporation)"
)
@Component
public class CustomerConvertImpl implements CustomerConvert {

}

四、常见用法

深克隆
import org.mapstruct.Mapper;
import org.mapstruct.control.DeepClone;

@Mapper(componentModel = "spring", mappingControl = DeepClone.class)
public interface Cloner {
    CustomerDto clone(CustomerDto customerDto);
}

import com.cy.mapstruct.entity.CustomerDto;
import com.cy.mapstruct.entity.OrderItemDto;
import com.cy.mapstruct.entity.OrderItemKeyDto;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Generated;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2023-05-09T20:14:48+0800",
    comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_333 (Oracle Corporation)"
)
@Component
public class ClonerImpl implements Cloner {

    @Override
    public CustomerDto clone(CustomerDto customerDto) {
        if ( customerDto == null ) {
            return null;
        }

        CustomerDto customerDto1 = new CustomerDto();

        customerDto1.setId( customerDto.getId() );
        customerDto1.setCustomerName( customerDto.getCustomerName() );
        customerDto1.setOrders( orderItemDtoListToOrderItemDtoList( customerDto.getOrders() ) );
        customerDto1.setStock( orderItemKeyDtoOrderItemDtoMapToOrderItemKeyDtoOrderItemDtoMap( customerDto.getStock() ) );

        return customerDto1;
    }

    protected OrderItemDto orderItemDtoToOrderItemDto(OrderItemDto orderItemDto) {
        if ( orderItemDto == null ) {
            return null;
        }

        OrderItemDto orderItemDto1 = new OrderItemDto();

        orderItemDto1.setName( orderItemDto.getName() );
        orderItemDto1.setQuantity( orderItemDto.getQuantity() );

        return orderItemDto1;
    }

    protected List<OrderItemDto> orderItemDtoListToOrderItemDtoList(List<OrderItemDto> list) {
        if ( list == null ) {
            return null;
        }

        List<OrderItemDto> list1 = new ArrayList<OrderItemDto>( list.size() );
        for ( OrderItemDto orderItemDto : list ) {
            list1.add( orderItemDtoToOrderItemDto( orderItemDto ) );
        }

        return list1;
    }

    protected OrderItemKeyDto orderItemKeyDtoToOrderItemKeyDto(OrderItemKeyDto orderItemKeyDto) {
        if ( orderItemKeyDto == null ) {
            return null;
        }

        OrderItemKeyDto orderItemKeyDto1 = new OrderItemKeyDto();

        orderItemKeyDto1.setStockNumber( orderItemKeyDto.getStockNumber() );

        return orderItemKeyDto1;
    }

    protected Map<OrderItemKeyDto, OrderItemDto> orderItemKeyDtoOrderItemDtoMapToOrderItemKeyDtoOrderItemDtoMap(Map<OrderItemKeyDto, OrderItemDto> map) {
        if ( map == null ) {
            return null;
        }

        Map<OrderItemKeyDto, OrderItemDto> map1 = new LinkedHashMap<OrderItemKeyDto, OrderItemDto>( Math.max( (int) ( map.size() / .75f ) + 1, 16 ) );

        for ( java.util.Map.Entry<OrderItemKeyDto, OrderItemDto> entry : map.entrySet() ) {
            OrderItemKeyDto key = orderItemKeyDtoToOrderItemKeyDto( entry.getKey() );
            OrderItemDto value = orderItemDtoToOrderItemDto( entry.getValue() );
            map1.put( key, value );
        }

        return map1;
    }
}
属性映射
import com.cy.mapstruct.entity.Customer;
import com.cy.mapstruct.entity.CustomerDto;
import com.cy.mapstruct.entity.OrderItem;
import com.cy.mapstruct.entity.OrderItemDto;
import org.mapstruct.InheritInverseConfiguration;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;

@Mapper(componentModel = "spring")
public interface PropConvertor {

    @Mapping(source = "orders", target = "orderItems")
    @Mapping(source = "customerName", target = "name")
    Customer toCustomer(CustomerDto customerDto);

    @InheritInverseConfiguration
    CustomerDto fromCustomer(Customer customer);

    OrderItem toOrder(OrderItemDto orderItemDto);

    @InheritInverseConfiguration
    OrderItemDto fromOrder(OrderItem orderItem);
}

import com.cy.mapstruct.entity.Customer;
import com.cy.mapstruct.entity.CustomerDto;
import com.cy.mapstruct.entity.OrderItem;
import com.cy.mapstruct.entity.OrderItemDto;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.annotation.Generated;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2023-05-09T20:52:30+0800",
    comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_333 (Oracle Corporation)"
)
@Component
public class PropConvertorImpl implements PropConvertor {

    @Override
    public Customer toCustomer(CustomerDto customerDto) {
        if ( customerDto == null ) {
            return null;
        }

        Customer customer = new Customer();

        customer.setOrderItems( orderItemDtoListToOrderItemCollection( customerDto.getOrders() ) );
        customer.setName( customerDto.getCustomerName() );
        customer.setId( customerDto.getId() );

        return customer;
    }

    @Override
    public CustomerDto fromCustomer(Customer customer) {
        if ( customer == null ) {
            return null;
        }

        CustomerDto customerDto = new CustomerDto();

        customerDto.setOrders( orderItemCollectionToOrderItemDtoList( customer.getOrderItems() ) );
        customerDto.setCustomerName( customer.getName() );
        customerDto.setId( customer.getId() );

        return customerDto;
    }

    @Override
    public OrderItem toOrder(OrderItemDto orderItemDto) {
        if ( orderItemDto == null ) {
            return null;
        }

        OrderItem orderItem = new OrderItem();

        orderItem.setName( orderItemDto.getName() );
        orderItem.setQuantity( orderItemDto.getQuantity() );

        return orderItem;
    }

    @Override
    public OrderItemDto fromOrder(OrderItem orderItem) {
        if ( orderItem == null ) {
            return null;
        }

        OrderItemDto orderItemDto = new OrderItemDto();

        orderItemDto.setName( orderItem.getName() );
        orderItemDto.setQuantity( orderItem.getQuantity() );

        return orderItemDto;
    }

    protected Collection<OrderItem> orderItemDtoListToOrderItemCollection(List<OrderItemDto> list) {
        if ( list == null ) {
            return null;
        }

        Collection<OrderItem> collection = new ArrayList<OrderItem>( list.size() );
        for ( OrderItemDto orderItemDto : list ) {
            collection.add( toOrder( orderItemDto ) );
        }

        return collection;
    }

    protected List<OrderItemDto> orderItemCollectionToOrderItemDtoList(Collection<OrderItem> collection) {
        if ( collection == null ) {
            return null;
        }

        List<OrderItemDto> list = new ArrayList<OrderItemDto>( collection.size() );
        for ( OrderItem orderItem : collection ) {
            list.add( fromOrder( orderItem ) );
        }

        return list;
    }
}
列表复制
import com.cy.mapstruct.entity.OrderItem;
import com.cy.mapstruct.entity.OrderItemDto;
import org.mapstruct.InheritInverseConfiguration;
import org.mapstruct.Mapper;

import java.util.List;

@Mapper(componentModel = "spring")
public interface ListConvertor {
    List<OrderItem> toOrders(List<OrderItemDto> orderItemDtos);

    @InheritInverseConfiguration
    List<OrderItemDto> fromOrders(List<OrderItem> orderItems);
}


import com.cy.mapstruct.entity.OrderItem;
import com.cy.mapstruct.entity.OrderItemDto;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Generated;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2023-05-12T20:55:39+0800",
    comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_333 (Oracle Corporation)"
)
@Component
public class ListConvertorImpl implements ListConvertor {

    @Override
    public List<OrderItem> toOrders(List<OrderItemDto> orderItemDtos) {
        if ( orderItemDtos == null ) {
            return null;
        }

        List<OrderItem> list = new ArrayList<OrderItem>( orderItemDtos.size() );
        for ( OrderItemDto orderItemDto : orderItemDtos ) {
            list.add( orderItemDtoToOrderItem( orderItemDto ) );
        }

        return list;
    }

    @Override
    public List<OrderItemDto> fromOrders(List<OrderItem> orderItems) {
        if ( orderItems == null ) {
            return null;
        }

        List<OrderItemDto> list = new ArrayList<OrderItemDto>( orderItems.size() );
        for ( OrderItem orderItem : orderItems ) {
            list.add( orderItemToOrderItemDto( orderItem ) );
        }

        return list;
    }

    protected OrderItem orderItemDtoToOrderItem(OrderItemDto orderItemDto) {
        if ( orderItemDto == null ) {
            return null;
        }

        OrderItem orderItem = new OrderItem();

        orderItem.setName( orderItemDto.getName() );
        orderItem.setQuantity( orderItemDto.getQuantity() );

        return orderItem;
    }

    protected OrderItemDto orderItemToOrderItemDto(OrderItem orderItem) {
        if ( orderItem == null ) {
            return null;
        }

        OrderItemDto orderItemDto = new OrderItemDto();

        orderItemDto.setName( orderItem.getName() );
        orderItemDto.setQuantity( orderItem.getQuantity() );

        return orderItemDto;
    }
}
带子集列表复制
import com.cy.mapstruct.entity.Customer;
import com.cy.mapstruct.entity.CustomerDto;
import org.mapstruct.InheritInverseConfiguration;
import org.mapstruct.IterableMapping;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.Named;
import org.mapstruct.Qualifier;

import java.util.List;

@Mapper(componentModel = "spring")
public interface ListChildrenConvertor {

    @IterableMapping(qualifiedByName = "toCustomer")
    List<Customer> toCustomers(List<CustomerDto> customerDtos);

    @Named("toCustomer")
    @Mappings({
            @Mapping(source = "orders", target = "orderItems"),
            @Mapping(source = "customerName", target = "name"),
    })
    Customer toCustomer(CustomerDto customerDto);
}


import com.cy.mapstruct.entity.Customer;
import com.cy.mapstruct.entity.CustomerDto;
import com.cy.mapstruct.entity.OrderItem;
import com.cy.mapstruct.entity.OrderItemDto;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.annotation.Generated;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2023-05-12T21:05:27+0800",
    comments = "version: 1.5.3.Final, compiler: javac, environment: Java 1.8.0_333 (Oracle Corporation)"
)
@Component
public class ListChildrenConvertorImpl implements ListChildrenConvertor {

    @Override
    public List<Customer> toCustomers(List<CustomerDto> customerDtos) {
        if ( customerDtos == null ) {
            return null;
        }

        List<Customer> list = new ArrayList<Customer>( customerDtos.size() );
        for ( CustomerDto customerDto : customerDtos ) {
            list.add( toCustomer( customerDto ) );
        }

        return list;
    }

    @Override
    public Customer toCustomer(CustomerDto customerDto) {
        if ( customerDto == null ) {
            return null;
        }

        Customer customer = new Customer();

        customer.setOrderItems( orderItemDtoListToOrderItemCollection( customerDto.getOrders() ) );
        customer.setName( customerDto.getCustomerName() );
        customer.setId( customerDto.getId() );

        return customer;
    }

    protected OrderItem orderItemDtoToOrderItem(OrderItemDto orderItemDto) {
        if ( orderItemDto == null ) {
            return null;
        }

        OrderItem orderItem = new OrderItem();

        orderItem.setName( orderItemDto.getName() );
        orderItem.setQuantity( orderItemDto.getQuantity() );

        return orderItem;
    }

    protected Collection<OrderItem> orderItemDtoListToOrderItemCollection(List<OrderItemDto> list) {
        if ( list == null ) {
            return null;
        }

        Collection<OrderItem> collection = new ArrayList<OrderItem>( list.size() );
        for ( OrderItemDto orderItemDto : list ) {
            collection.add( orderItemDtoToOrderItem( orderItemDto ) );
        }

        return collection;
    }
}

五、常用注解

注解

注解描述
@Mapper指示此接口将用于生成映射实现
@Mapping将源和目标属性之间的映射指定为参数
@Mappings允许使用多个 @Mapping 注释指定映射
@InheritConfiguration继承父映射配置
@BeanMapping自定义要应用于映射器方法的 Bean 映射选项
@BeforeMapping在映射开始时执行方法
@AfterMapping在映射结束时执行方法
@IterableMapping将迭代器类型映射指定为参数
@ValueMapping为枚举类型或其他可枚举类型提供自定义值映射
@Named为参数提供一个自定义名称
@Context将用户提供的上下文参数注入 Mapper 方法
@AfterMappingConversion在映射后进行类型转换
@Qualifier为不同的 Mapper 或 Mapping 提供自定义限定符
@MapperDependency指定该 Mapper 接口依赖于另一个 Mapper 接口

例子

1. @Mapper 用于指示此接口将用于生成映射实现。
public interface PersonMapper {
    PersonDto personToPersonDto(Person person);
    List<PersonDto> personsToPersonDtos(List<Person> persons);
}
2. @Mapping 将源类型和目标类型之间的映射指定为参数。
public interface PersonMapper {
    @Mapping(source = "firstName", target = "name")
    PersonDto personToPersonDto(Person person);
}
3. @Mappings 允许使用多个 @Mapping 注释来指定映射关系。
public interface PersonMapper {
    @Mappings({
        @Mapping(source = "firstName", target = "name"),
        @Mapping(source = "age", target = "ageGroup")
    })
    PersonDto personToPersonDto(Person person);
}
4. @InheritConfiguration 继承父映射配置。
@Mapper(config = ParentMapper.class)
public interface ChildMapper {
    @InheritConfiguration
    ChildDto childToChildDto(Child child);
}
5. @BeanMapping 自定义要应用于映射器方法的 Bean 映射选项。
public interface PersonMapper {
    @BeanMapping(ignoreByDefault = true)
    @Mapping(source = "firstName", target = "name")
    PersonDto personToPersonDto(Person person);
}
6. @BeforeMapping 在映射开始时执行方法。
public interface PersonMapper {
    @BeforeMapping
    default void beforePersonToPersonDto(Person person, @MappingTarget PersonDto personDto) {
        // do something before mapping
    }
    PersonDto personToPersonDto(Person person);
}
7. @AfterMapping 在映射结束时执行方法。
public interface PersonMapper {
    @AfterMapping
    default void afterPersonToPersonDto(Person person, @MappingTarget PersonDto personDto) {
        // do something after mapping
    }
    PersonDto personToPersonDto(Person person);
}
8. @IterableMapping 将迭代器类型映射指定为参数。
public interface PersonMapper {
    @IterableMapping(dateFormat = "yyyy-MM-dd")
    List<String> datesToStrings(List<Date> dates);
}
9. @ValueMapping 为枚举类型或其他可枚举类型提供自定义值映射。
public interface ColorMapper {
    @ValueMapping(source = "RED", target = "0")
    @ValueMapping(source = "GREEN", target = "1")
    @ValueMapping(source = "BLUE", target = "2")
    int colorToInt(Color color);
}
10. @Named 为参数提供一个自定义名称。
public interface PersonMapper {
    PersonDto personToPersonDto(@Named("firstName") String name, @Named("old") int age);
}
11. @Context 将用户提供的上下文参数注入 Mapper 方法。
public interface PersonMapper {
    PersonDto personToPersonDto(Person person, @Context SecurityContext securityContext);
}
12. @AfterMappingConversion 在映射后进行类型转换。
public interface HumanMapper {
 
    @AfterMappingConversion
    default void afterPersonToPersonDtoConversion(Date birthDate, @MappingTarget HumanDto humanDto) {
        humanDto.setAge(getAge(birthDate));
    }
 
    default int getAge(Date birthDate) {
        // calculate age
        return 0;
    }
 
    HumanDto humanToHumanDto(Human human);
}
13. @Qualifier 为不同的 Mapper 或 Mapping 提供自定义限定符。
@Mapper(qualifier = "Child")
public interface PersonMapper {
    PersonDto personToPersonDto(Person person);
}
14. @MapperDependency 指定该 Mapper 接口依赖于另一个 Mapper 接口。
@Mapper(uses = {ParentMapper.class})
public interface ChildMapper {
    ChildDto childToChildDto(Child child);
}

使用 MapStruct 的这些注解，可以很方便地进行 Java Bean 的映射。

六、链接

赖斯啊
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java实体映射工具MapStruct使用详解
guanshengg的博客
08-26 9383
通常在后端开发中经常不直接返回实体Entity类，经过处理转换返回前端，前端提交过来的对象也需要经过转换Entity实体才做存储；通常使用的BeanUtils.copyProperties方法也比较粗暴，不仅效率低下（使用反射）而且仅映射相同名的属性，多数情况下还需要手动编写对应的转换方法实现。 插件MapStruct以接口方法结合注解优雅实现对象转换，MapStruct生成器生成代码以更贴近原生的Setter、Getter方法处理属性映射更为高效...
Java实体映射工具：MapStruct
天瑕的博客
02-08 9221
当我们需要进行Java Model之间的拷贝时，或者项目要求Java Model需要严格区分为数据对象（DO）、数据传输对象（DTO）和展示对象（VO）的时候，我们就不得不把一个实体中的属性映射到另一个实体中。最简单的做法就是写一个工具类，进行不断的getter / setter，这样虽然能完成要求但却写了很多冗余代码，维护起来相当恶心。所以这个时候就需要一款能自动映射实体属性的工具了。 Spring自带的BeanUtils工具类算是一款，但是它却不能自定义映射规则；ModelMapper也是一款映射工具
Java最全MapStruct：一款java对象转换神器，java每次面试一般多长时间
最新发布
2301_79655438的博客
05-10 927
这份《“java高分面试指南”-25分类227页1000+题50w+字解析》同样可分享给有需要的朋友，感兴趣的伙伴们可挑战一下自我，在不看答案解析的情况，测试测试自己的解题水平，这样也能达到事半功倍的效果！（好东西要大家一起看才香）本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
Mapstruct使用说明（一）
cw_hello1的专栏
09-08 7540
在使用分层或者分模块化的项目中，我们可能定义各种各样的O，例如：DO，VO，DTO等等。我们在进行这些对象之间的拷贝时，通过手动写get/set方法进行属性之间的赋值。因为他们之间的属性大部分都是相同的，不仅浪费时间，并且还有大量重复代码。所以，各种框架都添加的对象之间的拷贝的工具类。例如： Spring自带了BeanUtils Apatch自带的BeanUtils Apatch自带的PropertyUtils mapstruct提供Mappers ...
MapStruct的原理与使用
weixin_46377148的博客
03-21 2870
MapStruct的原理与使用
MapStruct使用教程2024(高级版)
热门推荐
码到三十五
11-04 1万+
MapStruct是一个用于Java的代码生成库，它基于注解处理器在编译时生成类型安全且高性能的对象映射代码,MapStruct可以帮助开发者减少手动编写繁琐的JavaBean之间的转换代码，提高代码的可读性和维护性。
MapStruct 一文读懂
zhouzhiwengang的专栏
10-21 3351
MapStruct是基于JSR269规范的一个Java注解处理器，用于为Java Bean生成类型安全且高性能的映射。它基于编译阶段生成get/set代码，此实现过程中没有反射，不会造成额外的性能损失。= null?}}}}}温馨提示：可以使用多个类有时需要在某些映射方法之前或之后应用自定义逻辑。MapStruct提供了两种方法：装饰器允许对特定映射方法进行类型安全的自定义，而映射前和映射后生命周期方法则允许对具有给定源或目标类型的映射方法进行通用的自定义。
mapstruct-idea:IntelliJ IDEA插件，可与MapStruct一起使用
05-02
MapStruct是一个Java用于为Java Bean类生成类型安全和高性能的映射器。 要了解有关MapStruct的更多信息，请查看存储库或 特征 代码完成 完成@Mapping注释中的target和source属性（嵌套属性也可以使用） @...
mapstruct-spring-extensions-example
03-29
MapStruct 是一个流行的 Java 库，它自动化了对象到对象映射的过程，极大地简化了代码中的数据转换工作。Spring Extensions 是 MapStruct 的扩展，旨在更好地集成到 Spring 框架中，提供更丰富的功能和便利性。这个...
mapstruct-spi-protobuf:Mapstruct的Protobuf访问器命名策略
03-31
用于协议缓冲区的Mapstruct SPI实现 这种命名策略有助于在您的域类和protobuf类之间生成有效的映射代码。 无论和类支载。 注意：取决于mapstruct 1.4.0.CR1ProtobufAccessor命名策略扩展...
mapstruct-demo:该项目说明了如何使用mapstruct API自动执行Java映射
05-19
该项目说明了如何使用mapstruct API自动执行Java映射 什么是MapStruct MapStruct是一个代码生成器，它基于约定优于配置的方法极大地简化了Java bean类型之间映射的实现。 生成的映射代码使用简单的方法调用，因此...
【项目实战】基于Java的代码生成器——MapStruct入门介绍
本本本添哥
04-10 348
MapStruct是一个非常实用的Java注解处理器，可以大大简化Java对象之间的转换工作。通过使用MapStruct，可以提高开发效率、减少错误，并且具有良好的类型安全和性能表现。
java mapstruct详解_Mapstruct源码解析- 框架实现原理
weixin_35125814的博客
02-24 1914
只有用过Mapstruct才知道它是有多么的好用与顺手。本篇主要讲述Mapstuct的实现原理，它是怎么去生成转换代码的过程，让大家对这个框架的实现原理有个比较透彻的了解。1. Java动态编译与JSR 269首先，我们先重温下java的编译过程：Java源代码-->编译器-->jvm可执行的Java字节码(即虚拟指令)-->jvm-->jvm中解释器-->机器可执行...
MapStruct：Java代码转换的终极武器
赵KK的博客
04-30 1066
MapStruct是一个代码生成工具，它使用注解处理器在编译时生成映射代码，从而避免了手动编写映射逻辑的需要。MapStruct还支持自定义表达式，允许开发者指定复杂的映射逻辑。@Mapper开发者通过定义接口，并在接口方法上使用@Mapping注解来指定映射规则。MapStruct会根据这些规则生成实际的映射代码。
Java实体映射工具MapStruct
赵广陆
03-09 814
1 项目中关于Entity、VO、DTO的认识和应用 1、entity 里的每一个字段，与数据库相对应， 2、vo 里的每一个字段，是和你前台 html 页面相对应， 3、dto 这是用来转换从 entity 到 vo，或者从 vo 到 entity 的中间的东西 。（DTO中拥有的字段应该是entity中或者是vo中的一个子集） 举个例子： 你的html页面上有三个字段，name，pass，age 你的数据库表里，有两个字段，name，pass ， 注意没有 age。 而你的 vo 里，就应该有下面三个成
一文读懂MapStruct 1.5.5.Final
qq_27890899的博客
06-30 1784
我们在平时项目开发过程中会经常这样的情况，从数据库中查出来的PO对象中包含很多字段，但是在业务处理过程中需要处理的DTO包含PO中的部分字段，或者返回给前端的VO为DTO的部分字段，这就需要Class类转化，如果用构造器或者get()/set()方法，将会写大量冗余代码并且容易出错。面对这样的场景，采用MapStruct插件处理类转换是一个绝佳的选择。MapStruct 是一个注释处理器，用于生成类型安全、高性能和无依赖的 Bean 映射代码。
对象之间互相拷贝效率最高工具（mapstruct）
weixin_43811057的博客
09-10 1188
1、干掉 BeanUtils！试试这款 Bean 自动映射工具，真心强大 2、mapstruct最佳实践 3、springboot整合mapstruct 4、SpringBoot 2.4.1整合 MapStruct 详细教程
mapstruct使用及@Mapper(componentModel=“Spring“)
qq_39535439的博客
06-12 3820
mapstruct、@Mapper(componentModel="Spring")
mapstruct-plus
07-29
MapStruct-Plus是一个基于MapStruct的增强版本，它是一个Java注解处理器，用于生成类型安全的映射代码。MapStruct-Plus提供了一些额外的功能和特性，以便更方便地进行对象之间的映射。 相对于原始的MapStruct，MapStruct-Plus提供了以下一些增强功能： 1. 嵌套映射支持：MapStruct-Plus允许在对象之间进行深度嵌套映射，并且可以自动创建嵌套对象。 2. 映射策略：MapStruct-Plus允许使用自定义的映射策略来处理特定的映射场景，例如条件映射、默认值设置等。 3. 动态映射：MapStruct-Plus支持动态映射，可以根据运行时的条件来确定映射规则。 4. 枚举映射：MapStruct-Plus提供了更灵活的枚举映射支持，可以自定义枚举值之间的转换规则。 5. 集合映射：MapStruct-Plus提供了更强大的集合映射功能，支持集合类型之间的映射、元素类型转换等。 总的来说，MapStruct-Plus扩展了MapStruct的功能，使得对象之间的映射更加灵活、方便，并提供一些额外的特性来处理更复杂的映射场景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值