MapStruct 常用操作

刺骨的言语ヽ痛彻心扉 2022-09-09 04:52 142阅读 0赞

### 文章目录 ###

*   *   *   *   *  一、快速入门
                 *   *  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>
                            
                            <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>
                            
                            <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
        public void test() { 
            Product product = new Product(1,"电脑", new BigDecimal(6000),1);
            ProductVO productVO = ProductMapper.mapper.pojo2vo(product);
            System.out.println(productVO);
        }

##### 三、集合属性赋值 #####

###### 3.1. mapper定义 ######

###### 3.2. 测试 ######

@Test
        public void 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. 测试 ######