1.MapStruct是用來做什么的？

現在有這么個場景，從數據庫查詢出來了一個user對象（包含id，用戶名，密碼，手機號，郵箱，角色這些字段）和一個對應的角色對象role（包含id，角色名，角色描述這些字段），現在在controller需要用到user對象的id，用戶名，和角色對象的角色名三個屬性。

一種方式是直接把兩個對象傳遞到controller層，但是這樣會多出很多沒用的屬性。更通用的方式是需要用到的屬性封裝成一個類(DTO)，通過傳輸這個類的實例來完成數據傳輸。

User.java

@AllArgsConstructor
@Data
publicclassUser{
privateLongid;
privateStringusername;
privateStringpassword;
privateStringphoneNum;
privateStringemail;
privateRolerole;
}

Role.java

@AllArgsConstructor
@Data
publicclassRole{
privateLongid;
privateStringroleName;
privateStringdescription;
}

UserRoleDto.java，這個類就是封裝的類

@Data
publicclassUserRoleDto{
/**
*用戶id
*/
privateLonguserId;
/**
*用戶名
*/
privateStringname;
/**
*角色名
*/
privateStringroleName;
}

測試類，模擬將user對象轉換成UserRoleDto對象

publicclassMainTest{
Useruser=null;

/**
*模擬從數據庫中查出user對象
*/
@Before
publicvoidbefore(){
Rolerole=newRole(2L,"administrator","超級管理員");
user=newUser(1L,"zhangsan","12345","17677778888","123@qq.com",role);
}

/**
*模擬把user對象轉換成UserRoleDto對象
*/
@Test
publicvoidtest1(){
UserRoleDtouserRoleDto=newUserRoleDto();
userRoleDto.setUserId(user.getId());
userRoleDto.setName(user.getUsername());
userRoleDto.setRoleName(user.getRole().getRoleName());
System.out.println(userRoleDto);
}
}

從上面代碼可以看出，通過getter、setter的方式把一個對象屬性值復制到另一個對象中去還是很麻煩的，尤其是當屬性過多的時候。而MapStruct就是用于解決這種問題的。

2.使用MapStruct解決上述問題

這里我們沿用User.java、Role.java、UserRoleDto.java。

新建一個UserRoleMapper.java，這個來用來定義User.java、Role.java和UserRoleDto.java之間屬性對應規則：

UserRoleMapper.java

importorg.mapstruct.Mapper;
importorg.mapstruct.Mapping;
importorg.mapstruct.Mappings;
importorg.mapstruct.factory.Mappers;

/**
*@Mapper定義這是一個MapStruct對象屬性轉換接口，在這個類里面規定轉換規則
*在項目構建時，會自動生成改接口的實現類，這個實現類將實現對象屬性值復制
*/
@Mapper
publicinterfaceUserRoleMapper{

/**
*獲取該類自動生成的實現類的實例
*接口中的屬性都是publicstaticfinal的方法都是publicabstract的
*/
UserRoleMapperINSTANCES=Mappers.getMapper(UserRoleMapper.class);

/**
*這個方法就是用于實現對象屬性復制的方法
*
*@Mapping用來定義屬性復制規則source指定源對象屬性target指定目標對象屬性
*
*@paramuser這個參數就是源對象，也就是需要被復制的對象
*@return返回的是目標對象，就是最終的結果對象
*/
@Mappings({
@Mapping(source="id",target="userId"),
@Mapping(source="username",target="name"),
@Mapping(source="role.roleName",target="roleName")
})
UserRoleDtotoUserRoleDto(Useruser);

}

在測試類中測試：

通過上面的例子可以看出，使用MapStruct方便許多。

3.添加默認方法

添加默認方法是為了這個類（接口）不只是為了做數據轉換用的，也可以做一些其他的事。

importorg.mapstruct.Mapper;
importorg.mapstruct.Mapping;
importorg.mapstruct.Mappings;
importorg.mapstruct.factory.Mappers;

/**
*@Mapper定義這是一個MapStruct對象屬性轉換接口，在這個類里面規定轉換規則
*在項目構建時，會自動生成改接口的實現類，這個實現類將實現對象屬性值復制
*/
@Mapper
publicinterfaceUserRoleMapper{

/**
*獲取該類自動生成的實現類的實例
*接口中的屬性都是publicstaticfinal的方法都是publicabstract的
*/
UserRoleMapperINSTANCES=Mappers.getMapper(UserRoleMapper.class);

/**
*這個方法就是用于實現對象屬性復制的方法
*
*@Mapping用來定義屬性復制規則source指定源對象屬性target指定目標對象屬性
*
*@paramuser這個參數就是源對象，也就是需要被復制的對象
*@return返回的是目標對象，就是最終的結果對象
*/
@Mappings({
@Mapping(source="id",target="userId"),
@Mapping(source="username",target="name"),
@Mapping(source="role.roleName",target="roleName")
})
UserRoleDtotoUserRoleDto(Useruser);

/**
*提供默認方法，方法自己定義，這個方法是我隨便寫的，不是要按照這個格式來的
*@return
*/
defaultUserRoleDtodefaultConvert(){
UserRoleDtouserRoleDto=newUserRoleDto();
userRoleDto.setUserId(0L);
userRoleDto.setName("None");
userRoleDto.setRoleName("None");
returnuserRoleDto;
}

}

測試代碼：

@Test
publicvoidtest3(){
UserRoleMapperuserRoleMapperInstances=UserRoleMapper.INSTANCES;
UserRoleDtouserRoleDto=userRoleMapperInstances.defaultConvert();
System.out.println(userRoleDto);
}

4. 可以使用abstract class來代替接口

mapper可以用接口來實現，也可以完全由抽象來完全代替

importorg.mapstruct.Mapper;
importorg.mapstruct.Mapping;
importorg.mapstruct.Mappings;
importorg.mapstruct.factory.Mappers;

/**
*@Mapper定義這是一個MapStruct對象屬性轉換接口，在這個類里面規定轉換規則
*在項目構建時，會自動生成改接口的實現類，這個實現類將實現對象屬性值復制
*/
@Mapper
publicabstractclassUserRoleMapper{

/**
*獲取該類自動生成的實現類的實例
*接口中的屬性都是publicstaticfinal的方法都是publicabstract的
*/
publicstaticfinalUserRoleMapperINSTANCES=Mappers.getMapper(UserRoleMapper.class);

/**
*這個方法就是用于實現對象屬性復制的方法
*
*@Mapping用來定義屬性復制規則source指定源對象屬性target指定目標對象屬性
*
*@paramuser這個參數就是源對象，也就是需要被復制的對象
*@return返回的是目標對象，就是最終的結果對象
*/
@Mappings({
@Mapping(source="id",target="userId"),
@Mapping(source="username",target="name"),
@Mapping(source="role.roleName",target="roleName")
})
publicabstractUserRoleDtotoUserRoleDto(Useruser);

/**
*提供默認方法，方法自己定義，這個方法是我隨便寫的，不是要按照這個格式來的
*@return
*/
UserRoleDtodefaultConvert(){
UserRoleDtouserRoleDto=newUserRoleDto();
userRoleDto.setUserId(0L);
userRoleDto.setName("None");
userRoleDto.setRoleName("None");
returnuserRoleDto;
}

}

5.可以使用多個參數

可以綁定多個對象的屬性值到目標對象中：

packagecom.mapstruct.demo;

importorg.mapstruct.Mapper;
importorg.mapstruct.Mapping;
importorg.mapstruct.Mappings;
importorg.mapstruct.factory.Mappers;

/**
*@Mapper定義這是一個MapStruct對象屬性轉換接口，在這個類里面規定轉換規則
*在項目構建時，會自動生成改接口的實現類，這個實現類將實現對象屬性值復制
*/
@Mapper
publicinterfaceUserRoleMapper{

/**
*獲取該類自動生成的實現類的實例
*接口中的屬性都是publicstaticfinal的方法都是publicabstract的
*/
UserRoleMapperINSTANCES=Mappers.getMapper(UserRoleMapper.class);

/**
*這個方法就是用于實現對象屬性復制的方法
*
*@Mapping用來定義屬性復制規則source指定源對象屬性target指定目標對象屬性
*
*@paramuser這個參數就是源對象，也就是需要被復制的對象
*@return返回的是目標對象，就是最終的結果對象
*/
@Mappings({
@Mapping(source="id",target="userId"),
@Mapping(source="username",target="name"),
@Mapping(source="role.roleName",target="roleName")
})
UserRoleDtotoUserRoleDto(Useruser);

/**
*多個參數中的值綁定
*@paramuser源1
*@paramrole源2
*@return從源1、2中提取出的結果
*/
@Mappings({
@Mapping(source="user.id",target="userId"),//把user中的id綁定到目標對象的userId屬性中
@Mapping(source="user.username",target="name"),//把user中的username綁定到目標對象的name屬性中
@Mapping(source="role.roleName",target="roleName")//把role對象的roleName屬性值綁定到目標對象的roleName中
})
UserRoleDtotoUserRoleDto(Useruser,Rolerole);

對比兩個方法~

5.直接使用參數作為屬性值

packagecom.mapstruct.demo;

importorg.mapstruct.Mapper;
importorg.mapstruct.Mapping;
importorg.mapstruct.Mappings;
importorg.mapstruct.factory.Mappers;

/**
*@Mapper定義這是一個MapStruct對象屬性轉換接口，在這個類里面規定轉換規則
*在項目構建時，會自動生成改接口的實現類，這個實現類將實現對象屬性值復制
*/
@Mapper
publicinterfaceUserRoleMapper{

/**
*獲取該類自動生成的實現類的實例
*接口中的屬性都是publicstaticfinal的方法都是publicabstract的
*/
UserRoleMapperINSTANCES=Mappers.getMapper(UserRoleMapper.class);

/**
*直接使用參數作為值
*@paramuser
*@parammyRoleName
*@return
*/
@Mappings({
@Mapping(source="user.id",target="userId"),//把user中的id綁定到目標對象的userId屬性中
@Mapping(source="user.username",target="name"),//把user中的username綁定到目標對象的name屬性中
@Mapping(source="myRoleName",target="roleName")//把role對象的roleName屬性值綁定到目標對象的roleName中
})
UserRoleDtouseParameter(Useruser,StringmyRoleName);

}

測試類：

publicclassTest1{
Rolerole=null;
Useruser=null;

@Before
publicvoidbefore(){
role=newRole(2L,"administrator","超級管理員");
user=newUser(1L,"zhangsan","12345","17677778888","123@qq.com",role);
}
@Test
publicvoidtest1(){
UserRoleMapperinstances=UserRoleMapper.INSTANCES;
UserRoleDtouserRoleDto=instances.useParameter(user,"myUserRole");
System.out.println(userRoleDto);
}
}

6.更新對象屬性

在之前的例子中UserRoleDto useParameter(User user, String myRoleName);都是通過類似上面的方法來生成一個對象。而MapStruct提供了另外一種方式來更新一個對象中的屬性。@MappingTarget

publicinterfaceUserRoleMapper1{

UserRoleMapper1INSTANCES=Mappers.getMapper(UserRoleMapper1.class);

@Mappings({
@Mapping(source="userId",target="id"),
@Mapping(source="name",target="username"),
@Mapping(source="roleName",target="role.roleName")
})
voidupdateDto(UserRoleDtouserRoleDto,@MappingTargetUseruser);


@Mappings({
@Mapping(source="id",target="userId"),
@Mapping(source="username",target="name"),
@Mapping(source="role.roleName",target="roleName")
})
voidupdate(Useruser,@MappingTargetUserRoleDtouserRoleDto);

}

通過@MappingTarget來指定目標類是誰（誰的屬性需要被更新）。@Mapping還是用來定義屬性對應規則。

以此為例說明：

@Mappings({
@Mapping(source="id",target="userId"),
@Mapping(source="username",target="name"),
@Mapping(source="role.roleName",target="roleName")
})
voidupdate(Useruser,@MappingTargetUserRoleDtouserRoleDto);

@MappingTarget標注的類UserRoleDto 為目標類，user類為源類，調用此方法，會把源類中的屬性更新到目標類中。更新規則還是由@Mapping指定。

7.沒有getter/setter也能賦值

對于沒有getter/setter的屬性也能實現賦值操作

publicclassCustomer{

privateLongid;
privateStringname;

//gettersandsetteromittedforbrevity
}

publicclassCustomerDto{

publicLongid;
publicStringcustomerName;
}

@Mapper
publicinterfaceCustomerMapper{

CustomerMapperINSTANCE=Mappers.getMapper(CustomerMapper.class);

@Mapping(source="customerName",target="name")
CustomertoCustomer(CustomerDtocustomerDto);

@InheritInverseConfiguration
CustomerDtofromCustomer(Customercustomer);
}

@Mapping(source = “customerName”, target = “name”)不是用來指定屬性映射的，如果兩個對象的屬性名相同是可以省略@Mapping的。

MapStruct生成的實現類：

@Generated(
value="org.mapstruct.ap.MappingProcessor",
date="2019-02-14T1521+0800",
comments="version:1.3.0.Final,compiler:javac,environment:Java1.8.0_181(OracleCorporation)"
)
publicclassCustomerMapperImplimplementsCustomerMapper{

@Override
publicCustomertoCustomer(CustomerDtocustomerDto){
if(customerDto==null){
returnnull;
}

Customercustomer=newCustomer();

customer.setName(customerDto.customerName);
customer.setId(customerDto.id);

returncustomer;
}

@Override
publicCustomerDtotoCustomerDto(Customercustomer){
if(customer==null){
returnnull;
}

CustomerDtocustomerDto=newCustomerDto();

customerDto.customerName=customer.getName();
customerDto.id=customer.getId();

returncustomerDto;
}
}

@InheritInverseConfiguration在這里的作用就是實現customerDto.customerName = customer.getName();功能的。如果沒有這個注解，toCustomerDto這個方法則不會有customerName 和name兩個屬性的對應關系的。

8.使用Spring依賴注入

@Data
@NoArgsConstructor
@AllArgsConstructor
publicclassCustomer{
privateLongid;
privateStringname;
}

@Data
publicclassCustomerDto{
privateLongid;
privateStringcustomerName;
}

//這里主要是這個componentModel屬性，它的值就是當前要使用的依賴注入的環境
@Mapper(componentModel="spring")
publicinterfaceCustomerMapper{

@Mapping(source="name",target="customerName")
CustomerDtotoCustomerDto(Customercustomer);
}

@Mapper(componentModel = “spring”)，表示把當前Mapper類納入spring容器。可以在其它類中直接注入了：

@SpringBootApplication
@RestController
publicclassDemoMapstructApplication{

//注入Mapper
@Autowired
privateCustomerMappermapper;

publicstaticvoidmain(String[]args){
SpringApplication.run(DemoMapstructApplication.class,args);
}

@GetMapping("/test")
publicStringtest(){
Customercustomer=newCustomer(1L,"zhangsan");
CustomerDtocustomerDto=mapper.toCustomerDto(customer);
returncustomerDto.toString();
}

}

看一下由mapstruct自動生成的類文件，會發現標記了@Component注解。

@Generated(
value="org.mapstruct.ap.MappingProcessor",
date="2019-02-14T1517+0800",
comments="version:1.3.0.Final,compiler:javac,environment:Java1.8.0_181(OracleCorporation)"
)
@Component
publicclassCustomerMapperImplimplementsCustomerMapper{

@Override
publicCustomerDtotoCustomerDto(Customercustomer){
if(customer==null){
returnnull;
}

CustomerDtocustomerDto=newCustomerDto();

customerDto.setCustomerName(customer.getName());
customerDto.setId(customer.getId());

returncustomerDto;
}
}

9.自定義類型轉換

有時候，在對象轉換的時候可能會出現這樣一個問題，就是源對象中的類型是Boolean類型，而目標對象類型是String類型，這種情況可以通過@Mapper的uses屬性來實現：

@Data
@NoArgsConstructor
@AllArgsConstructor
publicclassCustomer{
privateLongid;
privateStringname;
privateBooleanisDisable;
}

@Data
publicclassCustomerDto{
privateLongid;
privateStringcustomerName;
privateStringdisable;
}

定義轉換規則的類：

publicclassBooleanStrFormat{
publicStringtoStr(BooleanisDisable){
if(isDisable){
return"Y";
}else{
return"N";
}
}
publicBooleantoBoolean(Stringstr){
if(str.equals("Y")){
returntrue;
}else{
returnfalse;
}
}
}

定義Mapper，@Mapper( uses = { BooleanStrFormat.class})，注意，這里的users屬性用于引用之前定義的轉換規則的類：

@Mapper(uses={BooleanStrFormat.class})
publicinterfaceCustomerMapper{

CustomerMapperINSTANCES=Mappers.getMapper(CustomerMapper.class);

@Mappings({
@Mapping(source="name",target="customerName"),
@Mapping(source="isDisable",target="disable")
})
CustomerDtotoCustomerDto(Customercustomer);
}

這樣子，Customer類中的isDisable屬性的true就會轉變成CustomerDto中的disable屬性的yes。

MapStruct自動生成的類中的代碼：

@Generated(
value="org.mapstruct.ap.MappingProcessor",
date="2019-02-14T1618+0800",
comments="version:1.3.0.Final,compiler:javac,environment:Java1.8.0_181(OracleCorporation)"
)
publicclassCustomerMapperImplimplementsCustomerMapper{

//引用uses中指定的類
privatefinalBooleanStrFormatbooleanStrFormat=newBooleanStrFormat();

@Override
publicCustomerDtotoCustomerDto(Customercustomer){
if(customer==null){
returnnull;
}

CustomerDtocustomerDto=newCustomerDto();
//轉換方式的使用
customerDto.setDisable(booleanStrFormat.toStr(customer.getIsDisable()));
customerDto.setCustomerName(customer.getName());
customerDto.setId(customer.getId());

returncustomerDto;
}
}

要注意的是，如果使用了例如像spring這樣的環境，Mapper引入uses類實例的方式將是自動注入，那么這個類也應該納入Spring容器：

CustomerMapper.java指定使用spring

@Mapper(componentModel="spring",uses={BooleanStrFormat.class})
publicinterfaceCustomerMapper{

CustomerMapperINSTANCES=Mappers.getMapper(CustomerMapper.class);

@Mappings({
@Mapping(source="name",target="customerName"),
@Mapping(source="isDisable",target="disable")
})
CustomerDtotoCustomerDto(Customercustomer);
}

轉換類要加入Spring容器：

@Component
publicclassBooleanStrFormat{
publicStringtoStr(BooleanisDisable){
if(isDisable){
return"Y";
}else{
return"N";
}
}
publicBooleantoBoolean(Stringstr){
if(str.equals("Y")){
returntrue;
}else{
returnfalse;
}
}
}

MapStruct自動生成的類：

@Generated(
value="org.mapstruct.ap.MappingProcessor",
date="2019-02-14T1635+0800",
comments="version:1.3.0.Final,compiler:javac,environment:Java1.8.0_181(OracleCorporation)"
)
@Component
publicclassCustomerMapperImplimplementsCustomerMapper{

//使用自動注入的方式引入
@Autowired
privateBooleanStrFormatbooleanStrFormat;

@Override
publicCustomerDtotoCustomerDto(Customercustomer){
if(customer==null){
returnnull;
}

CustomerDtocustomerDto=newCustomerDto();

customerDto.setDisable(booleanStrFormat.toStr(customer.getIsDisable()));
customerDto.setCustomerName(customer.getName());
customerDto.setId(customer.getId());

returncustomerDto;
}
}

原文標題：實體映射最強工具類：MapStruct 真香！