Mapstruct使用说明(一)

本文介绍了MapStruct在对象映射中的应用,包括它的基础知识、优缺点。MapStruct在编译时生成映射代码,提高了执行效率和安全性。与Spring的BeanUtils、Apache的BeanUtils和PropertyUtils相比,MapStruct在性能上有显著优势,并能实现深拷贝。此外,文中还提供了MapStruct的简单示例和百万数据拷贝的时间对比。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

        在使用分层或者分模块化的项目中,我们可能定义各种各样的O,例如:DO,VO,DTO等等。我们在进行这些对象之间的拷贝时,通过手动写get/set方法进行属性之间的赋值。因为他们之间的属性大部分都是相同的,不仅浪费时间,并且还有大量重复代码。所以,各种框架都添加的对象之间的拷贝的工具类。例如:

  1. Spring自带了BeanUtils

  2. Apatch自带的BeanUtils

  3. Apatch自带的PropertyUtils

  4. mapstruct提供Mappers

        本文主要介绍MapStruct的基础知识、Mapstruct的优缺点、Mapctruct的拷贝示例、以及四种方法时间对比。

01

Mapstuct介绍


1.mapstruct的官网地址:   

        https://mapstruct.org

2.mapstruct的文档地址:

        https://mapstruct.org/documentation/stable/reference/html/

3.mapstrcut的示例github地址

        https://github.com/mapstruct/mapstruct-examples

4.mapstruct的介绍

        mapstruct的作用:就像mapstruct官网所说的:mapsrtuct是一个用于简化在JavaBean之间映射的代码生成器工具,并且是基于约定高于配置的方式。

        因为生成的代码使用简单的get/set方法,所以mapstruct可以更快执行、类型之间复制更安全、且容易理解。

02

mapstruct的优缺点


下面看看mapstruct相比其他映射工具有什么优点

1.mapstruct的优点:

  • mapstruct是在代码编译的时候,生成其映射规则的代码,所以会在编译时暴露映射错误的代码,让错误提前暴露。

  • 因为使用的是一些简单方法:set/get或者Fluent方式,而非反射方式,所以可以更快的执行完成。可以通过04章节查看各个方法效率上对比

  • 可以实现深拷贝,上面4种方法中只有mapstruct可以实现深拷贝。但是需要进行配置(使用@mapper(mappingControl=DeepClone.class)进行设置)。其他的都是浅拷贝。从而mapstruct实现修改新对象不会对老对象产生影响。

  • 类型更加安全

  • 可以进行自定义的映射。可以自定义各种方法,完成属性映射。例如:将两个属性数据合并成一个设置到目标属性上

2.mapstruct的缺点

  • 必须添加一个接口或者抽象类,才能实现映射。其他的三种方法都不用写额外接口或者类。

03

Mapstruct的简单示例使用


        上面主要是介绍一下Mapstruct的基础知识,下面看一个mapstruct的简单示例,完成属性之间的映射。

        在示例中,我们使用mapstruct的1.4.2.Final版本,进行试验的

        1.第一个原属性数据

//第一个拷贝对象
public class CompareA {

    private String name;

    private Integer age;

    private LocalDateTime createTime;

    private double score;

    private Double totalScore;

    private Date updateTIme;

    private ChildCompare childCompare;

    private Long days;
    
    //省略其get/set方法,也可使用Lombok,以后讲解lombok与mapstruct结合使用
 }

       2. 第二个目标属性数据

public class CompareB {

    private String name;

    private Integer age;

    private String createTime;

    private double score;

    private Double totalScore;

    private Date updateTIme;

    private ChildCompare childCompare;

    private Long day;
    
    //省略其get/set方法,
}

       3.子类

//这是CompareA和CompareB共有的对象
public class ChildCompare {

    private String childName;

    private long childAge;
    
    //省略其get/set方法,
}

        上面是两个实体对象,观察这两个实体可以看到有两点不同:

  • CompareA中有一个createTime属性,数据类型为LocalDateTime,CompareB也有一个createTime,但是属性类型为String
  • CompareA有一个days属性,而CompareB有一个day属性

        4.mapstruct接口(这是需要我们手动写的)

package com.moxiao.properties.mapstruct;

import com.moxiao.properties.entity.CompareA;
import com.moxiao.properties.entity.CompareB;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.control.DeepClone;
import org.mapstruct.factory.Mappers;

/**
 * @author moxiao
 */
@Mapper
public interface CompareMapper {

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

    @Mapping(target = "day", source = "days")
    @Mapping(target = "createTime", source = "createTime", dateFormat = "yyyy-MM-dd HH:mm:ss")
    @Mapping(target = "childCompare", source = "childCompare", mappingControl = DeepClone.class)
    CompareB mapper(CompareA compareA);
}

        从上面的实现中,我们加入了三个注解:

  • 第一个注解:完成属性名不匹配的问题,将compareA中的days(source)赋值到compareB的day(target)
  • 第二个注解:完成属性类型不匹配的问题,将compareA中的createTime,赋值到compareB的createTime,这里进行日期的格式转化,使用dateFormat设置格式化类型
  • 第三个注解:完成深度拷贝,将compareA中的childCompare属性进行深度拷贝,而不是指针复制,最重要的是最后一个参数:mappingControl = DeepClone.class

        5.最后就会自动生成一个实现类:

package com.moxiao.properties.mapstruct;

import com.moxiao.properties.entity.ChildCompare;
import com.moxiao.properties.entity.CompareA;
import com.moxiao.properties.entity.CompareB;
import java.time.format.DateTimeFormatter;
import javax.annotation.Generated;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor"
)
public class CompareMapperImpl implements CompareMapper {

    @Override
    public CompareB mapper(CompareA compareA) {
        if ( compareA == null ) {
            return null;
        }

        CompareB compareB = new CompareB();

        compareB.setDay( compareA.getDays() );
        if ( compareA.getCreateTime() != null ) {
            compareB.setCreateTime( DateTimeFormatter.ofPattern( "yyyy-MM-dd HH:mm:ss" ).format( compareA.getCreateTime() ) );
        }
        compareB.setChildCompare( childCompareToChildCompare( compareA.getChildCompare() ) );
        compareB.setName( compareA.getName() );
        compareB.setAge( compareA.getAge() );
        compareB.setScore( compareA.getScore() );
        compareB.setTotalScore( compareA.getTotalScore() );
        compareB.setUpdateTIme( compareA.getUpdateTIme() );

        return compareB;
    }

    protected ChildCompare childCompareToChildCompare(ChildCompare childCompare) {
        if ( childCompare == null ) {
            return null;
        }

        ChildCompare childCompare1 = new ChildCompare();

        childCompare1.setChildName( childCompare.getChildName() );
        childCompare1.setChildAge( childCompare.getChildAge() );

        return childCompare1;
    }
}

          从上面的实现,我们可以看出,添加一个childCompareToChildCompare方法,来完成对象之间的深度拷贝。同样的将days设置到了day属性,等等。

          6.最后,我们调用这个mapper方法,就可以完成对象之间的拷贝:如下:

CompareMapper.INSTANCE.mapper(new CompareA());

04

这个对象映射之间的比较


        我们在1,000,000个对象进行各个工具之间的对比,看看效率如何?

package com.moxiao.properties.mapstruct;

import com.moxiao.properties.entity.ChildCompare;
import com.moxiao.properties.entity.CompareA;
import com.moxiao.properties.entity.CompareB;
import org.apache.commons.beanutils.PropertyUtils;
import org.junit.jupiter.api.Test;
import org.springframework.beans.BeanUtils;
import org.springframework.util.StopWatch;

import java.lang.reflect.InvocationTargetException;
import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author moxiao
 */
public class CompareTest {

    int count = 1000000;

    /**
     * Spring中的BeanUtils的使用,最后使用了6700ms
     */
    @Test
    public void springBeanUtils() {
        CompareA populate = populate();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("开始拷贝");
        for (int i = 0; i < count; i++) {
            CompareB compareB = new CompareB();
            BeanUtils.copyProperties(populate, compareB);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    /**
     * 这是使用mapstruct进行对象拷贝,使用时间54ms
     */
    @Test
    public void mapstructBeanUtils() {
        CompareA populate = populate();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("开始拷贝");
        for (int i = 0; i < count; i++) {
            CompareB mapper = CompareMapper.INSTANCE.mapper(populate);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    /**
     * 这是Apache的BeanUtils工具,使用7086ms
     * @throws InvocationTargetException
     * @throws IllegalAccessException
     */
    @Test
    public void commonBeanUtils() throws InvocationTargetException, IllegalAccessException {
        CompareA populate = populate();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("开始拷贝");
        for (int i = 0; i < count; i++) {
            CompareB compareB = new CompareB();
            org.apache.commons.beanutils.BeanUtils.copyProperties(compareB, populate);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    /**
     * 使用Apache中的propertyUtils静态方法,使用3756ms
     * @throws IllegalAccessException
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     */
    @Test
    public void commonPropertiesUtils() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        CompareA populate = populate();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start("开始拷贝");
        for (int i = 0; i < count; i++) {
            CompareB compareB = new CompareB();
            PropertyUtils.copyProperties(compareB, populate);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    public CompareA populate() {
        CompareA compareA = new CompareA();
        compareA.setAge(10);
        compareA.setName("moxiao");
        compareA.setCreateTime(LocalDateTime.now());
        compareA.setDays(100L);
        compareA.setTotalScore(100.0);
        compareA.setScore(12.3);
        compareA.setUpdateTIme(new Date());
        ChildCompare childCompare = new ChildCompare();
        childCompare.setChildAge(200);
        childCompare.setChildName("moxiaoChild");
        compareA.setChildCompare(childCompare);
        return compareA;
    }

}

        pom文件如下:


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.moxiao</groupId>
    <artifactId>propertiescopytest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.9</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.9</version>
        </dependency>
        
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>1.4.2.Final</version>
        </dependency>

        <!-- lombok dependencies should not end up on classpath -->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>commons-beanutils</groupId>
            <artifactId>commons-beanutils</artifactId>
            <version>1.9.4</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.projectlombok</groupId>
                            <artifactId>lombok-mapstruct-binding</artifactId>
                            <version>0.2.0</version>
                        </path>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>1.4.2.Final</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>1.18.18</version>
                        </path>
                    </annotationProcessorPaths>
                    <showWarnings>true</showWarnings>
                    <compilerArgs>
                        <arg>
                            -Amapstruct.suppressGeneratorTimestamp=true
                        </arg>
                        <arg>
                            -Amapstruct.suppressGeneratorVersionInfoComment=true
                        </arg>
                    </compilerArgs>

                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

上面是各个工具之间的对比,1000000数据之间拷贝的时间为:

工具名称时间(ms)
mapstruct54
Spring的BeanUtils6700
Apache的common的BeanUtils7086
Apache的common的PropertyUtils3756

综上所述,1百万数据,mapstruct可以在50ms左右完成。

这篇文章只是Mapstruct文章的开头,后续还有:

  • 与Lombok结合使用以及注意事项。
  • 与SpringBoot进行DI
  • 对象之间的深度拷贝,需要最什么配置

更多精彩内容:请关注公众号:


 

### Java MapStruct 使用泛型的示例教程 #### 1. 泛型的概念与作用 在Java中,泛型是种允许类型参数化的机制,可以提高代码的灵活性和重用性。通过引入泛型,开发者可以在编写通用算法的同时保持类型安全[^2]。 #### 2. MapStruct简介及其优势 MapStruct种用于自动对象映射的框架,能够显著减少手动编写的样板代码量。它基于注解处理器,在编译期生成高效的映射逻辑,从而提升性能并降低错误率[^1]。 #### 3. 结合泛型与MapStruct的实际案例 当需要处理复杂的对象层次结构或者多个具有相似字段的对象时,使用泛型可以使代码更加简洁和可维护。以下是具体实现步骤: ##### 定义基础实体类 假设存在两个基类 `BaseSource` 和 `BaseTarget`,它们分别表示源对象和目标对象,并且都支持泛型扩展。 ```java public class BaseSource<T> { private T data; // Getter and Setter methods } public class BaseTarget<T> { private T value; // Getter and Setter methods } ``` ##### 创建泛型Mapper接口 为了使 Mapper 支持泛型,需将其声明为带有类型参数的形式。 ```java @Mapper public interface GenericMapper<S, D> { /** * 将 S 类型的数据转换成 D 类型的目标对象。 */ D map(S source); /** * 反向操作:将 D 类型的数据转回 S 类型。 */ default S reverseMap(D destination) { throw new UnsupportedOperationException("Reverse mapping not implemented"); } } ``` ##### 实现特定类型的Mapper 对于具体的业务需求,可以通过继承上述泛型接口来定制化行为。 ```java // 继承泛型Mapper以完成实际的映射工作 @Mapper(componentModel = "spring") // 如果项目中有Spring,则启用此选项 public interface SpecificMapper extends GenericMapper<BaseSource<String>, BaseTarget<String>> {} ``` 此时,MapStruct会在后台自动生成对应的实现类,无需额外编码即可完成从`BaseSource<String>`到`BaseTarget<String>`以及反方向的转换[^4]。 #### 4. 测试代码片段 下面展示了个简单的单元测试例子,验证上面配置的有效性。 ```java @SpringBootTest class MapstructGenericTest { @Autowired private SpecificMapper specificMapper; @Test void testMapping() { BaseSource<String> source = new BaseSource<>(); source.setData("Hello World"); BaseTarget<String> target = specificMapper.map(source); assertNotNull(target.getValue()); assertEquals("Hello World", target.getValue()); System.out.println("Mapped Value: " + target.getValue()); } } ``` 以上即是在Java环境中利用MapStruct结合泛型进行对象间相互转化的个完整流程说明[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值