MapStruct 常用操作

文章目录

• ​​一、快速入门​​

• ​​1. 简介​​
• ​​2. 引入依赖​​

• ​​二、entity赋值vo​​

• ​​2.1. Product​​
• ​​2.2. ProductVO​​
• ​​2.3. mapper定义​​
• ​​2.4. 测试验证​​

• ​​三、集合属性赋值​​

• ​​3.1. mapper定义​​
• ​​3.2. 测试​​

• ​​四、2个对象整合属性赋值​​

• ​​4.1. mapper定义​​
• ​​4.2. 测试​​

• ​​五、自定义类型转换​​

• ​​5.1. mapper定义​​
• ​​5.2. 测试​​

一、快速入门

1. 简介

MapStruct是满足JSR269规范的一个Java注解处理器，用于为Java Bean生成类型安全且高性能的映射。它基于编译阶段生成get/set代码，此实现过程中没有反射，不会造成额外的性能损失。

您所要做的就是定义一个mapper接口（@Mapper），该接口用于声明所有必须的映射方法。在编译期间MapStruct会为该接口自动生成实现类。该实现类使用简单的Java方法调用来映射source-target对象，在此过程中没有反射或类似的行为发生。

2. 引入依赖

<properties>
        <java.version>1.8</java.version>
        <mapstruct.version>1.4.1.Final</mapstruct.version>
    </properties>
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>${mapstruct.version}</version>
        </dependency>
         <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>


 
 <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                    <encoding>UTF-8</encoding>
                    <annotationProcessorPaths>
                        <!-- 必须要加, 否则生成不了 MapperImpl 实现类 -->
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${mapstruct.version}</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>1.18.20</version>
                        </path>
                        <!-- 如果是 0.1.0 有可能出现生成了maptruct的实现类, 但该类只创建了对象, 没有进行赋值 -->
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok-mapstruct-binding</artifactId>
                            <version>0.2.0</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </build>

二、entity赋值vo

2.1. Product

@Data
@AllArgsConstructor
public class Product {
    private Integer productId;
    private String productName;
    private BigDecimal productPrice;
    private Integer productStatus;
}

2.2. ProductVO

@Data
public class ProductVO {
    private Integer id;
    private String name;
    private BigDecimal price;
    private Boolean status;
}

2.3. mapper定义

@Mapper
public interface ProductMapper {

    /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    ProductMapper mapper = Mappers.getMapper(ProductMapper.class);

  /**
     * 这个方法就是用于实现对象属性复制的方法
     *
     * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
     *
     * @param user 这个参数就是源对象，也就是需要被复制的对象
     * @return 返回的是目标对象，就是最终的结果对象
     */
    @Mappings({
            @Mapping(source = "productId",target = "id"),
            @Mapping(source = "productName",target = "name"),
            @Mapping(source = "productPrice",target = "price")
    })
  ProductVO pojo2vo(Product product);
    }

2.4. 测试验证

属性不一致赋值

test() {
        Product product = new Product(1,"电脑", new BigDecimal(6000),1);
        ProductVO productVO = ProductMapper.mapper.pojo2vo(product);
        System.out.println(productVO);
    }

三、集合属性赋值

3.1. mapper定义

@Mapper
public interface ProductMapper {
   /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    ProductMapper mapper = Mappers.getMapper(ProductMapper.class);

   /**
     * 这个方法就是用于实现对象属性复制的方法
     *
     * @param product 这个参数就是源对象，也就是需要被复制的对象
     * @return 返回的是目标对象，就是最终的结果对象
     * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
     */
    @Mappings({
            @Mapping(source = "productId",target = "id"),
            @Mapping(source = "productName",target = "name"),
            @Mapping(source = "productPrice",target = "price")
    })
  ProductVO pojo2vo(Product product);
   List<ProductVO> list2vo(List<Product> list);
  }

3.2. 测试

list(){
        List<Product> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add(new Product(i,"电脑"+i,new BigDecimal(6000),1));
        }
        List<ProductVO> productVOS = ProductMapper.mapper.list2vo(list);
        for (ProductVO productVO : productVOS) {
            System.out.println(productVO);
        }
    }

四、2个对象整合属性赋值

4.1. mapper定义

@Mapper
public interface ProductMapper {
   /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    ProductMapper mapper = Mappers.getMapper(ProductMapper.class);

   /**
     * 这个方法就是用于实现对象属性复制的方法
     *
     * @param product 这个参数就是源对象，也就是需要被复制的对象
     * @return 返回的是目标对象，就是最终的结果对象
     * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
     */
    @Mappings({
            @Mapping(source = "productId",target = "id"),
            @Mapping(source = "productName",target = "name"),
            @Mapping(source = "productPrice",target = "price"),
    })
   ProductVO pojo2vo(Product product);

    List<ProductVO> list2vo(List<Product> list);
  
   /**
     * 多个参数中的值绑定
     *
     * @param product 源1
     * @param category 源2
     * @return 从源1、2中提取出的结果
     */
    @Mappings({
            @Mapping(source = "product.productName", target = "product"), //把product中的productName绑定到目标对象的product属性中
            @Mapping(source = "category.categoryName", target = "category")//把category中的categoryName绑定到目标对象的category属性中
    })
   OrderVO createOrder(Product product, Category category);
}

4.2. 测试

@Test
    public void order(){
        Product product = new Product(1, "电脑", new BigDecimal(6000),1);
        Category category = new Category("电子产品");
        OrderVO order = ProductMapper.mapper.createOrder(product, category);
        System.out.println(order);
    }

五、自定义类型转换

例如：查询数据库某个段值为0或者1，但是需求中，如果是1就返回true 0返回 false
例如：查询数据库某个段值为0或者1，但是页面显示男或者女

5.1. mapper定义

@Mapper
public interface ProductMapper {
   /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    ProductMapper mapper = Mappers.getMapper(ProductMapper.class);
 
   /**
     * 这个方法就是用于实现对象属性复制的方法
     *
     * @param product 这个参数就是源对象，也就是需要被复制的对象
     * @return 返回的是目标对象，就是最终的结果对象
     * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
     */
    @Mappings({
            @Mapping(source = "productId",target = "id"),
            @Mapping(source = "productName",target = "name"),
            @Mapping(source = "productPrice",target = "price"),
            @Mapping(source = "productStatus",target = "status",qualifiedByName = "convertStatus")
    })
         ProductVO pojo2vo(Product product);

   /**
     * 提供默认方法，方法自己定义，这个方法是我根据实际业务写的
     * @return
     */
    @Named("convertStatus")
    default Boolean convertStatus(Integer status){
        if(status == 1) {
            return true;
        }
        return false;
    }

    public abstract List<ProductVO> list2vo(List<Product> list);
  
   /**
     * 多个参数中的值绑定
     *
     * @param product 源1
     * @param category 源2
     * @return 从源1、2中提取出的结果
     */
    @Mappings({
            @Mapping(source = "product.productName", target = "product"), //把product中的productName绑定到目标对象的product属性中
            @Mapping(source = "category.categoryName", target = "category")//把category中的categoryName绑定到目标对象的category属性中
    })
   OrderVO createOrder(Product product, Category category);
}

5.2. 测试

@Test
    public void test() {
        Product product = new Product(1,"电脑", new BigDecimal(6000),1);
        ProductVO productVO = ProductMapper.mapper.pojo2vo(product);
        System.out.println(productVO);
    }