精华内容
下载资源
问答
  • mapstruct

    千次阅读 2018-08-06 21:29:36
    配置MapStruct 到目前为止我们的准备工作差不多完成了,下面我们开始配置使用MapStruct。我们的最终目的是为了返回一个自定义的DTO实体,那么我们就先来创建这个DTO,DTO的代码如下所示: package ...

    配置MapStruct

    到目前为止我们的准备工作差不多完成了,下面我们开始配置使用MapStruct。我们的最终目的是为了返回一个自定义的DTO实体,那么我们就先来创建这个DTO,DTO的代码如下所示:

    package com.yuqiyu.chapter30.dto;
    
    import lombok.Data;
    
    /**
     * 转换Dto
     */
    @Data
    public class GoodInfoDTO
    {
        //商品编号
        private String goodId;
        //商品名称
        private String goodName;
        //商品价格
        private double goodPrice;
        //类型名称
        private String typeName;
    }
    

    可以看到GoodInfoDTO实体内集成了商品信息、商品类型两张表内的数据,对应查询出信息后,我们需要使用MapStruct自动映射到GoodInfoDTO。

    创建Mapper

    Mapper这个定义一般是被广泛应用到MyBatis半自动化ORM框架上,而这里的Mapper跟Mybatis没有关系。下面我们先来看下代码,如下所示:

    package com.yuqiyu.chapter30.mapper;
    
    import com.yuqiyu.chapter30.bean.GoodInfoBean;
    import com.yuqiyu.chapter30.bean.GoodTypeBean;
    import com.yuqiyu.chapter30.dto.GoodInfoDTO;
    import org.mapstruct.Mapper;
    import org.mapstruct.Mapping;
    import org.mapstruct.Mappings;
    
    /**
     * 配置映射
     */
    @Mapper(componentModel = "spring")
    //@Mapper
    public interface GoodInfoMapper
    {
        //public static GoodInfoMapper MAPPER = Mappers.getMapper(GoodInfoMapper.class);
    
        @Mappings({
                @Mapping(source = "type.name",target = "typeName"),
                @Mapping(source = "good.id",target = "goodId"),
                @Mapping(source = "good.title",target = "goodName"),
                @Mapping(source = "good.price",target = "goodPrice")
        })
        public GoodInfoDTO from(GoodInfoBean good, GoodTypeBean type);
    }
    

    可以看到GoodInfoMapper是一个接口的形式存在的,当然也可以是一个抽象类,如果你需要在转换的时候才用个性化的定制的时候可以采用抽象类的方式,相应的代码配置官方文档已经声明。
    @Mapper注解是用于标注接口、抽象类是被MapStruct自动映射的标识,只有存在该注解才会将内部的接口方法自动实现。
    MapStruct为我们提供了多种的获取Mapper的方式,比较常用的两种分别是

    默认配置

    默认配置,我们不需要做过多的配置内容,获取Mapper的方式就是采用Mappers通过动态工厂内部反射机制完成Mapper实现类的获取。
    默认方式获取Mapper如下所示:

    //Mapper接口内部定义
    public static GoodInfoMapper MAPPER = Mappers.getMapper(GoodInfoMapper.class);
    
    //外部调用
    GoodInfoMapper.MAPPER.from(goodBean,goodTypeBean);
    

    Spring方式配置

    Spring方式我们需要在@Mapper注解内添加componentModel属性值,配置后在外部可以采用@Autowired方式注入Mapper实现类完成映射方法调用。
    Spring方式获取Mapper如下所示:

    //注解配置
    @Mapper(componentModel = "spring")
    
    //注入Mapper实现类
    @Autowired
    private GoodInfoMapper goodInfoMapper;
    
    //调用
    goodInfoMapper.from(goodBean,goodTypeBean);
    

    @Mappings & @Mapping

    在Mapper接口定义方法上面声明了一系列的注解映射@Mapping以及@Mappings,那么这两个注解是用来干什么工作的呢?
    @Mapping注解我们用到了两个属性,分别是source、target

    source代表的是映射接口方法内的参数名称,如果是基本类型的参数,参数名可以直接作为source的内容,如果是实体类型,则可以采用实体参数名.字段名的方式作为source的内容,配置如上面GoodInfoMapper内容所示。

    target代表的是映射到方法方法值内的字段名称,配置如上面GoodInfoMapper所示。

    查看Mapper实现

    下面我们执行maven compile命令,到target/generated-sources/annotations目录下查看对应Mapper实现类,实现类代码如下所示:

    package com.yuqiyu.chapter30.mapper;
    
    import com.yuqiyu.chapter30.bean.GoodInfoBean;
    import com.yuqiyu.chapter30.bean.GoodTypeBean;
    import com.yuqiyu.chapter30.dto.GoodInfoDTO;
    import javax.annotation.Generated;
    import org.springframework.stereotype.Component;
    
    @Generated(
        value = "org.mapstruct.ap.MappingProcessor",
        date = "2017-08-20T12:52:52+0800",
        comments = "version: 1.2.0.CR1, compiler: javac, environment: Java 1.8.0_111 (Oracle Corporation)"
    )
    @Component
    public class GoodInfoMapperImpl implements GoodInfoMapper {
    
        @Override
        public GoodInfoDTO from(GoodInfoBean good, GoodTypeBean type) {
            if ( good == null && type == null ) {
                return null;
            }
    
            GoodInfoDTO goodInfoDTO = new GoodInfoDTO();
    
            if ( good != null ) {
                if ( good.getId() != null ) {
                    goodInfoDTO.setGoodId( String.valueOf( good.getId() ) );
                }
                goodInfoDTO.setGoodName( good.getTitle() );
                goodInfoDTO.setGoodPrice( good.getPrice() );
            }
            if ( type != null ) {
                goodInfoDTO.setTypeName( type.getName() );
            }
    
            return goodInfoDTO;
        }
    }
    
    

    MapStruct根据我们配置的@Mapping注解自动将source实体内的字段进行了调用target实体内字段的setXxx方法赋值,并且做出了一切参数验证。
    我们采用了Spring方式获取Mapper,在自动生成的实现类上MapStruct为我们自动添加了@ComponentSpring声明式注入注解配置。

    展开全文
  • MapStruct - 一篇就能上手 MapStruct

    万次阅读 热门讨论 2021-02-22 17:45:25
    MapStruct是满足JSR269规范的一个Java注解处理器,用于为Java Bean生成类型安全且高性能的映射。它基于编译阶段生成get/set代码,此实现过程中没有反射,不会造成额外的性能损失。 您所要做的就是定义一个mapper...

    简介

    MapStruct是满足JSR269规范的一个Java注解处理器,用于为Java Bean生成类型安全且高性能的映射。它基于编译阶段生成get/set代码,此实现过程中没有反射,不会造成额外的性能损失。

    您所要做的就是定义一个mapper接口(@Mapper),该接口用于声明所有必须的映射方法。在编译期间MapStruct会为该接口自动生成实现类。该实现类使用简单的Java方法调用来映射source-target对象,在此过程中没有反射或类似的行为发生。

    性能

    优点

    与手工编写映射代码相比

    • MapStruct通过生成冗长且容易出错的代码来节省时间。

    与动态映射框架相比

    • 简单泛型智能转换;
    • 效率高:无需手动 set/get 或 implements Serializable 以达到深拷贝;
    • 性能更高:使用简单的Java方法调用代替反射;
    • 编译时类型安全:只能映射相同名称或带映射标记的属性;
    • 编译时产生错误报告:如果映射不完整(存在未被映射的目标属性)或映射不正确(找不到合适的映射方法或类型转换)则会在编译时抛出异常。

    使用

    1、引入 Pom

    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-jdk8</artifactId>
        <version>1.2.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-processor</artifactId>
        <version>1.2.0.Final</version>
    </dependency>

    2、注入方式

    • Spring 注入方式
    /**
     * @author Lux Sun
     * @date 2021/2/22
     */
    @Mapper(componentModel = "spring")
    public interface ApiMapper {
    }
    • ClassLoader 加载方式
    /**
     * @author Lux Sun
     * @date 2021/2/22
     */
    @Mapper
    public interface ApiMapper {
        ApiMapper INSTANCE = Mappers.getMapper(ApiMapper.class);
    }

    3、案例(ApiVO 转 ApiDTO)

    ApiMapper

    /**
     * @author Lux Sun
     * @date 2021/2/22
     */
    @Mapper(componentModel = "spring")
    public interface ApiMapper {
        // ClassLoader 加载方式
        ApiMapper INSTANCE = Mappers.getMapper(ApiMapper.class);
    
        /**
         * ApiVO 转 ApiDTO
         * @param apiVO
         * @return com.chinadaas.platform.dsp.kernel.common.domain.dto.ApiDTO
         */
        @Mapping(source = "method", target = "apiMethod")
        ApiDTO apiVoToApiDto(ApiVO apiVO);
    }

    ApiMapperTest

    @Resource
    private ApiMapper apiMapper;
    
    /**
     * ApiVO 转 ApiDTO
     * @param
     * @return void
     */
    public void apiVoToApiDtoTest() {
        // 创建 ApiPOList
        ApiPO apiPO1 = ApiPO.builder().name("apiName1").build();
        List<ApiPO> apiPOList = Lists.newArrayList();
        apiPOList.add(apiPO1);
        
        // 创建 ApiConf
        ApiVO.ApiConf apiConf = ApiVO.ApiConf.builder().id("123456").build();
        
        // 创建数字 List
        List<Integer> numberList = Lists.newArrayList();
        numberList.add(1);
        numberList.add(2);
        
        // 创建 ApiVO
        ApiVO apiVO = ApiVO.builder().name("apiName").method(1)
                                    .apiPOList(apiPOList).apiConf(apiConf)
                                    .list(numberList).build();
        
        // 转换结果 ApiDTO
        // ClassLoader 调用方式
        ApiDTO apiDTO = ApiMapper.INSTANCE.apiVoToApiDto(apiVO);
        // Spring 调用方式
        // ApiDTO apiDTO = apiMapper.apiVoToApiDto(apiVO);
        System.out.println(apiDTO);
    }

    结果输出

    ApiDTO(name=apiName, apiMethod=1, apiConf=ApiDTO.ApiConf(id=123456, open=null), apiPOList=[ApiPO(name=apiName1, method=null, apiConf=null, apiPOList=null)], list=[1, 2])

    原理

    通过 JSR 269 Java注解处理器自动生成该文件

    ApiMapperImpl

    package com.chinadaas.platform.dsp.kernel.common.convert;
    import com.chinadaas.platform.dsp.kernel.common.domain.dto.ApiDTO;
    import com.chinadaas.platform.dsp.kernel.common.domain.dto.ApiDTO.ApiConf;
    import com.chinadaas.platform.dsp.kernel.common.domain.po.ApiPO;
    import com.chinadaas.platform.dsp.kernel.common.domain.vo.ApiVO;
    import java.util.ArrayList;
    import java.util.List;
    import javax.annotation.Generated;
    import org.springframework.stereotype.Component;
    @Generated(
        value = "org.mapstruct.ap.MappingProcessor",
        date = "2021-02-22T14:48:03+0800",
        comments = "version: 1.2.0.Final, compiler: javac, environment: Java 1.8.0_121 (Oracle Corporation)"
    )
    @Component
    public class ApiMapperImpl implements ApiMapper {
        @Override
        public ApiDTO apiVoToApiDto(ApiVO apiVO) {
            if ( apiVO == null ) {
                return null;
            }
            ApiDTO apiDTO = new ApiDTO();
            apiDTO.setApiMethod( apiVO.getMethod() );
            apiDTO.setName( apiVO.getName() );
            apiDTO.setApiConf( apiConfToApiConf( apiVO.getApiConf() ) );
            List<ApiPO> list = apiVO.getApiPOList();
            if ( list != null ) {
                apiDTO.setApiPOList( new ArrayList<ApiPO>( list ) );
            }
            else {
                apiDTO.setApiPOList( null );
            }
            apiDTO.setList( integerListToStringList( apiVO.getList() ) );
            return apiDTO;
        }
        protected ApiConf apiConfToApiConf(com.chinadaas.platform.dsp.kernel.common.domain.vo.ApiVO.ApiConf apiConf) {
            if ( apiConf == null ) {
                return null;
            }
            ApiConf apiConf1 = new ApiConf();
            apiConf1.setId( apiConf.getId() );
            apiConf1.setOpen( apiConf.getOpen() );
            return apiConf1;
        }
        protected List<String> integerListToStringList(List<Integer> list) {
            if ( list == null ) {
                return null;
            }
            List<String> list1 = new ArrayList<String>( list.size() );
            for ( Integer integer : list ) {
                list1.add( String.valueOf( integer ) );
            }
            return list1;
        }
    }

    Ps:这就是为什么 mapstruct 的效率比较高的原因,相比于反射获取对象进行拷贝的方法,这种更贴近于原生 get/set 方法的框架显得更为高效。这个文件是通过在 mapper 中的注解,使用生成映射器的注解处理器从而自动生成了这段代码。

    注意事项

    • 开发过程中遇到修改属性时,重新启动项目还是复制的时候新添加的属性为 null,此时,因为自动生成的实现类并没有重新编译,需要手动在 target 包中找到删除,再重新启动即可!

    FAQ

    展开全文
  • MapStruct

    2018-11-24 23:08:04
    <org.mapstruct.version>1.2.0.Final</org.mapstruct.version> <!-- 省略其他.. --> <groupId>org.mapstruct <artifactId>mapstruct-jdk8 ${org.mapstruct.version} <groupId>org.mapstruct ...

           一般java web开发的程序员,都有一个共同的体会,接受请求参数都会使用一个vo类,这个vo类里封装了所有需要接受的参数,然后对参数进行业务逻辑处理,处理完后会持久化处理,通常每个业务表都会对应一个bean类,然后就需要将vo对象转化为bean对象再持久化,这个过程中,就需要new bean对象,给bean对象里的每个属性赋值;请求处理完,还需要有返回,通常返回也会封装一个vo类,所以也需要new一个vo对象,将需要返回的数据封装在这个vo对象里,这个是比较麻烦的。

            使用MapStruct可以快速帮你解决vo->bean,bean->vo的转换工作,使得代码更加简洁。

           这里使用JDK8,idea来编写程序,maven解决依赖,先在pom文件引入依赖:

    <properties>
        <org.mapstruct.version>1.2.0.Final</org.mapstruct.version>
    </properties>
    <!-- 省略其他.. -->
    
    <dependencies>
      	<dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-jdk8</artifactId>
            <version>${org.mapstruct.version}</version>
        </dependency>
          <dependency>
              <groupId>org.mapstruct</groupId>
              <artifactId>mapstruct-processor</artifactId>
              <version>${org.mapstruct.version}</version>
          </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.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>

    下面看java代码,先定义一个接口或者抽象类

    @Mapper
    public interface CarMapper {
    	
    	CarMapper INSTANCE = Mappers.getMapper(CarMapper.class);
    	
    	CarDto carToCarDto(Car car);
    
    	@Mappings({
    			@Mapping(source = "numberOfSeats", target = "seatCount")
    	})
    	CarDto carToCarDtoSpecial(Car car);
    }
    
    public class Car {
    	
        private String make;
        private int numberOfSeats;
        private CarType type;
        private Date createTime;
        
        //getter and setter...
    }
    
    public class CarDto {
    	
    	private String make;
        private int seatCount;
        private String type;
    
        private String date;
        
        //getter and setter...
    }

    首先我们看mapstruct生成carToCarDto方法

    public CarDto carToCarDto(Car car) {
            if ( car == null ) {
                return null;
            }
    
            CarDto carDto = new CarDto();
    
            carDto.setMake( car.getMake() );
            if ( car.getType() != null ) {
                carDto.setType( car.getType().name() );
            }
    
            return carDto;
        }

    按照默认情况来说,mapstruct是根据两个对象里相同名称的属性名来进行赋值的,上面可以看出Car和CarDto有make和type两个属性名称是相同的,所以会将Car对象的两个属性值分别赋值给CarDto对象,当然也可以根据指定的属性来进行赋值。

    carToCarDtoSpecial方法就是可以解决上面这个问题的,下面是mapstruct生成的源码
    
    public CarDto carToCarDtoSpecial(Car car) {
            if ( car == null ) {
                return null;
            }
    
            CarDto carDto = new CarDto();
    
            carDto.setSeatCount( car.getNumberOfSeats() ); //A处
            carDto.setMake( car.getMake() );
            if ( car.getType() != null ) {
                carDto.setType( car.getType().name() );
            }
    
            return carDto;
        }

    源码多了A处,因为我们指定了注解

    @Mapping(source = "numberOfSeats", target = "seatCount")

    就是告诉mapstruct,Car的numberOfSeats属性值映射到CarDto的seatCount的属性值。

    使用mapstruct来转换Car和CarDto是非常简单的

    CarDto carDto = CarMapper.INSTANCE.carToCarDto(car);
    		
    
    CarDto carDto1 = CarMapper.INSTANCE.carToCarDtoSpecial(car);

    所以就两行代码就针对两种情况,使用非常简洁。

    上面只是一个Car对象转换到一个CarDto,mapstruct还可以将多个对象作为入参,转换到一个返回对象里。

    展开全文
  • Mapstruct原理

    千次阅读 2019-05-21 11:00:23
    一、Mapstruct简介 MapStruct是用于生成类型安全的bean映射类的Java注解处理器。 你所要做的就是定义一个映射器接口,声明任何需要映射的方法。在编译过程中,MapStruct将生成该接口的实现。此实现使用纯Java的...

    一、Mapstruct简介

           MapStruct是用于生成类型安全的bean映射类的Java注解处理器。
           你所要做的就是定义一个映射器接口,声明任何需要映射的方法。在编译过程中,MapStruct将生成该接口的实现。此实现使用纯Java的方法调用源对象和目标对象之间进行映射,并非Java反射机制。
           与手工编写映射代码相比,MapStruct通过生成冗长且容易出错的代码来节省时间。在配置方法的约定之后,MapStruct使用了合理的默认值,但在配置或实现特殊行为时将不再适用。

    与动态映射框架相比,MapStruct具有以下优点:

    • 使用纯Java方法代替Java反射机制快速执行
    • 编译时类型安全:只能映射彼此的对象和属性,不能映射一个Order实体到一个Customer DTO中等等
    • 如果无法映射实体或属性,则在编译时清除错误报告

    二、Mapstruct原理

     MapStruct是基于JSR 269的Java注解处理器,因此可以在命令行构建中使用(javac、Ant、Maven等等),也可以在IDE内使用。

           它包括以下工件

    • org.mapstruct:mapstruct:包含了必要的注解,例如@Mapping;在Java 8或更高版本中,使用org.mapstruct:mapstruct-jdk8,而不是利用Java 8中引入的语言进行改进。
    • org.mapstruct:mapstruct-processor:包含生成映射器实现的注解处理器

    在使用过程中需要只需要配置完成后运行 mvn compile就会发现  target文件夹中生成了一个mapper接口的实现类。打开实现类会发现实体类中自动生成了字段一一对应的get、set方法的文件。

     这就是为什么mapstruct的效率比较高的原因,相比于反射获取对象进行拷贝的方法,这种更贴近于原生get、set方法的框架显得更为高效。

    这个文件是通过在mapper中的注解,使用生成映射器的注解处理器从而自动生成了这段代码。

    看到这里是不是感觉JSR 269注解处理器很熟悉。确实在很多地方都是用到了他,在我之前了解lombok原理时也看到他的身影。那么总让我在这里好好介绍一下他。

    三、注解处理器

    1.Java代码编译过程

    Java代码编译和执行的整个过程包含了以下三个重要的机制:1)Java源码编译机制;2)类加载机制;3)类执行机制

    其中,Java源码编译由以下三个过程组成:1)分析和输入到符号表;2)注解处理;3)语义分析和生成class文件

    流程图如下所示:

    其中的annotation processing就是代码的注解处理,jdk7之前访问和处理Annotation的工具统称APT(Annotation Processing Tool)(jdk7后就被废除了),jdk7及之后采用了JSR 269 API。

    2.注解处理器的作用

    Annotation就像代码里的特殊标记,这些标记可以在编译、类加载、运行时被读取。读取到了程序元素的元数据,就可以执行相应的处理。通过注解,程序开发人员可以在不改变原有逻辑的情况下,在源代码文件中嵌入一些补充信息代码分析工具、开发工具和部署工具可以通过解析这些注解获取到这些补充信息,从而进行验证或者进行部署等

     

    接下来回头来理解lombok通过添加注解来标识实体类,在源码编译的过程中告诉注解处理器这里需要添加get、set方法就很顺理成章了。

     

    展开全文
  • MapStruct 详解

    千次阅读 2018-10-31 16:39:31
    GitHub 访问地址 : https://github.com/mapstruct/mapstruct/ 使用例子 : https://github.com/mapstruct/mapstruct-examples   MapStrcut与其它工具对比以及使用说明 : ...
  • mapstruct使用的正确姿势

    千次阅读 多人点赞 2020-04-22 09:29:29
    我们都知道,随着一个工程的越来越成熟,模块划分会越来越细,其中实体类一般存于 domain 之中,但 domain 工程最好不要被其他工程依赖,所以其他工程想...所以阿淼今天就要给大家安利一款叫 mapstruct 的插件,它就...
  • MapStruct超级简单的学习笔记

    万次阅读 多人点赞 2019-02-14 11:23:26
    MapStruct使用MapStruct1.MapStruct是用来做什么的?2.使用MapStruct解决上述问题3.添加默认方法4. 可以使用abstract class来代替接口5.可以使用多个参数5.直接使用参数作为属性值 使用MapStruct 首先来了解一下DTO...
  • Springboot集成mapstruct

    千次阅读 2019-08-13 11:43:18
    一、什么是mapstruct MapStruct是一个代码生成器的工具类,简化了不同的Java Bean之间映射的处理,所以映射指的就是从一个实体变化成一个实体。在实际项目中,我们经常会将PO转DTO、DTO转PO等一些实体间的转换。在...
  • MapStruct使用

    千次阅读 2017-09-29 09:38:01
    MapStruct介绍:在一个成熟可维护的工程中,细分模块后,domian工程最好不要被其他工程依赖,但是实体类一般存于domain之中,这样其他工程想获取实体类数据时就需要在各自工程写model,自定义model可以根据自身业务...
  • mapstruct使用

    千次阅读 2019-09-20 15:16:36
    mapstruct使用 官方文档地址 官方github地址 介绍 Mapstruct可以简化领域模型DO-DTO转换.通常转换发生在代码运行阶段或编译阶段,运行阶段的转换一般通过反射去做,但是这种方式比较消耗资源,会拖慢程序比如Model...
  • MapStruct - 原理讲解

    2021-02-22 17:53:20
    MapStruct是用于生成类型安全的bean映射类的Java注解处理器。 你所要做的就是定义一个映射器接口,声明任何需要映射的方法。在编译过程中,MapStruct将生成该接口的实现。此实现使用纯Java的方法调用源对象和目标...
  • MapStruct 映射工具

    2019-12-20 11:21:57
    本篇主要讲解MapStruct 一款映射工具,只需简单的定义一个Mapper接口,在编译期间,MapStruct将生成此接口的实现,据说MapStruct性能最高是Spring的CopyProperties的10倍,与手工编写映射代码相比,MapStruct通过...
  • MapStruct、ignore

    2021-05-19 12:37:21
    文章目录@[toc]使用由Spring代理...MapStruct是通过getter、setter来实现的。 <!--MapStruct依赖--> <!-- https://mvnrepository.com/artifact/org.mapstruct/mapstruct-jdk8 --> <dependency>
  • MapStruct的使用

    千次阅读 2019-09-05 17:26:30
    MapStruct 代替BeanUtil 和ModelMapper:https://blog.csdn.net/paincupid/article/details/71247255 推荐一个 Java 实体映射工具 MapStruct:https://blog.csdn.net/zhige_me/article/details/80699784 ...
  • Mapstruct 使用教程

    2020-12-12 10:20:59
    Mapstruct 版本1.4.1.Final 官方文档 案例-github 前言 MapStruct是一个Java注释处理器,用于生成类型安全的bean映射类。 您要做的就是定义一个映射器接口,该接口声明任何必需的映射方法。在编译期间,MapStruct将...
  • mapStruct 之 基本使用

    千次阅读 2019-09-16 16:03:03
    简介 mapstrct是一个很好注释处理的框架,解决...mapstrut一共两个主要的包,org.mapstruct.mapstruct包含里面常用的注释,org.mapstruct.mapstruct-processor处理注释的实现。 官方文档 文档传送门 maven引入 <...
  • mapstruct 之 类型转换

    千次阅读 2019-09-16 16:31:01
    参考链接:mapstruct的基本使用 背景介绍 是不是有时候发现明明source和target不是同一个类型,但是却转换成功了,这是因为mapstruct有一套自己的类型转换机制 类型转换的流程 首先尝试自动进行类型转换 若是无法...
  • mapstruct 使用总结

    2020-11-27 11:32:40
    mapstruct 专门用来处理 domin 实体类与 model 类的属性映射的,我们只需定义 mapper 接口,mapstruct 在编译的时候就会自动的帮我们实现这个映射接口,避免了麻烦复杂的映射实现 简单说:快捷实现domain 实体与DTO ...
  • kotlin中使用mapstruct

    2019-09-05 11:17:01
    kotlin中使用mapstruct前言创建实体和我们的dto以及我们的mapper实体Flight转换以后的实体FlightDto转换的工具类FlightConverter构建项目打包项目懒人解决方案 前言 我们在java中使用mapstruct只需要简单的引入我们...
  • springboot整合mapstruct

    2020-01-02 17:11:29
    2020年开始改变,从记录博客开始。 当程序员很多年,都没有写博客的习惯,原因很多,感觉没时间写,平常自己也有写笔记,新的一年,开始改变...MapStruct is a code generator that greatly simplifies the impl...
  • MapStruct使用方法

    2020-07-24 14:19:34
    目前代码中对象的copy大家使用的基本都是spring提供的BeanUtils.copyProperties,...我们可以试试MapStruct: 1.引入依赖 <mapstruct.version>1.3.1.Final</mapstruct.version> org.mapstruct mapstru
  • MapStruct 入门使用

    千次阅读 2019-09-27 22:46:03
    MapStruct 可以将某几种类型的对象映射为另外一种类型,如将多个Domain 对象转换为 DTO,涉及到类似之间对象转换的都可以用它来完成。其主要作用就是:Java bean mappings 详细信息可以参考最新版本的文档:Map...
  • MapStruct Map 转换成对象

    千次阅读 2020-08-23 21:59:33
    背景 调用公司影像识别服务接口,返回值都是 Map<... 查阅了一下,MapStruct 目前(1.3.1.Final 及之前)的版本暂不支持直接将 map 转换成 JavaBean,很早之前有人在 GitHub提了这个feature(Please ad...
  • Mapstruct的简单配置使用

    万次阅读 2016-12-16 10:59:59
    Mapstruct 是一个很好用的插件用来处理java工程中实体间的转换,比如po转vo,domain转dto。 通常我们会写一些convert 写一堆set get来处理这个转换,现在我们可以使用Mapstruct 。 http://mapstruct.org/这是map...
  • 丢弃掉那些BeanUtils工具类吧,MapStruct真香!!!

    万次阅读 热门讨论 2020-08-10 12:55:30
    然后在评论区有些读者反馈说MapStruct才是真的香,于是我就抽时间了解了一下MapStruct。结果我发现,这真的是一个神仙框架,炒鸡香。 这一篇文章就来简单介绍下MapStruct的用法,并且再和其他几个工具类进行一下对比...
  • MapStruct Documentation 中文版

    千次阅读 2019-11-16 23:17:29
    安装 目录 安装 分发包 ...您可以从GitHub获取包含MapStruct的二进制文件,源代码和API文档的分发包。 Apache Maven 如果使用Maven构建项目,则将以下内容添加到pom.xml中以使用MapStruct: ...
  • mapstruct 实体映射工具

    2020-03-20 17:28:16
    mapstruct.version>1.3.0.Final</mapstruct.version> <dependency> <groupId>org.mapstruct</groupId> <artifactId>mapstruct-jdk8</artifactId...
  • Spring Boot 集成 MapStruct 实现类型转换

    千次阅读 2019-12-12 18:02:14
    MapStruct 是一个属性映射工具,只需要定义一个 Mapper 接口,MapStruct就会自动实现这个映射接口,避免了复杂繁琐的映射实现。MapStruct官网地址: http://mapstruct.org/

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 292,262
精华内容 116,904
关键字:

mapstruct