devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

简化Java代码的组件 MapStruct使用_打包自动生成convert实现类

作者：Cpp五条 | 2024-03-22 15:41:27

赞

踩

打包自动生成convert实现类

我们在实际开发过程中会出现很多bean之间的拷贝动作，这样的动作需要不停的去进行set操作。容易造成代码的耦合和维护困难。通过MapStruct我们只需要定义一个接口，这个工具包会帮我们自动生成一个实现类，并且这个类是不可编辑的，代码自动生成帮我们省去了开发维护成本同时做了一定的解耦。

MapStruct注解

  • @Mapper：注解在接口、类上，这样 MapStruct 才会去实现该接口
    • componentModel：该属性用于指定实现类的类型，有几个属性：
      • default：默认，不使用任何组建类型，可以通过Mappers.getMapper(Class) 方式获取实例对象
      • spring：在实现类上注解 @Component，可通过 @Autowired 方式注入
      • jsr330：实现类上添加@javax.inject.Named 和@Singleton注解，可以通过 @Inject注解获取。
  • @Mappings：配置多个@Mapping
  • @Mapping：配置属性映射，若源对象属性与目标对象名字一致，会自动映射对应属性
    • source：源属性、target：目标属性
    • dateFormat：可将 String 到 Date 日期之间相互转换，通过 SimpleDateFormat，该值为 SimpleDateFormat 的日期格式

Maven依赖

使用MapStruct我们需要通过maven导入相关的依赖：

  1. <dependency>
  2.     <groupId>org.mapstruct</groupId>
  3.     <artifactId>mapstruct-jdk8</artifactId>
  4.     <version>1.3.0.Beta2</version> 
  5. </dependency>

同时我们需要添加maven-compiler-plugin，其中mapstruct-processor用于构建mapper实现类的生成器。

  1. <plugin>
  2.     <groupId>org.apache.maven.plugins</groupId>
  3.     <artifactId>maven-compiler-plugin</artifactId>
  4.     <version>3.5.1</version>
  5.     <configuration>
  6.         <source>1.8</source>
  7.         <target>1.8</target>
  8.         <annotationProcessorPaths>
  9.             <path>
  10.                 <groupId>org.mapstruct</groupId>
  11.                 <artifactId>mapstruct-processor</artifactId>
  12.                 <version>1.3.0.Beta2</version>
  13.             </path>
  14.         </annotationProcessorPaths>
  15.     </configuration>
  16. </plugin>

  1. @Autowired
  2. private GoodInfoMapper goodInfoMapper;
  3.  
  4. @RequestMapping(value = "/detail/{id}")
  5. public GoodInfoDTO details(@PathVariable("id")Long id){
  6.     GoodInfo goodInfo = goodInfoRepository.findOne(id);
  7.     GoodType goodType = goodTypeRepository.findOne(goodInfo.getId());
  8.     return goodInfoMapper.fromGoodInfoDTO(goodInfo,goodType);
  9. }

1.MapStruct是用来做什么的？

现在有这么个场景，从数据库查询出来了一个user对象（包含id，用户名，密码，手机号，邮箱，角色这些字段）和一个对应的角色对象role（包含id，角色名，角色描述这些字段），现在在controller需要用到user对象的id，用户名，和角色对象的角色名三个属性。一种方式是直接把两个对象传递到controller层，但是这样会多出很多没用的属性。更通用的方式是需要用到的属性封装成一个类(DTO)，通过传输这个类的实例来完成数据传输。
User.java

  1. @AllArgsConstructor
  2. @Data
  3. public class User {
  4.     private Long id;
  5.     private String username;
  6.     private String password;
  7.     private String phoneNum;
  8.     private String email;
  9.     private Role role;
  10. }

Role.java

  1. @AllArgsConstructor
  2. @Data
  3. public class Role {
  4.     private Long id;
  5.     private String roleName;
  6.     private String description;
  7. }
  8.

UserRoleDto.java，这个类就是封装的类

  1. @Data
  2. public class UserRoleDto {
  3.     /**
  4.      * 用户id
  5.      */
  6.     private Long userId;
  7.     /**
  8.      * 用户名
  9.      */
  10.     private String name;
  11.     /**
  12.      * 角色名
  13.      */
  14.     private String roleName;
  15. }
  16.

测试类，模拟将user对象转换成UserRoleDto对象

  1. public class MainTest {
  2.     User user = null;
  3.  
  4.     /**
  5.      * 模拟从数据库中查出user对象
  6.      */
  7.     @Before
  8.     public void before() {
  9.        Role role  = new Role(2L, "administrator", "超级管理员");
  10.        user  = new User(1L, "zhangsan", "12345", "17677778888", "123@qq.com", role);
  11.     }
  12.  
  13.     /**
  14.      * 模拟把user对象转换成UserRoleDto对象
  15.      */
  16.     @Test
  17.     public void test1() {
  18.         UserRoleDto userRoleDto = new UserRoleDto();
  19.         userRoleDto.setUserId(user.getId());
  20.         userRoleDto.setName(user.getUsername());
  21.         userRoleDto.setRoleName(user.getRole().getRoleName());
  22.         System.out.println(userRoleDto);
  23.     }
  24. }
  25.

从上面代码可以看出，通过getter、setter的方式把一个对象属性值复制到另一个对象中去还是很麻烦的，尤其是当属性过多的时候。而MapStruct就是用于解决这种问题的。

2.使用MapStruct解决上述问题

这里我们沿用User.java、Role.java、UserRoleDto.java。新建一个UserRoleConvert.java，这个来用来定义User.java、Role.java和UserRoleDto.java之间属性对应规则：
UserRoleConvert.java

  1. import org.mapstruct.Mapper;
  2. import org.mapstruct.Mapping;
  3. import org.mapstruct.Mappings;
  4. import org.mapstruct.factory.Mappers;
  5.  
  6. /**
  7.  * @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则
  8.  *          在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制
  9.  */
  10. @Mapper
  11. public interface UserRoleConvert {
  12.  
  13.     /**
  14.      * 获取该类自动生成的实现类的实例
  15.      * 接口中的属性都是 public static final 的 方法都是public abstract的
  16.      */
  17.     UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);
  18.  
  19.     /**
  20.      * 这个方法就是用于实现对象属性复制的方法
  21.      *
  22.      * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
  23.      *
  24.      * @param user 这个参数就是源对象，也就是需要被复制的对象
  25.      * @return 返回的是目标对象，就是最终的结果对象
  26.      */
  27.     @Mappings({
  28.             @Mapping(source = "id", target = "userId"),
  29.             @Mapping(source = "username", target = "name"),
  30.             @Mapping(source = "role.roleName", target = "roleName")
  31.     })
  32.     UserRoleDto toUserRoleDto(User user);
  33. }

在测试类中测试：

  1. public class MainTest {
  2.     User user = null;
  3.  
  4.     /**
  5.      * 模拟从数据库中查出user对象
  6.      */
  7.     @Before
  8.     public void before() {
  9.        Role role  = new Role(2L, "administrator", "超级管理员");
  10.        user  = new User(1L, "zhangsan", "12345", "17677778888", "123@qq.com", role);
  11.     }
  12.  
  13.     /**
  14.      * 模拟通过MapStruct把user对象转换成UserRoleDto对象
  15.      */
  16.     @Test
  17.     public void test2() {
  18.         UserRoleDto userRoleDto = UserRoleConvert.INSTANCES.toUserRoleDto(user);
  19.         System.out.println(userRoleDto);
  20.     }
  21. }

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

3.添加默认方法

添加默认方法是为了这个类（接口）不只是为了做数据转换用的，也可以做一些其他的事。将null设置成""空字符串

  1. import org.mapstruct.Mapper;
  2. import org.mapstruct.Mapping;
  3. import org.mapstruct.Mappings;
  4. import org.mapstruct.factory.Mappers;
  5.  
  6. /**
  7.  * @Mapper 将null设置成""空字符串
  8.  */
  9. @Mapper(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_DEFAULT,
  10. 		nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
  11. public interface UserRoleConvert {
  12.  
  13.     /**
  14.      * 获取该类自动生成的实现类的实例
  15.      * 接口中的属性都是 public static final 的 方法都是public abstract的
  16.      */
  17.     UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);
  18.  
  19.     /**
  20.      * 这个方法就是用于实现对象属性复制的方法
  21.      *
  22.      * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
  23.      *
  24.      * @param user 这个参数就是源对象，也就是需要被复制的对象
  25.      * @return 返回的是目标对象，就是最终的结果对象
  26.      */
  27.     @Mappings({
  28.             @Mapping(source = "id", target = "userId"),
  29.             @Mapping(source = "username", target = "name"),
  30.             @Mapping(source = "role.roleName", target = "roleName")
  31.     })
  32.     UserRoleDto toUserRoleDto(User user);
  33.  
  34.     /**
  35.      * 提供默认方法，方法自己定义，这个方法是我随便写的，不是要按照这个格式来的
  36.      * @return
  37.      */
  38.     default UserRoleDto defaultConvert() {
  39.         UserRoleDto userRoleDto = new UserRoleDto();
  40.         userRoleDto.setUserId(0L);
  41.         userRoleDto.setName("None");
  42.         userRoleDto.setRoleName("None");
  43.         return userRoleDto;
  44.     }
  45.  
  46. }

测试代码：

  1. @Test
  2. public void test3() {
  3.     UserRoleConvert userRoleConvertInstances = UserRoleConvert.INSTANCES;
  4.     UserRoleDto userRoleDto = userRoleConvertInstances.defaultConvert();
  5.     System.out.println(userRoleDto);
  6. }

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

mapper可以用接口来实现，也可以完全由抽象来完全代替

  1. import org.mapstruct.Mapper;
  2. import org.mapstruct.Mapping;
  3. import org.mapstruct.Mappings;
  4. import org.mapstruct.factory.Mappers;
  5.  
  6. /**
  7.  * @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则
  8.  *          在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制
  9.  */
  10. @Mapper
  11. public abstract class UserRoleConvert {
  12.  
  13.     /**
  14.      * 获取该类自动生成的实现类的实例
  15.      * 接口中的属性都是 public static final 的 方法都是public abstract的
  16.      */
  17.     public static final UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);
  18.  
  19.     /**
  20.      * 这个方法就是用于实现对象属性复制的方法
  21.      *
  22.      * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
  23.      *
  24.      * @param user 这个参数就是源对象，也就是需要被复制的对象
  25.      * @return 返回的是目标对象，就是最终的结果对象
  26.      */
  27.     @Mappings({
  28.             @Mapping(source = "id", target = "userId"),
  29.             @Mapping(source = "username", target = "name"),
  30.             @Mapping(source = "role.roleName", target = "roleName")
  31.     })
  32.     public abstract UserRoleDto toUserRoleDto(User user);
  33.  
  34.     /**
  35.      * 提供默认方法，方法自己定义，这个方法是我随便写的，不是要按照这个格式来的
  36.      * @return
  37.      */
  38.     UserRoleDto defaultConvert() {
  39.         UserRoleDto userRoleDto = new UserRoleDto();
  40.         userRoleDto.setUserId(0L);
  41.         userRoleDto.setName("None");
  42.         userRoleDto.setRoleName("None");
  43.         return userRoleDto;
  44.     }
  45.  
  46. }

5.可以使用多个参数

可以绑定多个对象的属性值到目标对象中：

  1. package com.mapstruct.demo;
  2.  
  3. import org.mapstruct.Mapper;
  4. import org.mapstruct.Mapping;
  5. import org.mapstruct.Mappings;
  6. import org.mapstruct.factory.Mappers;
  7.  
  8. /**
  9.  * @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则
  10.  *          在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制
  11.  */
  12. @Mapper
  13. public interface UserRoleConvert {
  14.  
  15.     /**
  16.      * 获取该类自动生成的实现类的实例
  17.      * 接口中的属性都是 public static final 的 方法都是public abstract的
  18.      */
  19.     UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);
  20.  
  21.     /**
  22.      * 这个方法就是用于实现对象属性复制的方法
  23.      *
  24.      * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
  25.      *
  26.      * @param user 这个参数就是源对象，也就是需要被复制的对象
  27.      * @return 返回的是目标对象，就是最终的结果对象
  28.      */
  29.     @Mappings({
  30.             @Mapping(source = "id", target = "userId"),
  31.             @Mapping(source = "username", target = "name"),
  32.             @Mapping(source = "role.roleName", target = "roleName")
  33.     })
  34.     UserRoleDto toUserRoleDto(User user);
  35.  
  36.     /**
  37.      * 多个参数中的值绑定 
  38.      * @param user 源1
  39.      * @param role 源2
  40.      * @return 从源1、2中提取出的结果
  41.      */
  42.     @Mappings({
  43.             @Mapping(source = "user.id", target = "userId"), // 把user中的id绑定到目标对象的userId属性中
  44.             @Mapping(source = "user.username", target = "name"), // 把user中的username绑定到目标对象的name属性中
  45.             @Mapping(source = "role.roleName", target = "roleName") // 把role对象的roleName属性值绑定到目标对象的roleName中
  46.     })
  47.     UserRoleDto toUserRoleDto(User user, Role role);

对比两个方法~

6.直接使用参数作为属性值

  1. package com.mapstruct.demo;
  2.  
  3. import org.mapstruct.Mapper;
  4. import org.mapstruct.Mapping;
  5. import org.mapstruct.Mappings;
  6. import org.mapstruct.factory.Mappers;
  7.  
  8. /**
  9.  * @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则
  10.  *          在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制
  11.  */
  12. @Mapper
  13. public interface UserRoleConvert {
  14.  
  15.     /**
  16.      * 获取该类自动生成的实现类的实例
  17.      * 接口中的属性都是 public static final 的 方法都是public abstract的
  18.      */
  19.     UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);
  20.  
  21.     /**
  22.      * 直接使用参数作为值
  23.      * @param user
  24.      * @param myRoleName
  25.      * @return
  26.      */
  27.     @Mappings({
  28.             @Mapping(source = "user.id", target = "userId"), // 把user中的id绑定到目标对象的userId属性中
  29.             @Mapping(source = "user.username", target = "name"), // 把user中的username绑定到目标对象的name属性中
  30.             @Mapping(source = "myRoleName", target = "roleName") // 把role对象的roleName属性值绑定到目标对象的roleName中
  31.     })
  32.     UserRoleDto useParameter(User user, String myRoleName);
  33.  
  34. }

测试类：

  1. public class Test1 {
  2.     Role role = null;
  3.     User user = null;
  4.  
  5.     @Before
  6.     public void before() {
  7.         role = new Role(2L, "administrator", "超级管理员");
  8.         user = new User(1L, "zhangsan", "12345", "17677778888", "123@qq.com", role);
  9.     }
  10.     @Test
  11.     public void test1() {
  12.         UserRoleConvert instances = UserRoleConvert.INSTANCES;
  13.         UserRoleDto userRoleDto = instances.useParameter(user, "myUserRole");
  14.         System.out.println(userRoleDto);
  15.     }
  16. }

7.更新对象属性

在之前的例子中UserRoleDto useParameter(User user, String myRoleName);都是通过类似上面的方法来生成一个对象。而MapStruct提供了另外一种方式来更新一个对象中的属性。@MappingTarget

  1. public interface UserRoleMapper1 {
  2.  
  3.     UserRoleMapper1 INSTANCES = Mappers.getMapper(UserRoleMapper1.class);
  4.  
  5.     @Mappings({
  6.             @Mapping(source = "userId", target = "id"),
  7.             @Mapping(source = "name", target = "username"),
  8.             @Mapping(source = "roleName", target = "role.roleName")
  9.     })
  10.     void updateDto(UserRoleDto userRoleDto, @MappingTarget User user);
  11.  
  12.  
  13.     @Mappings({
  14.             @Mapping(source = "id", target = "userId"),
  15.             @Mapping(source = "username", target = "name"),
  16.             @Mapping(source = "role.roleName", target = "roleName")
  17.     })
  18.     void update(User user, @MappingTarget UserRoleDto userRoleDto);
  19.  
  20. }

通过@MappingTarget来指定目标类是谁（谁的属性需要被更新）。@Mapping还是用来定义属性对应规则。
以此为例说明：

  1.  @Mappings({
  2.             @Mapping(source = "id", target = "userId"),
  3.             @Mapping(source = "username", target = "name"),
  4.             @Mapping(source = "role.roleName", target = "roleName")
  5.     })
  6.     void update(User user, @MappingTarget UserRoleDto userRoleDto);

@MappingTarget标注的类UserRoleDto 为目标类，user类为源类，调用此方法，会把源类中的属性更新到目标类中。更新规则还是由@Mapping指定。

8.没有getter/setter也能赋值

对于没有getter/setter的属性也能实现赋值操作

  1. public class Customer {
  2.  
  3.     private Long id;
  4.     private String name;
  5.  
  6.     //getters and setter omitted for brevity
  7. }
  8.  
  9. public class CustomerDto {
  10.  
  11.     public Long id;
  12.     public String customerName;
  13. }
  14.  
  15. @Mapper
  16. public interface CustomerMapper {
  17.  
  18.     CustomerMapper INSTANCE = Mappers.getMapper( CustomerMapper.class );
  19.  
  20.     @Mapping(source = "customerName", target = "name")
  21.     Customer toCustomer(CustomerDto customerDto);
  22.  
  23.     @InheritInverseConfiguration
  24.     CustomerDto fromCustomer(Customer customer);
  25. }

@Mapping(source = “customerName”, target = “name”)不是用来指定属性映射的，如果两个对象的属性名相同是可以省略@Mapping的。
MapStruct生成的实现类：

  1. @Generated(
  2.     value = "org.mapstruct.ap.MappingProcessor",
  3.     date = "2019-02-14T15:41:21+0800",
  4.     comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
  5. )
  6. public class CustomerMapperImpl implements CustomerMapper {
  7.  
  8.     @Override
  9.     public Customer toCustomer(CustomerDto customerDto) {
  10.         if ( customerDto == null ) {
  11.             return null;
  12.         }
  13.  
  14.         Customer customer = new Customer();
  15.  
  16.         customer.setName( customerDto.customerName );
  17.         customer.setId( customerDto.id );
  18.  
  19.         return customer;
  20.     }
  21.  
  22.     @Override
  23.     public CustomerDto toCustomerDto(Customer customer) {
  24.         if ( customer == null ) {
  25.             return null;
  26.         }
  27.  
  28.         CustomerDto customerDto = new CustomerDto();
  29.  
  30.         customerDto.customerName = customer.getName();
  31.         customerDto.id = customer.getId();
  32.  
  33.         return customerDto;
  34.     }
  35. }
  36.

@InheritInverseConfiguration在这里的作用就是实现customerDto.customerName = customer.getName();功能的。如果没有这个注解，toCustomerDto这个方法则不会有customerName 和name两个属性的对应关系的。

9.使用Spring依赖注入

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class Customer {
  5.     private Long id;
  6.     private String name;
  7. }
  8.  
  9. @Data
  10. public class CustomerDto {
  11.     private Long id;
  12.     private String customerName;
  13. }
  14.  
  15. // 这里主要是这个componentModel 属性，它的值就是当前要使用的依赖注入的环境
  16. @Mapper(componentModel = "spring")
  17. public interface CustomerMapper {
  18.  
  19.     @Mapping(source = "name", target = "customerName")
  20.     CustomerDto toCustomerDto(Customer customer);
  21. }
  22.

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

  1. @SpringBootApplication
  2. @RestController
  3. public class DemoMapstructApplication {
  4.  
  5. 	// 注入Mapper
  6.     @Autowired
  7.     private CustomerMapper mapper;
  8.  
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(DemoMapstructApplication.class, args);
  11.     }
  12.  
  13.     @GetMapping("/test")
  14.     public String test() {
  15.         Customer customer = new Customer(1L, "zhangsan");
  16.         CustomerDto customerDto = mapper.toCustomerDto(customer);
  17.         return customerDto.toString();
  18.     }
  19.  
  20. }

看一下由mapstruct自动生成的类文件，会发现标记了@Component注解。

  1. @Generated(
  2.     value = "org.mapstruct.ap.MappingProcessor",
  3.     date = "2019-02-14T15:54:17+0800",
  4.     comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
  5. )
  6. @Component
  7. public class CustomerMapperImpl implements CustomerMapper {
  8.  
  9.     @Override
  10.     public CustomerDto toCustomerDto(Customer customer) {
  11.         if ( customer == null ) {
  12.             return null;
  13.         }
  14.  
  15.         CustomerDto customerDto = new CustomerDto();
  16.  
  17.         customerDto.setCustomerName( customer.getName() );
  18.         customerDto.setId( customer.getId() );
  19.  
  20.         return customerDto;
  21.     }
  22. }

10.自定义类型转换

有时候，在对象转换的时候可能会出现这样一个问题，就是源对象中的类型是Boolean类型，而目标对象类型是String类型，这种情况可以通过@Mapper的uses属性来实现：

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class Customer {
  5.     private Long id;
  6.     private String name;
  7.     private Boolean isDisable;
  8. }
  9.  
  10. @Data
  11. public class CustomerDto {
  12.     private Long id;
  13.     private String customerName;
  14.     private String disable;
  15. }
  16.

定义转换规则的类：

  1. public class BooleanStrFormat {
  2.     public String toStr(Boolean isDisable) {
  3.         if (isDisable) {
  4.             return "Y";
  5.         } else {
  6.             return "N";
  7.         }
  8.     }
  9.     public Boolean toBoolean(String str) {
  10.         if (str.equals("Y")) {
  11.             return true;
  12.         } else {
  13.             return false;
  14.         }
  15.     }
  16. }
  17.

定义Mapper，@Mapper( uses = { BooleanStrFormat.class})，注意，这里的uses属性用于引用之前定义的转换规则的类：

  1. @Mapper( uses = { BooleanStrFormat.class})
  2. public interface CustomerMapper {
  3.  
  4.     CustomerMapper INSTANCES = Mappers.getMapper(CustomerMapper.class);
  5.  
  6.     @Mappings({
  7.             @Mapping(source = "name", target = "customerName"),
  8.             @Mapping(source = "isDisable", target = "disable")
  9.     })
  10.     CustomerDto toCustomerDto(Customer customer);
  11. }

这样子，Customer类中的isDisable属性的true就会转变成CustomerDto中的disable属性的yes。
MapStruct自动生成的类中的代码：

  1. @Generated(
  2.     value = "org.mapstruct.ap.MappingProcessor",
  3.     date = "2019-02-14T16:49:18+0800",
  4.     comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
  5. )
  6. public class CustomerMapperImpl implements CustomerMapper {
  7.  
  8. 	// 引用 uses 中指定的类
  9.     private final BooleanStrFormat booleanStrFormat = new BooleanStrFormat();
  10.  
  11.     @Override
  12.     public CustomerDto toCustomerDto(Customer customer) {
  13.         if ( customer == null ) {
  14.             return null;
  15.         }
  16.  
  17.         CustomerDto customerDto = new CustomerDto();
  18. 		// 转换方式的使用
  19.         customerDto.setDisable( booleanStrFormat.toStr( customer.getIsDisable() ) );
  20.         customerDto.setCustomerName( customer.getName() );
  21.         customerDto.setId( customer.getId() );
  22.  
  23.         return customerDto;
  24.     }
  25. }
  26.

要注意的是，如果使用了例如像spring这样的环境，Mapper引入uses类实例的方式将是自动注入，那么这个类也应该纳入Spring容器：
CustomerMapper.java指定使用spring

转换类要加入Spring容器：

  1. @Component
  2. public class BooleanStrFormat {
  3.     public String toStr(Boolean isDisable) {
  4.         if (isDisable) {
  5.             return "Y";
  6.         } else {
  7.             return "N";
  8.         }
  9.     }
  10.     public Boolean toBoolean(String str) {
  11.         if (str.equals("Y")) {
  12.             return true;
  13.         } else {
  14.             return false;
  15.         }
  16.     }
  17. }

MapStruct自动生成的类：

  1. @Generated(
  2.     value = "org.mapstruct.ap.MappingProcessor",
  3.     date = "2019-02-14T16:55:35+0800",
  4.     comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
  5. )
  6. @Component
  7. public class CustomerMapperImpl implements CustomerMapper {
  8.  
  9. 	// 使用自动注入的方式引入
  10.     @Autowired
  11.     private BooleanStrFormat booleanStrFormat;
  12.  
  13.     @Override
  14.     public CustomerDto toCustomerDto(Customer customer) {
  15.         if ( customer == null ) {
  16.             return null;
  17.         }
  18.  
  19.         CustomerDto customerDto = new CustomerDto();
  20.  
  21.         customerDto.setDisable( booleanStrFormat.toStr( customer.getIsDisable() ) );
  22.         customerDto.setCustomerName( customer.getName() );
  23.         customerDto.setId( customer.getId() );
  24.  
  25.         return customerDto;
  26.     }
  27. }

类型不一致，默认值和常量

  1. @Mapper(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_DEFAULT,
  2. 		nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
  3. public interface UserConvert {
  4. 	UserConvert INSTANCE = Mappers.getMapper(UserConvert.class);
  5.  
  6. 	Page<UserVO3> convert(Page<User> listPage);
  7. 	@Mappings({
  8. 			@Mapping(target = "createTime", source = "createTime", dateFormat = "yyyy-MM-dd HH:mm:ss"),
  9. 			@Mapping(source = "price", numberFormat = "$#.00"),
  10. 			@Mapping(target = "integerConstant", constant = "14"),
  11. 			@Mapping(target = "number", expression = "java(DettRitMapper.getLastDett(dvocRit).getNumber())"),
  12. 			@Mapping(target = "agNickName", source = "agNickname", defaultValue = ""),
  13. 	})
  14. 	UserVO3 toConvertVO3(User user);

qualifiedByName的意思就是使用这个Mapper接口中的指定的默认方法去处理这个属性的转换，而不是简单的get set

  1. public class UserVO5 {
  2.     /**
  3.      * 原始通话类型 1  呼入 2 呼出
  4.      */
  5.     private Integer callType;​
  6.  
  7.     /**
  8.      * 原始通话类型名称 呼入 呼出
  9.      */
  10.     private String callTypeStr;
  11. }
  12.  
  13. @Mapping(source = "callTypeStr", target = "callType", qualifiedByName = "callType")
  14. UserVO5 convert(User user);
  15.  
  16. //列表
  17. Page<UserVO5> convertList(Page<User> list);
  18.  
  19. @Named("callType") //需要起个名字，不然报错,可以与方法名一致，当然也可以不一致
  20. default String getCallType(String value) {
  21.     if (value == 1) {
  22.         return "呼出";
  23.     } else {
  24.         return "呼入";
  25.     }
  26. }

注意问题

改动Convert后，需要删除包重新编译生成实现类。在代码运行的时候总报找不到实现类–java.lang.ClassNotFoundException:Cannot find implementation for xxxx于是本能想到查看注解，发现注解[@Mapper]引用的jar包是对的（org.mapstruct），再一到target/generated-sources目录下查找实现类,发现没有.原来IDEA 没有自动编译生成我们接口的实现类。用IDEA 自带的maven编译（compile）一下,这时发现目录下已经可以正常生成实现类了。执行一下命令

mvn clean compile

生成impl文件就正常运行不报错了

更新依赖

右键项目-找到maven-reload project

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/289119
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号