admin/mapstruct-plus
1
0
Fork 0
mirror of https://gitee.com/easii/mapstruct-plus.git synced 2025-12-06 17:18:43 +08:00
Code Issues Packages Projects Releases Wiki Activity

release 1.3.0

Browse Source 
- 解决本地开发时 IDEA 编译或者运行时报错等与预期不一致的问题
This commit is contained in:
linpeilie 2023-06-16 17:55:13 +08:00
parent f640df71eb
commit 95e87c3a3a
6 changed files with 150 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
docs/README.md
View File

@ -56,23 +56,21 @@ copyright: false
<dependency>
<groupId>io.github.linpeilie</groupId>
<artifactId>mapstruct-plus-spring-boot-starter</artifactId>
<version>1.2.5</version>
<version>1.3.0</version>
</dependency>
```
- gradle
```groovy
implementation group: 'io.github.linpeilie', name: 'mapstruct-plus-spring-boot-starter', version: '1.2.5'
implementation group: 'io.github.linpeilie', name: 'mapstruct-plus-spring-boot-starter', version: '1.3.0'
```
## 更新日志
### 1.2.5
### 1.3.0
- fix: 解决 MapConvertMapperAdapter 编译警告问题
- feat: 增加 `nullValueMappingStrategy` 和 `nullValuePropertyMappingStrategy` 配置项
- feat: 适配 solon
- fix: 解决本地开发时 IDEA 编译或者运行时报错等与预期不一致的问题
……

64
docs/guide/configuration.md
View File

@ -23,6 +23,57 @@ public class MapStructPlusConfiguration {
}
```
-------------------------------------------------------------------
除此之外，配置属性还支持**增加编译参数**的方式，以 `-Akey=value` 的形式，传递给编译器。
例如，使用 Maven 时，可以在 `maven-compiler-plugin` 插件配置中，使用 `compilerArgs` 属性来配置传递，例如：
**且使用该方式配置优先级更高**，即，当该方式和配置类同时存在时，以该方式配置的属性为准。该功能从 `1.3.0` 开始支持。
:::warning
**建议使用该方式来配置，因为本地开发时，修改类时，IDEA 会只对修改的类进行部分编译，无法获取到配置类，所以可能会出现与预想编译结果不同的问题，但执行 mvn clean package 又变为正常**。
:::
```xml
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>${maven.compiler.source}</source>
<target>${maven.compiler.target}</target>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</version>
</path>
<path>
<groupId>io.github.linpeilie</groupId>
<artifactId>mapstruct-plus-processor</artifactId>
<version>${mapstruct-plus.version}</version>
</path>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok-mapstruct-binding</artifactId>
<version>0.2.0</version>
</path>
</annotationProcessorPaths>
<compilerArgs>
<arg>-Amapstruct.plus.mapperPackage=com.tutelary.mapper</arg>
<arg>-Amapstruct.plus.adapterClassName=DemoConvertMapperAdapter1</arg>
<arg>-Amapstruct.plus.adapterPackage=io.github.linpeilie.adapter</arg>
<arg>-Amapstruct.plus.mapAdapterClassName=DemoMapConvertMapperAdapter</arg>
</compilerArgs>
</configuration>
</plugin>
</plugins>
</build>
```
## 配置项
### mapperPackage
@ -30,6 +81,7 @@ public class MapStructPlusConfiguration {
- **说明**：生成的 Mapper 转换接口的包名
- **类型**：`String`
- **默认值**：默认生成在要转换的类同包名下
- **对应编译参数**：`-Amapstruct.plus.mapperPackage`
### unmappedSourcePolicy
@ -40,6 +92,7 @@ public class MapStructPlusConfiguration {
- `WARN`：打印警告日志
- `ERROR`：抛出异常
- **默认值**：`IGNORE`
- **对应编译参数**：`mapstruct.plus.unmappedSourcePolicy`
### unmappedTargetPolicy
@ -50,6 +103,7 @@ public class MapStructPlusConfiguration {
- `WARN`：打印警告日志
- `ERROR`：抛出异常
- **默认值**：`IGNORE`
- **对应编译参数**：`mapstruct.plus.unmappedTargetPolicy`
### nullValueMappingStrategy
@ -59,6 +113,7 @@ public class MapStructPlusConfiguration {
- `RETURN_NULL`：返回空值
- `RETURN_DEFAULT`：返回默认值
- **默认值**：`RETURN_NULL`
- **对应编译参数**：`mapstruct.plus.nullValueMappingStrategy`
### nullValuePropertyMappingStrategy
@ -69,6 +124,7 @@ public class MapStructPlusConfiguration {
- `SET_TO_DEFAULT`：设置为默认值
- `IGNORE`：忽略
- **默认值**：`SET_TO_NULL`
- **对应编译参数**：`mapstruct.plus.nullValuePropertyMappingStrategy`
### builder
@ -80,6 +136,9 @@ public class MapStructPlusConfiguration {
- **默认值**：
- `buildMethod`：`build`
- `disableBuilder`：`true`
- **分别对应的编译参数**：
- `mapstruct.plus.builder.buildMethod`
- `mapstruct.plus.builder.disableBuilder`
### adapterPackage
@ -88,6 +147,7 @@ public class MapStructPlusConfiguration {
- **说明**：ConvertAdapterClass 和 MapConvertMapperAdapter 的包名
- **类型**：`String`
- **默认值**：io.github.linpeilie
- **对应编译参数**：`mapstruct.plus.adapterPackage`
### adapterClassName
@ -96,6 +156,7 @@ public class MapStructPlusConfiguration {
- **说明**：ConvertAdapterClass 类名
- **类型**：`String`
- **默认值**：ConvertMapperAdapter
- **对应编译参数**：`mapstruct.plus.adapterClassName`
### mapAdapterClassName
@ -103,4 +164,5 @@ public class MapStructPlusConfiguration {
- **说明**：MapConvertMapperAdapter 类名
- **类型**：`String`
- **默认值**：MapConvertMapperAdapter
- **默认值**：MapConvertMapperAdapter
- **对应编译参数**：`mapstruct.plus.mapAdapterClassName`

6
docs/guide/faq.md
View File

@ -135,4 +135,8 @@ dependencies {
annotationProcessor group: 'io.github.linpeilie', name: 'mapstruct-plus-processor', version: ${mapstruct-plus.version}
annotationProcessor group: 'org.projectlombok', name: 'lombok-mapstruct-binding', version: '0.2.0'
}
```
```
## 本地开发时，修改类后启动报错，mvn clean compile 后又恢复正常
该问题是由于 IDEA 部分编译导致没有找到配置类导致的，建议先更新 1.3.0，更换配置方式，详情可以查看[指南 - 配置](/guide/configuration.html)

4
docs/release/log.md
View File

@ -6,6 +6,10 @@ category:
description: MapStructPlus release log
---
### 1.3.0
- fix: 解决本地开发时 IDEA 编译或者运行时报错等与预期不一致的问题
### 1.2.5
- fix: 解决 MapConvertMapperAdapter 编译警告问题

70
mapstruct-plus-processor/src/main/java/io/github/linpeilie/processor/AutoMapperProcessor.java
View File

@ -66,30 +66,27 @@ import static io.github.linpeilie.processor.Constants.COMPONENT_MODEL_CONFIG_ANN
import static io.github.linpeilie.processor.Constants.MAPPER_ANNOTATION;
import static io.github.linpeilie.processor.Constants.MAPPER_CONFIG_ANNOTATION;
import static javax.tools.Diagnostic.Kind.ERROR;
import static io.github.linpeilie.processor.ProcessorOptions.*;
@SupportedAnnotationTypes({AUTO_MAPPER_ANNOTATION, AUTO_MAPPERS_ANNOTATION, AUTO_MAP_MAPPER_ANNOTATION,
AUTO_ENUM_MAPPER_ANNOTATION, MAPPER_CONFIG_ANNOTATION, COMPONENT_MODEL_CONFIG_ANNOTATION,
MAPPER_ANNOTATION})
@SupportedOptions({
AutoMapperProcessor.MAPPER_PACKAGE,
AutoMapperProcessor.ADAPTER_PACKAGE,
AutoMapperProcessor.ADAPTER_CLASS_NAME,
AutoMapperProcessor.MAP_ADAPTER_CLASS_NAME,
MAPPER_PACKAGE,
UNMAPPED_SOURCE_POLICY,
UNMAPPED_TARGET_POLICY,
NULL_VALUE_MAPPING_STRATEGY,
NULL_VALUE_PROPERTY_MAPPING_STRATEGY,
BUILDER_BUILD_METHOD,
BUILDER_DISABLE_BUILDER,
ADAPTER_PACKAGE,
ADAPTER_CLASS_NAME,
MAP_ADAPTER_CLASS_NAME,
})
public class AutoMapperProcessor extends AbstractProcessor {
private static final ClassName MAPPING_DEFAULT_TARGET = ClassName.get("io.github.linpeilie", "DefaultMapping");
protected static final String DEFAULT_COMPONENT_MODEL = "mapstruct.defaultComponentModel";
protected static final String MAPPER_PACKAGE = "mapstruct.plus.mapperPackage";
protected static final String ADAPTER_PACKAGE = "mapstruct.plus.adapterPackage";
protected static final String ADAPTER_CLASS_NAME = "mapstruct.plus.adapterClassName";
protected static final String MAP_ADAPTER_CLASS_NAME = "mapstruct.plus.mapAdapterClassName";
private final AutoMapperGenerator mapperGenerator;
private AbstractAdapterMapperGenerator adapterMapperGenerator;
@ -356,30 +353,12 @@ public class AutoMapperProcessor extends AbstractProcessor {
}
private void loadCompilerArgs() {
String componentModel = processingEnv.getOptions().get(DEFAULT_COMPONENT_MODEL);
if (StrUtil.isNotEmpty(componentModel)) {
AutoMapperProperties.setComponentModel(componentModel);
}
final String mapperPackage = processingEnv.getOptions().get(MAPPER_PACKAGE);
if (StrUtil.isNotEmpty(mapperPackage)) {
AutoMapperProperties.setMapperPackage(mapperPackage);
}
final String adapterPackage = processingEnv.getOptions().get(ADAPTER_PACKAGE);
if (StrUtil.isNotEmpty(adapterPackage)) {
AutoMapperProperties.setAdapterPackage(adapterPackage);
}
final String adapterClassName = processingEnv.getOptions().get(ADAPTER_CLASS_NAME);
if (StrUtil.isNotEmpty(adapterClassName)) {
AutoMapperProperties.setAdapterClassName(adapterClassName);
}
final String mapAdapterClassName = processingEnv.getOptions().get(MAP_ADAPTER_CLASS_NAME);
if (StrUtil.isNotEmpty(mapAdapterClassName)) {
AutoMapperProperties.setMapAdapterClassName(mapAdapterClassName);
}
}
private String getPackageName(Element element) {
return String.valueOf(processingEnv.getElementUtils().getPackageOf(element).getQualifiedName());
ProcessorOptions.optionConsumers().forEach((key, consumer) -> {
final String value = processingEnv.getOptions().get(key);
if (StrUtil.isNotEmpty(value)) {
consumer.accept(value);
}
});
}
private void processAutoMapperAnnotation(final RoundEnvironment roundEnv, final TypeElement annotation) {
@ -522,21 +501,6 @@ public class AutoMapperProcessor extends AbstractProcessor {
return buildAutoMapperMetadata(autoMapperAnnotation, ele);
}
private boolean hasReverseAutoMapping(Element ele) {
TypeElement typeElement = (TypeElement) ele;
if (!typeElement.getKind().isClass()) {
return false;
}
return typeElement.getEnclosedElements()
.stream().anyMatch(e -> {
if (e.getKind() != ElementKind.FIELD) {
return false;
}
return e.getAnnotation(ReverseAutoMapping.class) != null
|| e.getAnnotation(ReverseAutoMappings.class) != null;
});
}
private boolean isTargetFieldMapping(ClassName target, AutoMappingMetadata mappingMetadata) {
if (MAPPING_DEFAULT_TARGET.reflectionName().contentEquals(mappingMetadata.getTargetClass().reflectionName())) {
return true;

57
mapstruct-plus-processor/src/main/java/io/github/linpeilie/processor/ProcessorOptions.java Normal file
View File

@ -0,0 +1,57 @@
package io.github.linpeilie.processor;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
import org.mapstruct.NullValueMappingStrategy;
import org.mapstruct.NullValuePropertyMappingStrategy;
import org.mapstruct.ReportingPolicy;
public class ProcessorOptions {
public static final String DEFAULT_COMPONENT_MODEL = "mapstruct.defaultComponentModel";
public static final String MAPPER_PACKAGE = "mapstruct.plus.mapperPackage";
public static final String UNMAPPED_SOURCE_POLICY = "mapstruct.plus.unmappedSourcePolicy";
public static final String UNMAPPED_TARGET_POLICY = "mapstruct.plus.unmappedTargetPolicy";
public static final String NULL_VALUE_MAPPING_STRATEGY = "mapstruct.plus.nullValueMappingStrategy";
public static final String NULL_VALUE_PROPERTY_MAPPING_STRATEGY = "mapstruct.plus.nullValuePropertyMappingStrategy";
public static final String BUILDER_BUILD_METHOD = "mapstruct.plus.builder.buildMethod";
public static final String BUILDER_DISABLE_BUILDER = "mapstruct.plus.builder.disableBuilder";
public static final String ADAPTER_PACKAGE = "mapstruct.plus.adapterPackage";
public static final String ADAPTER_CLASS_NAME = "mapstruct.plus.adapterClassName";
public static final String MAP_ADAPTER_CLASS_NAME = "mapstruct.plus.mapAdapterClassName";
public static Map<String, Consumer<String>> optionConsumers() {
final Map<String, Consumer<String>> consumerMap = new HashMap<>();
consumerMap.put(DEFAULT_COMPONENT_MODEL, AutoMapperProperties::setComponentModel);
consumerMap.put(MAPPER_PACKAGE, AutoMapperProperties::setMapperPackage);
consumerMap.put(UNMAPPED_SOURCE_POLICY, value -> AutoMapperProperties.setUnmappedSourcePolicy(ReportingPolicy.valueOf(value)));
consumerMap.put(UNMAPPED_TARGET_POLICY, value -> AutoMapperProperties.setUnmappedTargetPolicy(ReportingPolicy.valueOf(value)));
consumerMap.put(NULL_VALUE_MAPPING_STRATEGY,
value -> AutoMapperProperties.setNullValueMappingStrategy(NullValueMappingStrategy.valueOf(value)));
consumerMap.put(NULL_VALUE_PROPERTY_MAPPING_STRATEGY,
value -> AutoMapperProperties.setNullValuePropertyMappingStrategy(
NullValuePropertyMappingStrategy.valueOf(value)
));
consumerMap.put(BUILDER_BUILD_METHOD, AutoMapperProperties::setBuildMethod);
consumerMap.put(BUILDER_DISABLE_BUILDER,
value -> AutoMapperProperties.setDisableBuilder(Boolean.parseBoolean(value)));
consumerMap.put(ADAPTER_PACKAGE, AutoMapperProperties::setAdapterPackage);
consumerMap.put(ADAPTER_CLASS_NAME, AutoMapperProperties::setAdapterClassName);
consumerMap.put(MAP_ADAPTER_CLASS_NAME, AutoMapperProperties::setMapAdapterClassName);
return consumerMap;
}
}