MapStruct学习笔记

最新推荐文章于 2024-09-30 09:20:09 发布
最新推荐文章于 2024-09-30 09:20:09 发布
阅读量9.2k 收藏 13
点赞数 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vtnews/article/details/80678533
版权 
MapStruct版本号是1.2.0.Final
http://mapstruct.org/documentation/stable/reference/html/

学习mapstruct主要就是看文档，还有一个小窍门是编译之后，会直接在相应的包下生成一个xxxImpl.class，直接查看此类就可以了

项目配置

最小化的配置：

...
plugins {
    ...
    id 'net.ltgt.apt' version '0.8'
}
dependencies {
    ...
    compile 'org.mapstruct:mapstruct-jdk8:1.2.0.Final'

    apt 'org.mapstruct:mapstruct-processor:1.2.0.Final'
}
...
compileJava {
    options.compilerArgs = [
        '-Amapstruct.suppressGeneratorTimestamp=true',
        '-Amapstruct.suppressGeneratorVersionInfoComment=true'
    ]
}
...

我的整个配置文件：

buildscript {
    ext {
        spring_boot_version = "1.5.9.RELEASE"
        mapstruct_version = "1.2.0.Final"
        apt_plugin_version = "0.15"
        lombok_version = "1.16.20"
    }
    repositories {
        mavenLocal()
        mavenCentral()
        maven { url "http://maven.aliyun.com/nexus/content/groups/public" }
    }
    dependencies {
        classpath("net.ltgt.gradle:gradle-apt-plugin:${apt_plugin_version}")
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${spring_boot_version}")
    }
}

apply plugin: "java"
apply plugin: "org.springframework.boot"
apply plugin: "net.ltgt.apt"

sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    compile "org.springframework.boot:spring-boot-starter-web:${spring_boot_version}"
    compile "org.mapstruct:mapstruct-jdk8:${mapstruct_version}"
    compileOnly "org.projectlombok:lombok:${lombok_version}"
    annotationProcessor "org.mapstruct:mapstruct-processor:${mapstruct_version}"
    annotationProcessor "org.projectlombok:lombok:${lombok_version}"
    testCompile 'org.testng:testng:6.10', 'org.easytesting:fest-assert:1.4'
}

tasks.withType(JavaCompile) {
    options.compilerArgs = [
            '-Amapstruct.suppressGeneratorTimestamp=true',
            '-Amapstruct.defaultComponentModel=spring'
    ]
}

task wrapper(type: Wrapper) {
    gradleVersion = '3.4'
}

test {
    useTestNG()
}

MapStruct 全局配置

  • mapstruct. suppressGeneratorTimestamp：false/true
  • mapstruct. suppressGeneratorVersionInfoComment：false/true
  • mapstruct.defaultComponentModel：default/cdi/spring/jsr330，使用spring时，需要spring-boot支持
  • mapstruct.unmappedTargetPolicy：ERROR/WARN/IGNORE

操作

Mapper

基础操作

@Mapper
public interface CarMapper {

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

    @Mapping(source = "name", target = "fullName")
    PersonDto personToPersonDto(Person person);
}

在CarMapper中的方法carToCarDto 是转换的入口函数。@Mapping 注解中，source是Car类，target是CarDto类。注解含义是Car类的make变量，CarDto中manufacturer相互转换。其中Car中有一个driver变量，是一个Person类。做转换时，会自动调用personToPersonDto 做转换（具体原理需要查看源码）。

interface和abstract

@Mapper
public interface CarMapper {

    @Mappings({...})
    CarDto carToCarDto(Car car);

    default PersonDto personToPersonDto(Person person) {
        //hand-written mapping logic
    }
}

在Java 8时，可以在接口中指定default方法和实现转换逻辑，我们可以这样写mapper。他会调用默认方法去转换Person。

@Mapper
public abstract class CarMapper {

    @Mappings(...)
    public abstract CarDto carToCarDto(Car car);

    public PersonDto personToPersonDto(Person person) {
        //hand-written mapping logic
    }
}

抽象类，也同样可以达到这个效果。

多参数

@Mapper
public interface AddressMapper {

    @Mappings({
        @Mapping(source = "person.description", target = "description"),
        @Mapping(source = "address.houseNo", target = "houseNumber")
    })
    DeliveryAddressDto personAndAddressToDeliveryAddressDto(Person person, Address address);
}

使用原有对象

@Mapper
public interface CarMapper {

    void updateCarFromDto(CarDto carDto, @MappingTarget Car car);
}

直接访问变量

@Mapper
public interface CustomerMapper {

    CustomerMapper MAPPER = Mappers.getMapper( CustomerMapper.class );

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

    @InheritInverseConfiguration
    CustomerDto fromCustomer(Customer customer);
}

获取Mapper

mapper factory

@Mapper
public interface CarMapper {

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

    CarDto carToCarDto(Car car);
}

Car car = ...;
CarDto dto = CarMapper.INSTANCE.carToCarDto( car );

cdi

componentModel对应值参照前文表格。

@Mapper(componentModel = "cdi")
public interface CarMapper {

    CarDto carToCarDto(Car car);
}

@Inject
private CarMapper mapper;

数值类型转换

隐式类型转换

支持的类型有很多种（Boolean，Integer，String，Date），详情见文档

@Mapper
public interface CarMapper {

    @Mapping(source = "price", numberFormat = "$#.00")
    CarDto carToCarDto(Car car);

    @IterableMapping(numberFormat = "$#.00")
    List<String> prices(List<Integer> prices);

    @Mapping(source = "power", numberFormat = "#.##E0")
    CarDto carToCarDto(Car car);

    @Mapping(source = "manufacturingDate", dateFormat = "dd.MM.yyyy")
    CarDto carToCarDto(Car car);

    @IterableMapping(dateFormat = "dd.MM.yyyy")
    List<String> stringListToDateList(List<Date> dates);
}

Object转换

@Mapper
public interface CarMapper {

    CarDto carToCarDto(Car car);

    PersonDto personToPersonDto(Person person);
}

转换的规则：

  • source和target类型相同，直接拷贝。含有List类型的属性，会复制一个新的List到target
  • source(Atype attr)和target(Btype attr)类型不相同，就去查找mapper（当前或其他）中，是否含有Btype func(Atype attr) ，找到就使用。
  • 如果没有找到func函数，看是否有内置的转换(a built-in conversion)
  • 如果还是没有，则尝试自动创建一个mapping去处理。此配置会取消自动创建@Mapper( disableSubMappingMethodsGeneration = true )
  • 如果创建失败，则会出错

根据转换规则，可以很方便写出处理的方法，能满足任何定制化需求(也是mapstruct强大的地方，尽量让人避免编码。迫不得已进行编码时，也只需要定制化小部分就行，自动帮你组装)。

不同名称的变量转换

@Mapper
public interface FishTankMapper {

    @Mappings({
        @Mapping(target = "fish.kind", source = "fish.type"),
        @Mapping(target = "fish.name", ignore = true),
        @Mapping(target = "ornament", source = "interior.ornament"),
        @Mapping(target = "material.materialType", source = "material"),
        @Mapping(target = "quality.report.organisation.name", source = "quality.report.organisationName")
    })
    FishTankDto map( FishTank source );
}

@Mapper
public interface FishTankMapperWithDocument {

    @Mappings({
        @Mapping(target = "fish.kind", source = "fish.type"),
        @Mapping(target = "fish.name", expression = "java(\"Jaws\")"),
        @Mapping(target = "plant", ignore = true ),
        @Mapping(target = "ornament", ignore = true ),
        @Mapping(target = "material", ignore = true),
        @Mapping(target = "quality.document", source = "quality.report"),
        @Mapping(target = "quality.document.organisation.name", constant = "NoIdeaInc" )
    })
    FishTankWithNestedDocumentDto map( FishTank source );

}

使用其他mapper

public class DateMapper {

    public String asString(Date date) {
        return date != null ? new SimpleDateFormat( "yyyy-MM-dd" )
            .format( date ) : null;
    }

    public Date asDate(String date) {
        try {
            return date != null ? new SimpleDateFormat( "yyyy-MM-dd" )
                .parse( date ) : null;
        }
        catch ( ParseException e ) {
            throw new RuntimeException( e );
        }
    }
}

@Mapper(uses=DateMapper.class)
public class CarMapper {

    CarDto carToCarDto(Car car);
}

传递目标类型@TargetType

@ApplicationScoped // CDI component model
public class ReferenceMapper {

    @PersistenceContext
    private EntityManager entityManager;

    public <T extends BaseEntity> T resolve(Reference reference, @TargetType Class<T> entityClass) {
        return reference != null ? entityManager.find( entityClass, reference.getPk() ) : null;
    }

    public Reference toReference(BaseEntity entity) {
        return entity != null ? new Reference( entity.getPk() ) : null;
    }
}

@Mapper(componentModel = "cdi", uses = ReferenceMapper.class )
public interface CarMapper {

    Car carDtoToCar(CarDto carDto);
}

//生成的代码
@ApplicationScoped
public class CarMapperImpl implements CarMapper {

    @Inject
    private ReferenceMapper referenceMapper;

    @Override
    public Car carDtoToCar(CarDto carDto) {
        if ( carDto == null ) {
            return null;
        }

        Car car = new Car();

        car.setOwner( referenceMapper.resolve( carDto.getOwner(), Owner.class ) );
        // ...

        return car;
    }
}

传递@Context到Mapper中

public abstract CarDto toCar(Car car, @Context Locale translationLocale);

protected OwnerManualDto translateOwnerManual(OwnerManual ownerManual, @Context Locale locale) {
    // manually implemented logic to translate the OwnerManual with the given Locale
}

//生成后的代码
public CarDto toCar(Car car, Locale translationLocale) {
    if ( car == null ) {
        return null;
    }

    CarDto carDto = new CarDto();

    carDto.setOwnerManual( translateOwnerManual( car.getOwnerManual(), translationLocale );
    // more generated mapping code

    return carDto;
}

@Qualifier指定处理

import org.mapstruct.Qualifier;

@Qualifier
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface TitleTranslator {
}

import org.mapstruct.Qualifier;

@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface EnglishToGerman {
}

import org.mapstruct.Qualifier;

@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface GermanToEnglish {
}

@Mapper( uses = Titles.class )
public interface MovieMapper {

     @Mapping( target = "title", qualifiedBy = { TitleTranslator.class, EnglishToGerman.class } )
     GermanRelease toGerman( OriginalRelease movies );

}
可以这样使用
@TitleTranslator
public class Titles {

    @EnglishToGerman
    public String translateTitleEG(String title) {
        // some mapping logic
    }

    @GermanToEnglish
    public String translateTitleGE(String title) {
        // some mapping logic
    }
}
或者这样使用
@Named("TitleTranslator")
public class Titles {

    @Named("EnglishToGerman")
    public String translateTitleEG(String title) {
        // some mapping logic
    }

    @Named("GermanToEnglish")
    public String translateTitleGE(String title) {
        // some mapping logic
    }
}

@Mapper( uses = Titles.class )
public interface MovieMapper {

     @Mapping( target = "title", qualifiedByName = { "TitleTranslator", "EnglishToGerman" } )
     GermanRelease toGerman( OriginalRelease movies );

}

集合的mapping

maps

map中的数值转换
public interface SourceTargetMapper {

    @MapMapping(valueDateFormat = "dd.MM.yyyy")
    Map<String, String> longDateMapToStringStringMap(Map<Long, Date> source);
}

//生成代码
@Override
public Map<Long, Date> stringStringMapToLongDateMap(Map<String, String> source) {
    if ( source == null ) {
        return null;
    }

    Map<Long, Date> map = new HashMap<Long, Date>();

    for ( Map.Entry<String, String> entry : source.entrySet() ) {

        Long key = Long.parseLong( entry.getKey() );
        Date value;
        try {
            value = new SimpleDateFormat( "dd.MM.yyyy" ).parse( entry.getValue() );
        }
        catch( ParseException e ) {
            throw new RuntimeException( e );
        }

        map.put( key, value );
    }

    return map;
}

这里写图片描述

这里写图片描述

Stream的mapping

@Mapper
public interface CarMapper {

    Set<String> integerStreamToStringSet(Stream<Integer> integers);

    List<CarDto> carsToCarDtos(Stream<Car> cars);

    CarDto carToCarDto(Car car);
}

//代码生成
@Override
public Set<String> integerStreamToStringSet(Stream<Integer> integers) {
    if ( integers == null ) {
        return null;
    }

    return integers.stream().map( integer -> String.valueOf( integer ) )
        .collect( Collectors.toCollection( HashSet<String>::new ) );
}

@Override
public List<CarDto> carsToCarDtos(Stream<Car> cars) {
    if ( cars == null ) {
        return null;
    }

    return integers.stream().map( car -> carToCarDto( car ) )
        .collect( Collectors.toCollection( ArrayList<CarDto>::new ) );
}

Mapping Values

enum type

@Mapper
public interface OrderMapper {

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

    @ValueMappings({
        @ValueMapping(source = "EXTRA", target = "SPECIAL"),
        @ValueMapping(source = "STANDARD", target = "DEFAULT"),
        @ValueMapping(source = "NORMAL", target = "DEFAULT")
    })
    ExternalOrderType orderTypeToExternalOrderType(OrderType orderType);
}

// GENERATED CODE
public class OrderMapperImpl implements OrderMapper {

    @Override
    public ExternalOrderType orderTypeToExternalOrderType(OrderType orderType) {
        if ( orderType == null ) {
            return null;
        }

        ExternalOrderType externalOrderType_;

        switch ( orderType ) {
            case EXTRA: externalOrderType_ = ExternalOrderType.SPECIAL;
            break;
            case STANDARD: externalOrderType_ = ExternalOrderType.DEFAULT;
            break;
            case NORMAL: externalOrderType_ = ExternalOrderType.DEFAULT;
            break;
            case RETAIL: externalOrderType_ = ExternalOrderType.RETAIL;
            break;
            case B2B: externalOrderType_ = ExternalOrderType.B2B;
            break;
            default: throw new IllegalArgumentException( "Unexpected enum constant: " + orderType );
        }

        return externalOrderType_;
    }
}

@Mapper
public interface SpecialOrderMapper {

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

    @ValueMappings({
        @ValueMapping( source = MappingConstants.NULL, target = "DEFAULT" ),
        @ValueMapping( source = "STANDARD", target = MappingConstants.NULL ),
        @ValueMapping( source = MappingConstants.ANY_REMAINING, target = "SPECIAL" )
    })
    ExternalOrderType orderTypeToExternalOrderType(OrderType orderType);
}

对象工厂

public class DtoFactory {

     public CarDto createCarDto() {
         return // ... custom factory logic
     }
}

public class EntityFactory {

     public <T extends BaseEntity> T createEntity(@TargetType Class<T> entityClass) {
         return // ... custom factory logic
     }
}

@Mapper(uses= { DtoFactory.class, EntityFactory.class } )
public interface CarMapper {

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

    CarDto carToCarDto(Car car);

    Car carDtoToCar(CarDto carDto);
}

//生成代码
public class CarMapperImpl implements CarMapper {

    private final DtoFactory dtoFactory = new DtoFactory();

    private final EntityFactory entityFactory = new EntityFactory();

    @Override
    public CarDto carToCarDto(Car car) {
        if ( car == null ) {
            return null;
        }

        CarDto carDto = dtoFactory.createCarDto();

        //map properties...

        return carDto;
    }

    @Override
    public Car carDtoToCar(CarDto carDto) {
        if ( carDto == null ) {
            return null;
        }

        Car car = entityFactory.createEntity( Car.class );

        //map properties...

        return car;
    }
}

高级技巧

默认值

@Mapper(uses = StringListMapper.class)
public interface SourceTargetMapper {

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

    @Mappings( {
        @Mapping(target = "stringProperty", source = "stringProp", defaultValue = "undefined"),
        @Mapping(target = "longProperty", source = "longProp", defaultValue = "-1"),
        @Mapping(target = "stringConstant", constant = "Constant Value"),
        @Mapping(target = "integerConstant", constant = "14"),
        @Mapping(target = "longWrapperConstant", constant = "3001"),
        @Mapping(target = "dateConstant", dateFormat = "dd-MM-yyyy", constant = "09-01-2014"),
        @Mapping(target = "stringListConstants", constant = "jack-jill-tom")
    } )
    Target sourceToTarget(Source s);
}

表达式

可以加入java代码：

@Mapper
public interface SourceTargetMapper {

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

    @Mapping(target = "timeAndFormat",
         expression = "java( new org.sample.TimeAndFormat( s.getTime(), s.getFormat() ) )")
    Target sourceToTarget(Source s);
}

imports org.sample.TimeAndFormat;

@Mapper( imports = TimeAndFormat.class )
public interface SourceTargetMapper {

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

    @Mapping(target = "timeAndFormat",
         expression = "java( new TimeAndFormat( s.getTime(), s.getFormat() ) )")
    Target sourceToTarget(Source s);
}

定义返回类型

@Mapper( uses = FruitFactory.class )
public interface FruitMapper {

    @BeanMapping( resultType = Apple.class )
    Fruit map( FruitDto source );

}

public class FruitFactory {

    public Apple createApple() {
        return new Apple( "Apple" );
    }

    public Banana createBanana() {
        return new Banana( "Banana" );
    }
}

异常

@Mapper(uses = HandWritten.class)
public interface CarMapper {

    CarDto carToCarDto(Car car) throws GearException;
}

public class HandWritten {

    private static final String[] GEAR = {"ONE", "TWO", "THREE", "OVERDRIVE", "REVERSE"};

    public String toGear(Integer gear) throws GearException, FatalException {
        if ( gear == null ) {
            throw new FatalException("null is not a valid gear");
        }

        if ( gear < 0 && gear > GEAR.length ) {
            throw new GearException("invalid gear");
        }
        return GEAR[gear];
    }
}

// GENERATED CODE
@Override
public CarDto carToCarDto(Car car) throws GearException {
    if ( car == null ) {
        return null;
    }

    CarDto carDto = new CarDto();
    try {
        carDto.setGear( handWritten.toGear( car.getGear() ) );
    }
    catch ( FatalException e ) {
        throw new RuntimeException( e );
    }

    return carDto;
}

装饰器


@Mapper
@DecoratedWith(PersonMapperDecorator.class)
public interface PersonMapper {

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

    PersonDto personToPersonDto(Person person);

    AddressDto addressToAddressDto(Address address);
}

public abstract class PersonMapperDecorator implements PersonMapper {

    private final PersonMapper delegate;

    public PersonMapperDecorator(PersonMapper delegate) {
        this.delegate = delegate;
    }

    @Override
    public PersonDto personToPersonDto(Person person) {
        PersonDto dto = delegate.personToPersonDto( person );
        dto.setFullName( person.getFirstName() + " " + person.getLastName() );
        return dto;
    }
}

before-mapping和after-mapping

@Mapper
public abstract class VehicleMapper {

    @BeforeMapping
    protected void flushEntity(AbstractVehicle vehicle) {
        // I would call my entity manager's flush() method here to make sure my entity
        // is populated with the right @Version before I let it map into the DTO
    }

    @AfterMapping
    protected void fillTank(AbstractVehicle vehicle, @MappingTarget AbstractVehicleDto result) {
        result.fuelUp( new Fuel( vehicle.getTankCapacity(), vehicle.getFuelType() ) );
    }

    public abstract CarDto toCarDto(Car car);
}

// Generates something like this:
public class VehicleMapperImpl extends VehicleMapper {

    public CarDto toCarDto(Car car) {
        flushEntity( car );

        if ( car == null ) {
            return null;
        }

        CarDto carDto = new CarDto();
        // attributes mapping ...

        fillTank( car, carDto );

        return carDto;
    }
}

@Mapper
public abstract class VehicleMapper {

    @PersistenceContext
    private EntityManager entityManager;

    @AfterMapping
    protected <T> T attachEntity(@MappingTarget T entity) {
        return entityManager.merge(entity);
    }

    public abstract CarDto toCarDto(Car car);
}

// Generates something like this:
public class VehicleMapperImpl extends VehicleMapper {

    public CarDto toCarDto(Car car) {
        if ( car == null ) {
            return null;
        }

        CarDto carDto = new CarDto();
        // attributes mapping ...

        CarDto target = attachEntity( carDto );
        if ( target != null ) {
            return target;
        }

        return carDto;
    }
}
vtnews
关注
MapStruct属性复制框架学习笔记
墨者的博客
08-17 1547
Java中DO,VO,DTO结构一样，但在意义上或者说功能上不一样，DO定义实体，VO定义视图层数据返回，DTO用于查询实体参数，通常进行转化可以自写setter/getter方法或者使用BeanUtils的属性复制方法（运行期利用反射），具体原理可以查看源码或者百度。MapStruct是同学推荐的一个开源工具，是在编译期生成对应的实体类来完成属性复制，使用方便，这里做个简单的笔记...
mapstruct 使用总结
chris
11-27 3305
介绍 mapstruct 专门用来处理 domin 实体类与 model 类的属性映射的，我们只需定义 mapper 接口，mapstruct 在编译的时候就会自动的帮我们实现这个映射接口，避免了麻烦复杂的映射实现 简单说：快捷实现domain 实体与DTO 、VO实体的映射转化。 使用 引入 在pom.xml中引入jar包 <!--mapstruct核心--> <dependency> <groupId>org.mapstruct</groupId&gt
mapstruct-processor-1.2.0.Final-API文档-中英对照版.zip
06-12
赠送jar包：mapstruct-processor-1.2.0.Final.jar； 赠送原API文档：mapstruct-processor-1.2.0.Final-javadoc.jar； 赠送源代码：mapstruct-processor-1.2.0.Final-sources.jar； 赠送Maven依赖信息文件：mapstruct-processor-1.2.0.Final.pom； 包含翻译后的API文档：mapstruct-processor-1.2.0.Final-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：org.mapstruct:mapstruct-processor:1.2.0.Final； 标签：mapstruct、processor、中英对照文档、jar包、java； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。 双语对照，边学技术、边学英语。
实体映射工具：MapStruct使用的正确姿势
Java笔记虾
03-26 1757
来源：https://blog.csdn.net/qq122516902目录MapStruct是用来做什么的？使用MapStruct解决上述问题添加默认方法可以使用abstract cla...
【微服务】SpringBoot 整合对象映射工具 MapStruct 使用详解
最新发布
小蜗牛的珍贵百宝箱
09-30 1400
MapStruct 是一个用于 Java Bean 之间转换的代码生成器，能够自动生成对象映射的代码。在编译时，MapStruct 会生成高效的、类型安全的代码来实现对象之间的映射，无需运行时依赖。它可以帮助开发者节省手动编写转换逻辑的时间，同时保证代码的性能和可读性。接下来，我们定义一个UserMapper接口，通过 MapStruct 的@Mapper注解来表示这是一个映射接口。@Mapper// 将 User 映射为 UserDTO// 将 UserDTO 映射为 User。
MapStruct 使用及通用实例化工具类
学习学习学习学习
07-17 1891
mapstruct
MapStruct使用指南
qq_28344049的博客
12-30 4161
MapStruct使用指南
Mapstruct详细使用说明
热门推荐
liuerchong的博客
02-18 1万+
前言 在使用分层或者分模块化的项目中，我们可能定义各种各样的O，例如：DO，VO，DTO等等。我们在进行这些对象之间的拷贝时，通过手动写get/set方法进行属性之间的赋值。因为他们之间的属性大部分都是相同的，不仅浪费时间，并且还有大量重复代码。所以，各种框架都添加的对象之间的拷贝的工具类。例如： Spring自带了BeanUtils Apatch自带的BeanUtils Apatch自带的PropertyUtils mapstruct提供Mappers 本文主要介绍MapStruct的基础知识、M
【精品】基于 MapStruct实现 JavaBean克隆及属性拷贝
2401_84048416的博客
04-18 459
还有更多的Redis、MySQL、JVM、Kafka、微服务、Spring全家桶等学习笔记这里就不一一列举出来。
Go 学习笔记 第四版 pdf
07-01
根据提供的信息，我们可以总结出这份文档是关于Go语言学习笔记的部分内容，主要涵盖了Go语言的基础概念、语法结构、数据类型以及并发模型等关键知识点。以下是对这些知识点的详细解析： ### Go语言概述 Go（也称作...
go学习笔记-文档-文档
07-21
本文档集合了关于Go语言的学习笔记，旨在帮助读者全面理解并掌握Go语言的核心概念、语法特性以及实际应用。 一、基础语法 Go语言的语法简洁明了，易于上手。它采用了C风格的语法，但增加了诸如类型推断（Type ...
MapStruct 1.2.0 参考指南
07-12
MapStruct是一个代码生成器的工具类，简化了不同的Java Bean之间映射的处理，所以映射指的就是从一个实体变化成一个实体。（带目录标签）
实体映射最强工具类：MapStruct 真香！
程序员高级码农的博客
01-11 914
现在有这么个场景，从数据库查询出来了一个user对象（包含id，用户名，密码，手机号，邮箱，角色这些字段）和一个对应的角色对象role（包含id，角色名，角色描述这些字段），现在在controller需要用到user对象的id，用户名，和角色对象的角色名三个属性。有时候，在对象转换的时候可能会出现这样一个问题，就是源对象中的类型是Boolean类型，而目标对象类型是String类型，这种情况可以通过。标注的类UserRoleDto 为目标类，user类为源类，调用此方法，会把源类中的属性更新到目标类中。
告别BeanUtils，Mapstruct从入门到精通
淘系技术
09-01 4466
如果你现在还在使用BeanUtils，看了本文，也会像我一样，从此改用Mapstruct。对象之间的属性拷贝，之前用的是Spring的BeanUtils，有一次，在学习领域驱动设计的时候，看了一位大佬的文章，他在文章中提到使用Mapstruct做DO和Entity的相互转换，出于好奇，后来就去了解了一下Mapstruct，发现这个工具确实优秀，所以果断弃用BeanUtils。如果你现在还在使用Be...
秒懂Java之实体转化利器MapStruct详解
ShuSheng007的程序人生
01-12 1557
由于现代程序在追求扩展和维护性时很多采用分层的设计结构，所以在写程序时候需要在各种实体之间互相转换，而他们之间很多时候在业务或者技术架构上区别较大，在具体的属性上差别却很小。例如将Programer转换为由于这些是繁琐易错且没有技术含量的编码工作，所以聪明的程序员就会寻求不断简化它的方法，MapStruct就是其中的一个利器。MapStruct是一个用于Java的Bean的映射器，是它是基于注解的，而且是编译时APT（annotation processor tool）。
MapStruct系列（6）-映射集合、映射Stream流、映射枚举
记录知识、锤炼自我
04-14 3313
映射集合 List Set 集合类型（的映射List，Set等等）以相同的方式映射豆类型，即通过定义与在映射器接口所需的源和目标类型的映射方法进行。MapStruct 支持来自Java Collection Framework 的各种可迭代类型。 生成的代码将包含一个循环，该循环遍历源集合，转换每个元素并将其放入目标集合。如果在给定的映射器或其使用的映射器中找到集合元素类型的映射方法，则调用此方法来执行元素转换。或者，如果存在源元素和目标元素类型的隐式转换，则将调用此转换例程。下面显示了一个示例： 具有集合
MapStruct的用法总结及示例
小蜜蜂1010的博客
06-10 3692
比dozer更好用的java对象属性映射复制工具MapStuct的用法及代码示例
mapstruct框架和mappings注解的使用
qq_41358574的博客
07-18 3400
mapstruct框架
MapStruct 教程
让每一行代码都有改变世界的力量
03-03 2281
MapStruct 支持装饰器模式，允许你在不修改生成的 Mapper 实现的情况下增强 Mapper 的功能。通过定义一个实现了 Mapper 接口的类，并在该类中添加额外的映射逻辑，你可以扩展 Mapper 的行为。如果需要自定义嵌套对象或集合的映射行为，我们可以在 Mapper 接口中定义相应的方法，并使用。这个参数代表了被装饰的 Mapper 实现，我们可以在装饰器类中调用它的方法来执行基本的映射操作，并添加自定义的逻辑。当然，你也可以通过依赖注入的方式将 Mapper 注入到你的组件中。
org.mapstruct.factory
07-28
- *1* *3* [MapStruct超级简单的学习笔记](https://blog.csdn.net/weixin_45623983/article/details/102513781)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值