MapStruct 之 mapstruct-processor

绝地灬酷狼 2023-10-10 17:24 37阅读 0赞

#### MapStruct 之 mapstruct-processor ####

*   *  mapstruct-processor
     *   *  添加依赖：
         *  定义源对象和目标对象：
         *  创建映射接口：
         *  使用映射器：
     *  基于当前IDEA设置并不需要mapstruct-processor的依赖, 可以不需要配置吗
     *   *  打开项目设置（\`File\` > \`Project Structure\`）。
     *  案例
     *   *  \`jar\`: 这一行定义了项目的打包类型。在这个例子中，它将以JAR文件的形式打包。

### mapstruct-processor ###

MapStruct是一个Java库，用于简化对象之间映射的过程。

mapstruct-processor是MapStruct的编译时注解处理器，它可以在编译时自动生成映射代码，从而减少手动编写代码的工作量和潜在的错误。

下面，我将分步介绍mapstruct-processor的使用

#### 添加依赖： ####

在使用mapstruct-processor之前，首先需要将相关的依赖添加到项目中。在Maven项目中，可以添加以下依赖：

<dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>1.5.0.Beta1</version>
    </dependency>
    <dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>1.5.0.Beta1</version>
    <scope>provided</scope>
    </dependency>

对于Gradle项目，可以添加以下依赖：

implementation 'org.mapstruct:mapstruct:1.5.0.Beta1'
    annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.0.Beta1'

#### 定义源对象和目标对象： ####

在使用MapStruct之前，需要定义源对象和目标对象。例如：

public class Source {
        
        private String name;
        private int age;
        // getters and setters
    }
    
    public class Target {
        
        private String name;
        private int age;
        // getters and setters
    }

#### 创建映射接口： ####

创建一个接口并使用`@Mapper`注解标记。在接口中，定义一个将源对象转换为目标对象的方法。例如：

import org.mapstruct.Mapper;
    import org.mapstruct.factory.Mappers;
    
    @Mapper
    public interface SourceToTargetMapper {
        
        SourceToTargetMapper INSTANCE = Mappers.getMapper(SourceToTargetMapper.class);
    
        Target sourceToTarget(Source source);
    }

#### 使用映射器： ####

现在可以在项目中使用映射器。MapStruct会自动生成实现类，无需手动实现。例如：

public class Main {
        
        public static void main(String[] args) {
        
            Source source = new Source();
            source.setName("John");
            source.setAge(30);
    
            Target target = SourceToTargetMapper.INSTANCE.sourceToTarget(source);
            System.out.println("Target name: " + target.getName());
            System.out.println("Target age: " + target.getAge());
        }
    }

此示例展示了如何使用MapStruct和mapstruct-processor将源对象映射到目标对象。MapStruct还提供了许多高级功能，如自定义映射、嵌套映射、更新策略等。具体可以查阅MapStruct官方文档以获取更多详细信息。

### 基于当前IDEA设置并不需要mapstruct-processor的依赖, 可以不需要配置吗 ###

确实，在某些情况下，IntelliJ  
IDEA可以在不添加mapstruct-processor依赖的情况下正常工作。但是，建议在项目中显式添加mapstruct-processor依赖，以确保在不同的IDE和构建工具之间保持一致性。这样可以避免在其他开发人员或CI环境中出现问题。

如果仍然想在不添加mapstruct-processor依赖的情况下使用IntelliJ IDEA，请确保按照以下步骤操作：

#### 打开项目设置（`File` > `Project Structure`）。 ####

1.  转到`Modules`选项卡。
2.  选择需要使用MapStruct的模块。
3.  转到`Dependencies`选项卡。
4.  点击"+“图标，然后选择"Library”。
5.  在搜索框中输入"mapstruct"，然后选择mapstruct-processor的最新版本，点击"Add Selected"。

这样，IntelliJ IDEA会自动为您的项目添加mapstruct-processor依赖。但请注意，这种设置方式可能无法在其他IDE和构建工具中正常工作。因此，强烈建议将依赖添加到项目的构建配置中，以确保一致性。

### 案例 ###

<packaging>jar</packaging>
    <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <org.mapstruct.version>1.4.0.Beta3</org.mapstruct.version>
    <org.projectlombok.version>1.18.12</org.projectlombok.version>
    </properties>
    <dependencies>
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>${org.mapstruct.version}</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${org.projectlombok.version}</version>
        <scope>provided</scope>
    </dependency>
    
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.71</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    </dependencies>
    
    <build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    
                    
                    
                    
                    
                    
                    
                    <annotationProcessorPaths>
                        <path>
                            <groupId>org.mapstruct</groupId>
                            <artifactId>mapstruct-processor</artifactId>
                            <version>${org.mapstruct.version}</version>
                        </path>
                        <path>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                            <version>${org.projectlombok.version}</version>
                        </path>
                    </annotationProcessorPaths>
                </configuration>
            </plugin>
        </plugins>
    </pluginManagement>
    </build>

这个pom.xml文件是一个Maven项目的配置文件。它定义了项目的基本信息、依赖关系和构建过程。现在，我将详细解释每个部分的作用。

#### `<packaging>jar</packaging>`: 这一行定义了项目的打包类型。在这个例子中，它将以JAR文件的形式打包。 ####

1.  `<properties>`: 这个部分定义了一些属性，用于在整个pom.xml文件中引用。这些属性包括：

*  `<project.build.sourceEncoding>`: 设置项目源代码的编码为UTF-8。
 *  `<maven.compiler.source>` 和 `<maven.compiler.target>`: 设置Java编译器的源代码和目标代码版本为1.8。
 *  `<org.mapstruct.version>` 和 `<org.projectlombok.version>`: 定义MapStruct和Lombok库的版本。

1.  `<dependencies>`: 这个部分定义了项目所需的依赖关系。在这个例子中，有以下依赖：

*  MapStruct: 用于简化Java对象之间的映射。
 *  Lombok: 用于自动生成Java类的getter、setter、equals、hashCode等方法，减少手动编写这些方法的工作量。
 *  Fastjson: 一个高性能的JSON库，用于解析和生成JSON数据。
 *  JUnit: 一个广泛使用的Java单元测试框架。

请注意，Lombok依赖的作用域被设置为`provided`，这意味着这个依赖只在编译和测试阶段可用，而不会包含在生成的JAR文件中。

1.  `<build>`: 这个部分定义了项目的构建配置。在这个例子中，它包含一个`<pluginManagement>`  
    元素，用于配置Maven插件。唯一配置的插件是maven-compiler-plugin，它用于编译Java源代码。该插件的配置包括：

*  `<source>` 和 `<target>`: 设置Java编译器的源代码和目标代码版本为1.8（与前面的`<properties>`部分中的设置一致）。
 *  `<annotationProcessorPaths>`: 配置注解处理器的类路径。在这个例子中，添加了MapStruct和Lombok的注解处理器。这样，Maven编译器插件将在编译时执行这些注解处理器，自动生成相应的代码。

通过这个pom.xml文件，项目将包含MapStruct、Lombok、Fastjson和JUnit库，并在编译时使用MapStruct和Lombok的注解处理器。这样，开发人员可以利用这些库简化代码编写和测试工作。

<path>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct-processor</artifactId>
        <version>${org.mapstruct.version}</version>
    </path>

> 使用 MapStruct的时候 这一段是必要的吗?不配置行不行呀

在大多数情况下，为了让MapStruct在编译时正确生成映射实现，您需要在`<annotationProcessorPaths>`  
中配置mapstruct-processor。这样，Maven编译器插件会在编译时执行MapStruct的注解处理器，从而自动生成映射实现代码。

如果不配置这一部分，编译过程中可能不会执行MapStruct的注解处理器，导致映射实现代码无法正确生成。然而，在某些情况下，特定的IDE可能能够在没有显式配置的情况下自动识别和执行MapStruct的注解处理器。但这种情况下，项目在不同的开发环境和构建系统之间可能会产生不一致的行为。

总之，为了确保项目在各种环境中的一致性和可靠性，建议配置mapstruct-processor。这样可以确保无论在哪个开发环境或构建系统中，MapStruct的注解处理器都能被正确执行。