MapStruct使用(二)

合集 - 简洁之道(13)

1.Lombok使用(一)2022-10-022.Lombok使用(二)2022-10-023.MapStruct使用(一)2022-10-02

4.MapStruct使用(二)2022-10-03

5.commons-lang3使用2022-10-036.commons-collections4使用2022-10-037.commons-io使用2022-10-038.guava使用2022-10-039.spring中工具类2022-10-0310.beanvalidation简介2022-10-0511.分组校验、级联校验、自定义验证规则2022-10-0712.快速失败、非bean入参校验2022-10-0713.整合springboot2022-10-07

收起

• 批量转换

# 编写convert
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public abstract class CarConvert {
 
    public static CarConvert INSTANCE = Mappers.getMapper(CarConvert.class);
 
    public abstract List<CarVO> dtos2vos(List<CarDTO> carDTO);
 
}
 
# 测试
    /**
     * 测试mapstruct批量转换
     * List<CarDto>--> List<CarVo>
     */
    @Test
    public void test3() {
        CarDTO carDTO = buildCarDTO();
        List<CarDTO> carDTOList = new ArrayList<>();
        carDTOList.add(carDTO); // source
        // target
        List<CarVO> carVOList = CarConvert.INSTANCE.dtos2vos(carDTOList);
        System.out.println(carVOList);
    }

• @BeanMapping

• 如果有多个属性需要忽略的时候，需要些很多行
  

# 编写convert
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public abstract class CarConvert {
 
    public static CarConvert INSTANCE = Mappers.getMapper(CarConvert.class);
 
    /**
     * 配置忽略mapstruct的默认映射行为，只映射那些配置了@Mapping的属性
     * @param carDTO
     */
    @BeanMapping(ignoreByDefault = true)
    @Mapping(source = "id",target = "id")
    public abstract VehicleVO carDTO2vehicleVO(CarDTO carDTO);
}
 
# 测试
    @Test
    public void test4() {
        CarDTO carDTO = buildCarDTO();
        VehicleVO vehicleVO = CarConvert.INSTANCE.carDTO2vehicleVO(carDTO);
        System.out.println(vehicleVO);
    }

• 映射继承

# 编写convert
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public abstract class CarConvert {
 
    public static CarConvert INSTANCE = Mappers.getMapper(CarConvert.class);
 
    /**
     * 配置忽略mapstruct的默认映射行为，只映射那些配置了@Mapping的属性
     * @param carDTO
     */
    @BeanMapping(ignoreByDefault = true)
    @Mapping(source = "id",target = "id")
    @Mapping(source = "brand",target = "brandName")
    public abstract VehicleVO carDTO2vehicleVO(CarDTO carDTO);
 
    /**
     * 会继承全部配置，包括@BeanMapping和@Mapping
     * @param carDTO
     * @param vehicleVO
     */
    @InheritConfiguration(name = "carDTO2vehicleVO")
    public abstract void updateVehicleVO(CarDTO carDTO,@MappingTarget VehicleVO vehicleVO);
}
 
# 测试
    @Test
    public void test5() {
        CarDTO carDTO = buildCarDTO();
        VehicleVO vehicleVO = CarConvert.INSTANCE.carDTO2vehicleVO(carDTO);
 
        CarDTO carDTO2 = new CarDTO();
        carDTO2.setId(330L);
        carDTO2.setPrice(789d);
        carDTO2.setBrand("迈巴赫");
        // 通过carDTO2的属性值来更新已存在的vehicleVO对象
        CarConvert.INSTANCE.updateVehicleVO(carDTO2,vehicleVO);
        System.out.println(vehicleVO);
    }

• 反向继承

# 编写convert
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper
public abstract class CarConvert {
 
    public static CarConvert INSTANCE = Mappers.getMapper(CarConvert.class);
 
    /**
     * 配置忽略mapstruct的默认映射行为，只映射那些配置了@Mapping的属性
     * @param carDTO
     */
    @BeanMapping(ignoreByDefault = true)
    @Mapping(source = "id",target = "id")
    @Mapping(source = "brand",target = "brandName")
    public abstract VehicleVO carDTO2vehicleVO(CarDTO carDTO);
 
    /**
     * 测试@InheritInverseConfiguration反向继承，只会继承@Mapping
     * 故需要再单独写一次 @BeanMapping
     * name:指定使用哪一个方法的配置,写方法的名字
     * @param vehicleVO
     */
    @BeanMapping(ignoreByDefault = true)
    @InheritInverseConfiguration(name = "carDTO2vehicleVO")
    public abstract CarDTO vehicleVO2CarDTO(VehicleVO vehicleVO);
}
 
# 测试
    @Test
    public void test6() {
       VehicleVO vehicleVO = new VehicleVO();
       vehicleVO.setId(9999L);
       vehicleVO.setBrandName("别克");
       vehicleVO.setPrice(66554322d);
        CarDTO carDTO = CarConvert.INSTANCE.vehicleVO2CarDTO(vehicleVO);
        System.out.println(carDTO);
    }

• 结合spring使用

# 编写convert
import org.mapstruct.factory.Mappers;
import java.util.List;
@Mapper(componentModel = "spring")                                                              <-----
public abstract class CarConvert {
 
    public static CarConvert INSTANCE = Mappers.getMapper(CarConvert.class);
 
    /**
     * 配置忽略mapstruct的默认映射行为，只映射那些配置了@Mapping的属性
     * @param carDTO
     */
    @BeanMapping(ignoreByDefault = true)
    @Mapping(source = "id",target = "id")
    @Mapping(source = "brand",target = "brandName")
    public abstract VehicleVO carDTO2vehicleVO(CarDTO carDTO);
 
    /**
     * 测试@InheritInverseConfiguration反向继承，只会继承@Mapping
     * 故需要再单独写一次 @BeanMapping
     * name:指定使用哪一个方法的配置,写方法的名字
     * @param vehicleVO
     */
    @BeanMapping(ignoreByDefault = true)
    @InheritInverseConfiguration(name = "carDTO2vehicleVO")
    public abstract CarDTO vehicleVO2CarDTO(VehicleVO vehicleVO);
}
 
# 测试
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MapStructApplication.class)
public class MapStructTest {
 
//    @Autowired
    @Resource
    private CarConvert carConvert;
 
    /**
     * 测试mapstruct和spring整合
     */
    @Test
    public void test7() {
        VehicleVO vehicleVO = new VehicleVO();
        vehicleVO.setId(9999L);
        vehicleVO.setBrandName("别克");
        vehicleVO.setPrice(66554322d);
        CarDTO carDTO = carConvert.vehicleVO2CarDTO(vehicleVO);
        System.out.println(carDTO);
    }
 
}