丢掉那些BeanUtils工具类吧，MapStruct真香！！！

BeanUtils工具类

使用 MapStruct 之前我们是这样来转换对象的：

package com.spring.security.demo.utils.bean;

import org.springframework.beans.BeanUtils;

/**
 * @author wulongbo
 * @version 1.0
 * @date 2020/6/11 9:17
 * @description
 */
public class BabaBeanUtils<Vo, Dto> {

    /**
     * dot 转换为Do 工具类
     *
     * @param voEntity
     * @param dtoClass
     * @return
     */
    public static <Dto> Dto voToDto(Object voEntity, Class<Dto> dtoClass) {
        // 判断VoSF是否为空!
        if (voEntity == null) {
            return null;
        }
        // 判断DtoClass 是否为空
        if (dtoClass == null) {
            return null;
        }
        try {
            Dto newInstance = dtoClass.newInstance();
            BeanUtils.copyProperties(voEntity, newInstance);
            // Dto转换Do
            return newInstance;
        } catch (Exception e) {
            return null;
        }
    }

    // 后面集合类型带封装
}

后面读者可以参照BeanUtils自行修改 PersonConverter 接口为泛型。

为什么需要MapStruct ？

首先，我们先说一下MapStruct这类框架适用于什么样的场景，为什么市面上会有这么多的类似的框架。

在软件体系架构设计中，分层式结构是最常见，也是最重要的一种结构。很多人都对三层架构、四层架构等并不陌生。

甚至有人说："计算机科学领域的任何问题都可以通过增加一个间接的中间层来解决，如果不行，那就加两层。"

但是，随着软件架构分层越来越多，那么各个层次之间的数据模型就要面临着相互转换的问题，典型的就是我们可以在代码中见到各种O，如DO、DTO、VO等。

一般情况下，同样一个数据模型，我们在不同的层次要使用不同的数据模型。如在数据存储层，我们使用DO来抽象一个业务实体；在业务逻辑层，我们使用DTO来表示数据传输对象；到了展示层，我们又把对象封装成VO来与前端进行交互。

那么，数据的从前端透传到数据持久化层（从持久层透传到前端），就需要进行对象之间的互相转化，即在不同的对象模型之间进行映射。

通常我们可以使用get/set等方式逐一进行字段映射操作，如：

personDTO.setName(personDO.getName());

personDTO.setAge(personDO.getAge());

personDTO.setSex(personDO.getSex());

personDTO.setBirthday(personDO.getBirthday());

但是，编写这样的映射代码是一项冗长且容易出错的任务。MapStruct等类似的框架的目标是通过自动化的方式尽可能多地简化这项工作。

MapStruct的使用

MapStruct（https://mapstruct.org/ ）是一种代码生成器，它极大地简化了基于"约定优于配置"方法的Java bean类型之间映射的实现。生成的映射代码使用纯方法调用，因此快速、类型安全且易于理解。

约定优于配置，也称作按约定编程，是一种软件设计范式，旨在减少软件开发人员需做决定的数量，获得简单的好处，而又不失灵活性。

假设我们有两个类需要进行互相转换，分别是PersonDO和PersonDTO，类定义如下：

package com.spring.security.demo.Do;

import lombok.Data;

import java.util.Date;

/**
 * @Author wulongbo
 * @Date 2021/1/6 16:36
 * @Version 1.0
 */
@Data
public class PersonDO {

    private Integer id;

    private String name;

    private int age;

    private Date birthday;

    private String gender;

    private String address;

}

package com.spring.security.demo.dto;

import com.spring.security.demo.base.GenderEnum;
import com.spring.security.demo.entity.HomeAddress;
import lombok.Data;

import java.util.Date;

@Data
public class PersonDTO {

    public String userName;

    private Integer age;

    private Date birthday;

    private GenderEnum gender;

    private HomeAddress address;

}

package com.spring.security.demo.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author wulongbo
 * @Date 2021/1/6 17:26
 * @Version 1.0
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
public class HomeAddress {

    private String province;

    private String city;

    private String area;

    private String street;

    private String towns;

    private String community;

    // 门牌号
    private String houseNums;
}

package com.spring.security.demo.base;

/**
 * @Author wulongbo
 * @Date 2021/1/6 17:06
 * @Version 1.0
 */
public enum GenderEnum {
    FEMALE, MALE
}

我们演示下如何使用MapStruct进行bean映射。
想要使用MapStruct，首先需要依赖他的相关的jar包，使用maven依赖方式如下：

<!--MapStruct依赖-->
<!-- https://mvnrepository.com/artifact/org.mapstruct/mapstruct-jdk8 -->
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-jdk8</artifactId>
        <version>1.0.0.Final</version>
    </dependency>
<!--https://mvnrepository.com/artifact/org.mapstruct/mapstruct-processor -->
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-processor</artifactId>
        <version>1.0.0.Final</version>
    </dependency>

之后，我们需要定义一个做映射的接口，主要代码如下：

package com.spring.security.demo.service;

import com.alibaba.fastjson.JSON;
import com.spring.security.demo.Do.PersonDO;
import com.spring.security.demo.dto.PersonDTO;
import com.spring.security.demo.entity.HomeAddress;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

import java.util.Map;

/**
 * @Author wulongbo
 * @Date 2021/1/6 16:38
 * @Version 1.0
 */

@Mapper
public interface PersonConverter {

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

    @Mappings({
            @Mapping(source = "name", target = "userName"),
            @Mapping(target = "address", ignore = true)
    })
    @Mapping(target = "birthday", dateFormat = "yyyy-MM-dd HH:mm:ss")
    PersonDTO do2dto(PersonDO person);

    @Mappings({@Mapping(expression = "java(map.get(\"province\"))", target = "province"),
            @Mapping(expression = "java(map.get(\"city\"))", target = "city"),
            @Mapping(expression = "java(map.get(\"area\"))", target = "area"),
            @Mapping(expression = "java(map.get(\"street\"))", target = "street"),
            @Mapping(expression = "java(map.get(\"towns\"))", target = "towns"),
            @Mapping(expression = "java(map.get(\"community\"))", target = "community"),
            @Mapping(expression = "java(map.get(\"houseNums\"))", target = "houseNums")})
    HomeAddress map2HomeAddress(Map<String, String> map);


    @Mappings(@Mapping(source = "userName", target = "name"))
    @Mapping(target = "address", expression = "java(homeAddressToString(dto2do.getAddress()))")
    PersonDO dto2do(PersonDTO dto2do);

    default String homeAddressToString(HomeAddress address) {
        return JSON.toJSONString(address);
    }

}

使用注解@Mapper定义一个Converter接口，在其中定义一个do2dto方法，方法的入参类型是PersonDO，出参类型是PersonDTO，这个方法就用于将PersonDO转成PersonDTO。
测试代码如下：

package com.spring.security.demo;

import com.spring.security.demo.Do.PersonDO;
import com.spring.security.demo.base.GenderEnum;
import com.spring.security.demo.dto.PersonDTO;
import com.spring.security.demo.entity.HomeAddress;
import com.spring.security.demo.service.PersonConverter;
import org.springframework.security.core.parameters.P;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author wulongbo
 * @Date 2021/1/6 16:48
 * @Version 1.0
 */
public class do2Dto {
    public static void main(String[] args) {

        Map<String, String> map = new HashMap<String, String>();
        map.put("province", "湖南");
        map.put("city", "郴州");
        map.put("area", "临武");
        map.put("street", "湖南");
        map.put("towns", "顺峰");
        map.put("community", "东云");
        map.put("houseNums", "1001");
        HomeAddress homeAddress = PersonConverter.INSTANCE.map2HomeAddress(map);
        System.out.println(homeAddress.toString());

        PersonDO personDO = new PersonDO();

        personDO.setName("wlb");

        personDO.setAge(26);

        personDO.setBirthday(new Date());

        personDO.setId(1);

        personDO.setGender(GenderEnum.MALE.name());

        PersonDTO personDTO = PersonConverter.INSTANCE.do2dto(personDO);

        personDTO.setAddress(homeAddress);
        System.out.println(personDTO);

        PersonDO personDO1 = PersonConverter.INSTANCE.dto2do(personDTO);
        System.out.println(personDO1);
    }
}

输出结果：

HomeAddress(province=湖南, city=郴州, area=临武, street=湖南, towns=顺峰, community=东云, houseNums=1001)
PersonDTO(userName=wlb, age=26, birthday=Thu Jan 07 11:33:26 CST 2021, gender=MALE, address=HomeAddress(province=湖南, city=郴州, area=临武, street=湖南, towns=顺峰, community=东云, houseNums=1001))
PersonDO(id=null, name=wlb, age=26, birthday=Thu Jan 07 11:33:26 CST 2021, gender=MALE, address={"area":"临武","city":"郴州","community":"东云","houseNums":"1001","province":"湖南","street":"湖南","towns":"顺峰"})

可以看到，我们使用MapStruct完美的将PersonDO转成了PersonDTO。
上面的代码可以看出，MapStruct的用法比较简单，主要依赖@Mapper注解。

但是我们知道，大多数情况下，我们需要互相转换的两个类之间的属性名称、类型等并不完全一致，还有些情况我们并不想直接做映射，那么该如何处理呢？
其实MapStruct在这方面也是做的很好的。

MapStruct处理字段映射

首先，可以明确的告诉大家，如果要转换的两个类中源对象属性与目标对象属性的类型和名字一致的时候，会自动映射对应属性。

那么，如果遇到特殊情况如何处理呢？

名字不一致如何映射

如上面的例子中，在PersonDO中用name表示用户名称，而在PersonDTO中使用userName表示用户名，那么如何进行参数映射呢。
这时候就要使用@Mapping注解了，只需要在方法签名上，使用该注解，并指明需要转换的源对象的名字和目标对象的名字就可以了，如将name的值映射给userName，可以使用如下方式：

@Mapping(source = "name", target = "userName")

可以自动映射的类型

除了名字不一致以外，还有一种特殊情况，那就是类型不一致，如上面的例子中，在PersonDO中用String类型表示用户性别，而在PersonDTO中使用一个Genter的枚举表示用户性别。

这时候类型不一致，就需要涉及到互相转换的问题

其实，MapStruct会对部分类型自动做映射，不需要我们做额外配置，如例子中我们将String类型自动转成了枚举类型。

一般情况下，对于以下情况可以做自动类型转换：

• 基本类型及其他们对应的包装类型。
• 基本类型的包装类型和String类型之间
• String类型和枚举类型之间

自定义常量

如果我们在转换映射过程中，想要给一些属性定义一个固定的值，这个时候可以使用 constant

@Mapping(source = "name", constant = "wlb")

类型不一致的如何映射

还是上面的例子，如果我们需要在Person这个对象中增加家庭住址这个属性，那么我们一般在PersonoDTO中会单独定义一个HomeAddress类来表示家庭住址，而在Person类中，我们一般使用String类型表示家庭住址。

这就需要在HomeAddress和String之间使用JSON进行互相转化，这种情况下，MapStruct也是可以支持的。

我们只需要在PersonConverter中在定义一个方法（因为PersonConverter是一个接口，所以在JDK 1.8以后的版本中可以定义一个default方法），这个方法的作用就是将HomeAddress转换成String类型。

default方法：Java 8 引入的新的语言特性，用关键字default来标注，被default所标注的方法，需要提供实现，而子类可以选择实现或者不实现该方法

然后在dto2do方法上，通过以下注解方式即可实现类型的转换：

@Mapping(target = "address",expression = "java(homeAddressToString(dto2do.getAddress()))")

上面这种是自定义的类型转换，还有一些类型的转换是MapStruct本身就支持的，如String和Date之间的转换：

@Mapping(target = "birthday",dateFormat = "yyyy-MM-dd HH:mm:ss")

上，简单介绍了一些常用的字段映射的方法，也是我自己在工作中经常遇到的几个场景，更多的情况大家可以查看官方的示例（https://github.com/mapstruct/...）。

MapStruct的性能

前面说了这么多MapStruct的用法，可以看出MapStruct的使用还是比较简单的，并且字段映射上面的功能很强大，那么他的性能到底怎么样呢？

参考《为什么阿里巴巴禁止使用Apache Beanutils进行属性的copy？》中的示例，我们对MapStruct进行性能测试。

分别执行1000、10000、100000、1000000次映射的耗时分别为：0ms、1ms、3ms、6ms。

可以看到，MapStruct的耗时相比较于其他几款工具来说是非常短的。

那么，为什么MapStruct的性能可以这么好呢？

其实，MapStruct和其他几类框架最大的区别就是：与其他映射框架相比，MapStruct在编译时生成bean映射，这确保了高性能，可以提前将问题反馈出来，也使得开发人员可以彻底的错误检查。

在引入MapStruct的依赖的时候，特别在maven-compiler-plugin中增加了mapstruct-processor的支持吗？

并且我们在代码中使用了很多MapStruct提供的注解，这使得在编译期，MapStruct就可以直接生成bean映射的代码，相当于代替我们写了很多setter和getter。
如我们在代码中定义了以下一个Mapper：

package com.spring.security.demo.service;

import com.alibaba.fastjson.JSON;
import com.spring.security.demo.Do.PersonDO;
import com.spring.security.demo.dto.PersonDTO;
import com.spring.security.demo.entity.HomeAddress;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

import java.util.Map;

/**
 * @Author wulongbo
 * @Date 2021/1/6 16:38
 * @Version 1.0
 */

@Mapper
public interface PersonConverter {

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

    @Mappings({
            @Mapping(source = "name", target = "userName"),
            @Mapping(target = "address", ignore = true)
    })
    @Mapping(target = "birthday", dateFormat = "yyyy-MM-dd HH:mm:ss")
    PersonDTO do2dto(PersonDO person);

    @Mappings({@Mapping(expression = "java(map.get(\"province\"))", target = "province"),
            @Mapping(expression = "java(map.get(\"city\"))", target = "city"),
            @Mapping(expression = "java(map.get(\"area\"))", target = "area"),
            @Mapping(expression = "java(map.get(\"street\"))", target = "street"),
            @Mapping(expression = "java(map.get(\"towns\"))", target = "towns"),
            @Mapping(expression = "java(map.get(\"community\"))", target = "community"),
            @Mapping(expression = "java(map.get(\"houseNums\"))", target = "houseNums")})
    HomeAddress map2HomeAddress(Map<String, String> map);


    @Mappings(@Mapping(source = "userName", target = "name"))
    @Mapping(target = "address", expression = "java(homeAddressToString(dto2do.getAddress()))")
    PersonDO dto2do(PersonDTO dto2do);

    default String homeAddressToString(HomeAddress address) {
        return JSON.toJSONString(address);
    }

}

经过代码编译后，会自动生成一个PersonConverterImpl：

package com.spring.security.demo.service;

import com.spring.security.demo.Do.PersonDO;
import com.spring.security.demo.base.GenderEnum;
import com.spring.security.demo.dto.PersonDTO;
import com.spring.security.demo.entity.HomeAddress;
import java.util.Map;
import javax.annotation.Generated;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2021-01-07T11:33:24+0800",
    comments = "version: 1.0.0.Final, compiler: javac, environment: Java 1.8.0_251 (Oracle Corporation)"
)
public class PersonConverterImpl implements PersonConverter {

    @Override
    public PersonDTO do2dto(PersonDO person) {
        if ( person == null ) {
            return null;
        }

        PersonDTO personDTO = new PersonDTO();

        personDTO.setUserName( person.getName() );
        personDTO.setAge( person.getAge() );
        personDTO.setBirthday( person.getBirthday() );
        if ( person.getGender() != null ) {
            personDTO.setGender( Enum.valueOf( GenderEnum.class, person.getGender() ) );
        }

        return personDTO;
    }

    @Override
    public HomeAddress map2HomeAddress(Map<String, String> map) {
        if ( map == null ) {
            return null;
        }

        HomeAddress homeAddress = new HomeAddress();

        homeAddress.setArea( map.get("area") );
        homeAddress.setProvince( map.get("province") );
        homeAddress.setCity( map.get("city") );
        homeAddress.setStreet( map.get("street") );
        homeAddress.setTowns( map.get("towns") );
        homeAddress.setHouseNums( map.get("houseNums") );
        homeAddress.setCommunity( map.get("community") );

        return homeAddress;
    }

    @Override
    public PersonDO dto2do(PersonDTO dto2do) {
        if ( dto2do == null ) {
            return null;
        }

        PersonDO personDO = new PersonDO();

        personDO.setName( dto2do.getUserName() );
        if ( dto2do.getAge() != null ) {
            personDO.setAge( dto2do.getAge() );
        }
        personDO.setBirthday( dto2do.getBirthday() );
        if ( dto2do.getGender() != null ) {
            personDO.setGender( dto2do.getGender().name() );
        }

        personDO.setAddress( homeAddressToString(dto2do.getAddress()) );

        return personDO;
    }
}

在运行期，对于bean进行映射的时候，就会直接调用PersonConverterImpl的dto2do方法，这样就没有什么特殊的事情要做了，只是在内存中进行set和get就可以了。
所以，因为在编译期做了很多事情，所以MapStruct在运行期的性能会很好，并且还有一个好处，那就是可以把问题的暴露提前到编译期。
使得如果代码中字段映射有问题，那么应用就会无法编译，强制开发者要解决这个问题才行。

总结

本文介绍了一款Java中的字段映射工具类，MapStruct，他的用法比较简单，并且功能非常完善，可以应付各种情况的字段映射。
并且因为他是编译期就会生成真正的映射代码，使得运行期的性能得到了大大的提升。
强烈推荐，真的很香！！！