實體映射最強工具類：MapStruct 真香！
首先來了解一下DTO，DTO簡單的理解就是做數(shù)據(jù)傳輸對象的，類似于VO，但是VO用于傳輸?shù)角岸?。（~~）
1.MapStruct是用來做什么的？
現(xiàn)在有這么個場景，從數(shù)據(jù)庫查詢出來了一個user對象（包含id，用戶名，密碼，手機號，郵箱，角色這些字段）和一個對應(yīng)的角色對象role（包含id，角色名，角色描述這些字段），現(xiàn)在在controller需要用到user對象的id，用戶名，和角色對象的角色名三個屬性。
一種方式是直接把兩個對象傳遞到controller層，但是這樣會多出很多沒用的屬性。更通用的方式是需要用到的屬性封裝成一個類(DTO)，通過傳輸這個類的實例來完成數(shù)據(jù)傳輸。
User.java
@AllArgsConstructor
@Data
public class User {
private Long id;
private String username;
private String password;
private String phoneNum;
private String email;
private Role role;
}
Role.java
@AllArgsConstructor
@Data
public class Role {
private Long id;
private String roleName;
private String description;
}
UserRoleDto.java，這個類就是封裝的類
@Data
public class UserRoleDto {
/**
* 用戶id
*/
private Long userId;
/**
* 用戶名
*/
private String name;
/**
* 角色名
*/
private String roleName;
}
測試類，模擬將user對象轉(zhuǎn)換成UserRoleDto對象
public class MainTest {
User user = null;
/**
* 模擬從數(shù)據(jù)庫中查出user對象
*/
@Before
public void before() {
Role role = new Role(2L, "administrator", "超級管理員");
user = new User(1L, "zhangsan", "12345", "17677778888", "[email protected]", role);
}
/**
* 模擬把user對象轉(zhuǎn)換成UserRoleDto對象
*/
@Test
public void test1() {
UserRoleDto userRoleDto = new UserRoleDto();
userRoleDto.setUserId(user.getId());
userRoleDto.setName(user.getUsername());
userRoleDto.setRoleName(user.getRole().getRoleName());
System.out.println(userRoleDto);
}
}
從上面代碼可以看出，通過getter、setter的方式把一個對象屬性值復(fù)制到另一個對象中去還是很麻煩的，尤其是當(dāng)屬性過多的時候。而MapStruct就是用于解決這種問題的。
2.使用MapStruct解決上述問題
這里我們沿用User.java、Role.java、UserRoleDto.java。
新建一個UserRoleMapper.java，這個來用來定義User.java、Role.java和UserRoleDto.java之間屬性對應(yīng)規(guī)則：
UserRoleMapper.java
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
* @Mapper 定義這是一個MapStruct對象屬性轉(zhuǎn)換接口，在這個類里面規(guī)定轉(zhuǎn)換規(guī)則
* 在項目構(gòu)建時，會自動生成改接口的實現(xiàn)類，這個實現(xiàn)類將實現(xiàn)對象屬性值復(fù)制
*/
@Mapper
public interface UserRoleMapper {
/**
* 獲取該類自動生成的實現(xiàn)類的實例
* 接口中的屬性都是 public static final 的 方法都是public abstract的
*/
UserRoleMapper INSTANCES = Mappers.getMapper(UserRoleMapper.class);
/**
* 這個方法就是用于實現(xiàn)對象屬性復(fù)制的方法
*
* @Mapping 用來定義屬性復(fù)制規(guī)則 source 指定源對象屬性 target指定目標(biāo)對象屬性
*
* @param user 這個參數(shù)就是源對象，也就是需要被復(fù)制的對象
* @return 返回的是目標(biāo)對象，就是最終的結(jié)果對象
*/
@Mappings({
@Mapping(source = "id", target = "userId"),
@Mapping(source = "username", target = "name"),
@Mapping(source = "role.roleName", target = "roleName")
})
UserRoleDto toUserRoleDto(User user);
}
在測試類中測試：
通過上面的例子可以看出，使用MapStruct方便許多。
3.添加默認(rèn)方法
添加默認(rèn)方法是為了這個類（接口）不只是為了做數(shù)據(jù)轉(zhuǎn)換用的，也可以做一些其他的事。
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
* @Mapper 定義這是一個MapStruct對象屬性轉(zhuǎn)換接口，在這個類里面規(guī)定轉(zhuǎn)換規(guī)則
* 在項目構(gòu)建時，會自動生成改接口的實現(xiàn)類，這個實現(xiàn)類將實現(xiàn)對象屬性值復(fù)制
*/
@Mapper
public interface UserRoleMapper {
/**
* 獲取該類自動生成的實現(xiàn)類的實例
* 接口中的屬性都是 public static final 的 方法都是public abstract的
*/
UserRoleMapper INSTANCES = Mappers.getMapper(UserRoleMapper.class);
/**
* 這個方法就是用于實現(xiàn)對象屬性復(fù)制的方法
*
* @Mapping 用來定義屬性復(fù)制規(guī)則 source 指定源對象屬性 target指定目標(biāo)對象屬性
*
* @param user 這個參數(shù)就是源對象，也就是需要被復(fù)制的對象
* @return 返回的是目標(biāo)對象，就是最終的結(jié)果對象
*/
@Mappings({
@Mapping(source = "id", target = "userId"),
@Mapping(source = "username", target = "name"),
@Mapping(source = "role.roleName", target = "roleName")
})
UserRoleDto toUserRoleDto(User user);
/**
* 提供默認(rèn)方法，方法自己定義，這個方法是我隨便寫的，不是要按照這個格式來的
* @return
*/
default UserRoleDto defaultConvert() {
UserRoleDto userRoleDto = new UserRoleDto();
userRoleDto.setUserId(0L);
userRoleDto.setName("None");
userRoleDto.setRoleName("None");
return userRoleDto;
}
}
測試代碼：
@Test
public void test3() {
UserRoleMapper userRoleMapperInstances = UserRoleMapper.INSTANCES;
UserRoleDto userRoleDto = userRoleMapperInstances.defaultConvert();
System.out.println(userRoleDto);
}
4. 可以使用abstract class來代替接口
mapper可以用接口來實現(xiàn)，也可以完全由抽象來完全代替
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
* @Mapper 定義這是一個MapStruct對象屬性轉(zhuǎn)換接口，在這個類里面規(guī)定轉(zhuǎn)換規(guī)則
* 在項目構(gòu)建時，會自動生成改接口的實現(xiàn)類，這個實現(xiàn)類將實現(xiàn)對象屬性值復(fù)制
*/
@Mapper
public abstract class UserRoleMapper {
/**
* 獲取該類自動生成的實現(xiàn)類的實例
* 接口中的屬性都是 public static final 的 方法都是public abstract的
*/
public static final UserRoleMapper INSTANCES = Mappers.getMapper(UserRoleMapper.class);
/**
* 這個方法就是用于實現(xiàn)對象屬性復(fù)制的方法
*
* @Mapping 用來定義屬性復(fù)制規(guī)則 source 指定源對象屬性 target指定目標(biāo)對象屬性
*
* @param user 這個參數(shù)就是源對象，也就是需要被復(fù)制的對象
* @return 返回的是目標(biāo)對象，就是最終的結(jié)果對象
*/
@Mappings({
@Mapping(source = "id", target = "userId"),
@Mapping(source = "username", target = "name"),
@Mapping(source = "role.roleName", target = "roleName")
})
public abstract UserRoleDto toUserRoleDto(User user);
/**
* 提供默認(rèn)方法，方法自己定義，這個方法是我隨便寫的，不是要按照這個格式來的
* @return
*/
UserRoleDto defaultConvert() {
UserRoleDto userRoleDto = new UserRoleDto();
userRoleDto.setUserId(0L);
userRoleDto.setName("None");
userRoleDto.setRoleName("None");
return userRoleDto;
}
}
5.可以使用多個參數(shù)
可以綁定多個對象的屬性值到目標(biāo)對象中：
package com.mapstruct.demo;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
* @Mapper 定義這是一個MapStruct對象屬性轉(zhuǎn)換接口，在這個類里面規(guī)定轉(zhuǎn)換規(guī)則
* 在項目構(gòu)建時，會自動生成改接口的實現(xiàn)類，這個實現(xiàn)類將實現(xiàn)對象屬性值復(fù)制
*/
@Mapper
public interface UserRoleMapper {
/**
* 獲取該類自動生成的實現(xiàn)類的實例
* 接口中的屬性都是 public static final 的 方法都是public abstract的
*/
UserRoleMapper INSTANCES = Mappers.getMapper(UserRoleMapper.class);
/**
* 這個方法就是用于實現(xiàn)對象屬性復(fù)制的方法
*
* @Mapping 用來定義屬性復(fù)制規(guī)則 source 指定源對象屬性 target指定目標(biāo)對象屬性
*
* @param user 這個參數(shù)就是源對象，也就是需要被復(fù)制的對象
* @return 返回的是目標(biāo)對象，就是最終的結(jié)果對象
*/
@Mappings({
@Mapping(source = "id", target = "userId"),
@Mapping(source = "username", target = "name"),
@Mapping(source = "role.roleName", target = "roleName")
})
UserRoleDto toUserRoleDto(User user);
/**
* 多個參數(shù)中的值綁定
* @param user 源1
* @param role 源2
* @return 從源1、2中提取出的結(jié)果
*/
@Mappings({
@Mapping(source = "user.id", target = "userId"), // 把user中的id綁定到目標(biāo)對象的userId屬性中
@Mapping(source = "user.username", target = "name"), // 把user中的username綁定到目標(biāo)對象的name屬性中
@Mapping(source = "role.roleName", target = "roleName") // 把role對象的roleName屬性值綁定到目標(biāo)對象的roleName中
})
UserRoleDto toUserRoleDto(User user, Role role);
對比兩個方法~
5.直接使用參數(shù)作為屬性值
package com.mapstruct.demo;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;
/**
* @Mapper 定義這是一個MapStruct對象屬性轉(zhuǎn)換接口，在這個類里面規(guī)定轉(zhuǎn)換規(guī)則
* 在項目構(gòu)建時，會自動生成改接口的實現(xiàn)類，這個實現(xiàn)類將實現(xiàn)對象屬性值復(fù)制
*/
@Mapper
public interface UserRoleMapper {
/**
* 獲取該類自動生成的實現(xiàn)類的實例
* 接口中的屬性都是 public static final 的 方法都是public abstract的
*/
UserRoleMapper INSTANCES = Mappers.getMapper(UserRoleMapper.class);
/**
* 直接使用參數(shù)作為值
* @param user
* @param myRoleName
* @return
*/
@Mappings({
@Mapping(source = "user.id", target = "userId"), // 把user中的id綁定到目標(biāo)對象的userId屬性中
@Mapping(source = "user.username", target = "name"), // 把user中的username綁定到目標(biāo)對象的name屬性中
@Mapping(source = "myRoleName", target = "roleName") // 把role對象的roleName屬性值綁定到目標(biāo)對象的roleName中
})
UserRoleDto useParameter(User user, String myRoleName);
}
測試類：
public class Test1 {
Role role = null;
User user = null;
@Before
public void before() {
role = new Role(2L, "administrator", "超級管理員");
user = new User(1L, "zhangsan", "12345", "17677778888", "[email protected]", role);
}
@Test
public void test1() {
UserRoleMapper instances = UserRoleMapper.INSTANCES;
UserRoleDto userRoleDto = instances.useParameter(user, "myUserRole");
System.out.println(userRoleDto);
}
}
6.更新對象屬性
在之前的例子中UserRoleDto useParameter(User user, String myRoleName);都是通過類似上面的方法來生成一個對象。而MapStruct提供了另外一種方式來更新一個對象中的屬性。@MappingTarget
public interface UserRoleMapper1 {
UserRoleMapper1 INSTANCES = Mappers.getMapper(UserRoleMapper1.class);
@Mappings({
@Mapping(source = "userId", target = "id"),
@Mapping(source = "name", target = "username"),
@Mapping(source = "roleName", target = "role.roleName")
})
void updateDto(UserRoleDto userRoleDto, @MappingTarget User user);
@Mappings({
@Mapping(source = "id", target = "userId"),
@Mapping(source = "username", target = "name"),
@Mapping(source = "role.roleName", target = "roleName")
})
void update(User user, @MappingTarget UserRoleDto userRoleDto);
}
通過@MappingTarget來指定目標(biāo)類是誰（誰的屬性需要被更新）。@Mapping還是用來定義屬性對應(yīng)規(guī)則。
以此為例說明：
@Mappings({
@Mapping(source = "id", target = "userId"),
@Mapping(source = "username", target = "name"),
@Mapping(source = "role.roleName", target = "roleName")
})
void update(User user, @MappingTarget UserRoleDto userRoleDto);
@MappingTarget標(biāo)注的類UserRoleDto 為目標(biāo)類，user類為源類，調(diào)用此方法，會把源類中的屬性更新到目標(biāo)類中。更新規(guī)則還是由@Mapping指定。
7.沒有g(shù)etter/setter也能賦值
對于沒有g(shù)etter/setter的屬性也能實現(xiàn)賦值操作
public class Customer {
private Long id;
private String name;
//getters and setter omitted for brevity
}
public class CustomerDto {
public Long id;
public String customerName;
}
@Mapper
public interface CustomerMapper {
CustomerMapper INSTANCE = Mappers.getMapper( CustomerMapper.class );
@Mapping(source = "customerName", target = "name")
Customer toCustomer(CustomerDto customerDto);
@InheritInverseConfiguration
CustomerDto fromCustomer(Customer customer);
}
@Mapping(source = “customerName”, target = “name”)不是用來指定屬性映射的，如果兩個對象的屬性名相同是可以省略@Mapping的。
MapStruct生成的實現(xiàn)類：
@Generated(
value = "org.mapstruct.ap.MappingProcessor",
date = "2019-02-14T15:41:21+0800",
comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
public class CustomerMapperImpl implements CustomerMapper {
@Override
public Customer toCustomer(CustomerDto customerDto) {
if ( customerDto == null ) {
return null;
}
Customer customer = new Customer();
customer.setName( customerDto.customerName );
customer.setId( customerDto.id );
return customer;
}
@Override
public CustomerDto toCustomerDto(Customer customer) {
if ( customer == null ) {
return null;
}
CustomerDto customerDto = new CustomerDto();
customerDto.customerName = customer.getName();
customerDto.id = customer.getId();
return customerDto;
}
}
@InheritInverseConfiguration在這里的作用就是實現(xiàn)customerDto.customerName = customer.getName();功能的。如果沒有這個注解，toCustomerDto這個方法則不會有customerName 和name兩個屬性的對應(yīng)關(guān)系的。
8.使用Spring依賴注入
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Customer {
private Long id;
private String name;
}
@Data
public class CustomerDto {
private Long id;
private String customerName;
}
// 這里主要是這個componentModel 屬性，它的值就是當(dāng)前要使用的依賴注入的環(huán)境
@Mapper(componentModel = "spring")
public interface CustomerMapper {
@Mapping(source = "name", target = "customerName")
CustomerDto toCustomerDto(Customer customer);
}
@Mapper(componentModel = “spring”)，表示把當(dāng)前Mapper類納入spring容器?？梢栽谄渌愔兄苯幼⑷肓耍?/p>
@SpringBootApplication
@RestController
public class DemoMapstructApplication {
// 注入Mapper
@Autowired
private CustomerMapper mapper;
public static void main(String[] args) {
SpringApplication.run(DemoMapstructApplication.class, args);
}
@GetMapping("/test")
public String test() {
Customer customer = new Customer(1L, "zhangsan");
CustomerDto customerDto = mapper.toCustomerDto(customer);
return customerDto.toString();
}
}
看一下由mapstruct自動生成的類文件，會發(fā)現(xiàn)標(biāo)記了@Component注解。
@Generated(
value = "org.mapstruct.ap.MappingProcessor",
date = "2019-02-14T15:54:17+0800",
comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
@Component
public class CustomerMapperImpl implements CustomerMapper {
@Override
public CustomerDto toCustomerDto(Customer customer) {
if ( customer == null ) {
return null;
}
CustomerDto customerDto = new CustomerDto();
customerDto.setCustomerName( customer.getName() );
customerDto.setId( customer.getId() );
return customerDto;
}
}
9.自定義類型轉(zhuǎn)換
有時候，在對象轉(zhuǎn)換的時候可能會出現(xiàn)這樣一個問題，就是源對象中的類型是Boolean類型，而目標(biāo)對象類型是String類型，這種情況可以通過@Mapper的uses屬性來實現(xiàn)：
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Customer {
private Long id;
private String name;
private Boolean isDisable;
}
@Data
public class CustomerDto {
private Long id;
private String customerName;
private String disable;
}
定義轉(zhuǎn)換規(guī)則的類：
public class BooleanStrFormat {
public String toStr(Boolean isDisable) {
if (isDisable) {
return "Y";
} else {
return "N";
}
}
public Boolean toBoolean(String str) {
if (str.equals("Y")) {
return true;
} else {
return false;
}
}
}
定義Mapper，@Mapper( uses = { BooleanStrFormat.class})，注意，這里的users屬性用于引用之前定義的轉(zhuǎn)換規(guī)則的類：
@Mapper( uses = { BooleanStrFormat.class})
public interface CustomerMapper {
CustomerMapper INSTANCES = Mappers.getMapper(CustomerMapper.class);
@Mappings({
@Mapping(source = "name", target = "customerName"),
@Mapping(source = "isDisable", target = "disable")
})
CustomerDto toCustomerDto(Customer customer);
}
這樣子，Customer類中的isDisable屬性的true就會轉(zhuǎn)變成CustomerDto中的disable屬性的yes。
MapStruct自動生成的類中的代碼：
@Generated(
value = "org.mapstruct.ap.MappingProcessor",
date = "2019-02-14T16:49:18+0800",
comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
public class CustomerMapperImpl implements CustomerMapper {
// 引用 uses 中指定的類
private final BooleanStrFormat booleanStrFormat = new BooleanStrFormat();
@Override
public CustomerDto toCustomerDto(Customer customer) {
if ( customer == null ) {
return null;
}
CustomerDto customerDto = new CustomerDto();
// 轉(zhuǎn)換方式的使用
customerDto.setDisable( booleanStrFormat.toStr( customer.getIsDisable() ) );
customerDto.setCustomerName( customer.getName() );
customerDto.setId( customer.getId() );
return customerDto;
}
}
要注意的是，如果使用了例如像spring這樣的環(huán)境，Mapper引入uses類實例的方式將是自動注入，那么這個類也應(yīng)該納入Spring容器：
CustomerMapper.java指定使用spring
@Mapper(componentModel = "spring", uses = { BooleanStrFormat.class})
public interface CustomerMapper {
CustomerMapper INSTANCES = Mappers.getMapper(CustomerMapper.class);
@Mappings({
@Mapping(source = "name", target = "customerName"),
@Mapping(source = "isDisable", target = "disable")
})
CustomerDto toCustomerDto(Customer customer);
}
轉(zhuǎn)換類要加入Spring容器：
@Component
public class BooleanStrFormat {
public String toStr(Boolean isDisable) {
if (isDisable) {
return "Y";
} else {
return "N";
}
}
public Boolean toBoolean(String str) {
if (str.equals("Y")) {
return true;
} else {
return false;
}
}
}
MapStruct自動生成的類：
@Generated(
value = "org.mapstruct.ap.MappingProcessor",
date = "2019-02-14T16:55:35+0800",
comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
@Component
public class CustomerMapperImpl implements CustomerMapper {
// 使用自動注入的方式引入
@Autowired
private BooleanStrFormat booleanStrFormat;
@Override
public CustomerDto toCustomerDto(Customer customer) {
if ( customer == null ) {
return null;
}
CustomerDto customerDto = new CustomerDto();
customerDto.setDisable( booleanStrFormat.toStr( customer.getIsDisable() ) );
customerDto.setCustomerName( customer.getName() );
customerDto.setId( customer.getId() );
return customerDto;
}
}評論
圖片
表情