Springboot提升-MapStruct组件使用

概览

MapStruct 是一个代码生成器，它基于 Java 注解来处理 Java Bean 之间的映射。通过生成类型安全的映射代码，它显著简化了 Java 对象之间的转换工作。在 Maven 项目中引入 MapStruct 并使用它非常简单，以下是一个详细的步骤指南。

1. 在 Maven 项目中引入 MapStruct 依赖

首先，你需要在 pom.xml 文件中添加 MapStruct 的依赖。MapStruct 分为两部分：API 和处理器。API 是你在代码中使用的部分，而处理器是在编译时生成映射代码的部分。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>mapstruct-example</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>11</java.version>
        <org.mapstruct.version>1.5.2.Final</org.mapstruct.version>
    </properties>

    <dependencies>
        <!-- MapStruct API -->
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
            <version>${org.mapstruct.version}</version>
        </dependency>
        <!-- 添加其他依赖 -->
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <annotationProcessorPaths>
                    	<!-- 使用lombok生成get,set方法时需要添加这个 -->
                    	<path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${lombok.version}</version>
                        </path>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${org.mapstruct.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2. 创建源对象和目标对象

接下来，创建你希望进行映射的源对象和目标对象。例如：

// 源对象
public class Source {
    private String name;
    private int age;

    // Getters and Setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

// 目标对象
public class Target {
    private String fullName;
    private int years;

    // Getters and Setters
    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    public int getYears() {
        return years;
    }

    public void setYears(int years) {
        this.years = years;
    }
}

3. 创建 Mapper 接口

然后，创建一个 Mapper 接口，并使用 MapStruct 提供的注解来定义映射规则。

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;

@Mapper
public interface MyMapper {
    MyMapper INSTANCE = Mappers.getMapper(MyMapper.class);

    @Mapping(source = "name", target = "fullName")
    @Mapping(source = "age", target = "years")
    Target sourceToTarget(Source source);
}

4. 使用 Mapper 进行映射

最后，在你的代码中使用 Mapper 接口来进行对象映射。

public class Main {
    public static void main(String[] args) {
        Source source = new Source();
        source.setName("John Doe");
        source.setAge(30);

        Target target = MyMapper.INSTANCE.sourceToTarget(source);

        System.out.println("Full Name: " + target.getFullName());
        System.out.println("Years: " + target.getYears());
    }
}

5. 编译和运行

确保你的项目结构正确，并且 pom.xml 配置无误。然后，使用 Maven 编译并运行你的项目：

mvn clean compile exec:java -Dexec.mainClass="com.example.Main"

如果一切正常，你应该会看到控制台输出：

Full Name: John Doe
Years: 30

这就是在 Maven 项目中引入并使用 MapStruct 的完整步骤。通过这种方式，你可以轻松地在 Java 项目中实现对象之间的类型安全映射。

相关注解以及使用

MapStruct是一个Java注解处理器，它基于“约定优于配置”的原则，使用Java注解来简化从源对象到目标对象的映射过程。以下是MapStruct的一些常用注解及其使用范例：

1. @Mapper

• 作用：标记一个接口为MapStruct的映射器接口。
• 范例：

@Mapper
public interface CarMapper {
    CarMapper INSTANCE = Mappers.getMapper(CarMapper.class);

    @Mapping(target = "manufacturer", source = "make")
    @Mapping(target = "seatCount", source = "numberOfSeats")
    CarDto carToCarDto(Car car);
}

2. @Mapping

• 作用：为单个属性配置映射关系。
• 范例：

@Mapper
public interface PersonMapper {
    @Mapping(source = "name", target = "fullName")
    PersonDto personToPersonDto(Person person);
}

在上面的例子中，@Mapping注解指定了源对象Person的name属性映射到目标对象PersonDto的fullName属性。

3. @Mappings

• 作用：当需要配置多个属性映射关系时，可以使用@Mappings注解来包含多个@Mapping注解。
• 范例：

@Mapper
public interface MyMapper {
    @Mappings({
        @Mapping(target = "name", source = "fullName"),
        @Mapping(target = "age", source = "years")
    })
    void updateTargetFromSource(Source source, Target target);
}

4. @BeanMapping

• 作用：为bean映射提供额外的配置，如忽略默认映射、指定映射控制策略等。
• 范例：

@Mapper
public interface CarMapper {
    @BeanMapping(resultType = CarDto.class, ignoreByDefault = true, mappingControl = MappingControl.FILTER)
    @Mapping(target = "color", ignore = true)
    @Mapping(source = "model", target = "modelName")
    CarDto map(Car car);
}

在上面的例子中，@BeanMapping注解指定了映射方法的返回类型为CarDto，并设置了忽略默认映射和映射控制策略为FILTER。然后，通过@Mapping注解对特定属性进行了额外的配置。

5. expression

• 作用：允许使用Java表达式来定义字段映射。这在源和目标字段之间需要一些特定逻辑时非常有用。
• 范例：

@Mapper
public interface OrderMapper {
    @Mapping(target = "status", expression = "java(order.isShipped() ? \"SHIPPED\" : \"PENDING\")")
    OrderDto orderToOrderDto(Order order);
}

在上面的例子中，expression属性使用了Java表达式来根据order.isShipped()的返回值设置OrderDto的status属性。

6. defaultValue

• 作用：为字段映射指定默认值。
• 范例：

@Mapper
public interface MyMapper {
    @Mapping(target = "address", defaultValue = "Unknown")
    MyDTO sourceToDTO(MySource source);
}

在上面的例子中，当源对象MySource中没有与address字段对应的属性时，目标对象MyDTO的address字段将被设置为默认值"Unknown"。

7. qualifiedByName

• 作用：当默认的get/set方法无法满足需求时，可以使用qualifiedByName指定一个自定义的映射方法。
• 范例（略，因为需要额外的自定义映射方法定义，但可以通过文档或示例代码了解）。

8. componentModel

• 作用：指定映射器的组件模型，如Spring管理的bean。
• 范例：

@Mapper(componentModel = "spring")
public interface MyMapper {
    // 映射方法定义
}

在上面的例子中，componentModel = "spring"指定了映射器将作为一个Spring管理的bean进行注册。

这些注解和范例展示了MapStruct在简化Java对象映射方面的强大功能。通过合理使用这些注解，开发者可以大大提高代码的可读性和可维护性，并减少手动编写繁琐的转换代码的工作量。