• mapStruct笔记


    背景

    mapStruct 是一个方便对象转换的工具,类似的工具还有 Dozer, BeanUtils。

    实现

    mapStruct的核心是在编译期生成基于转换规则的 Impl 文件,运行时直接调用 Impl 文件中的函数。整个 mapStruct 分成三个部分:

    1. 自定义注解,指定转换的规则。例如 source, target 等。

    2. freemarker 模板,用来生成 impl 文件。

    3. 基于 javax.annotation.processing 的处理模块。

    基本流程是

    解析注解
    生成 Mapper Model
    将 Model 按规则写入 Freemarker 模板中, 并生成 Impl 文件
    生成Impl对象, 转换时调用

    具体解析

    具体的解析逻辑是将解析注解内容转化为 Mapper model 对象,然后将 Mapper model 写入 freemarker 模板中。

    处理框架

    整个注解的解析是通过 java compile[1] 实现的,逻辑包含在MappingProcessor.process 函数中,并通过 MapperGenerationVisitor 进行解析。

    	@Override
    	public boolean process(
    			final Set<? extends TypeElement> annotations,
    			final RoundEnvironment roundEnvironment) {
            // 遍历需要处理的注解
    		for ( TypeElement oneAnnotation : annotations ) {
    
    		<span class="hljs-comment">//Indicates that the annotation's type isn't on the class path of the compiled</span>
    		<span class="hljs-comment">//project. Let the compiler deal with that and print an appropriate error.</span>
    		<span class="hljs-keyword">if</span> ( oneAnnotation.getKind() != ElementKind.ANNOTATION_TYPE ) {
    			<span class="hljs-keyword">continue</span>;
    		}
    

    // 遍历包含 Mapper 注解的 interface and class , 例如 org.mapstruct.ap.test.conversion.SourceTargetMapper
    for ( Element oneAnnotatedElement : roundEnvironment.getElementsAnnotatedWith( oneAnnotation ) ) {
    // MapperGenerationVisitor 解析每个Mapper 注解的内容 成为一个 Model
    oneAnnotatedElement.accept( new MapperGenerationVisitor( processingEnv ), null );
    }
    }

    	<span class="hljs-keyword">return</span> ANNOTATIONS_CLAIMED_EXCLUSIVELY;
    }
    

    解析逻辑

    MapperGenerationVisitor 负责解析注解为 Mapper model, 并写入 ftl 模板文件中。

    MapperGenerationVisitor.retrieveModel 包含了具体的解析逻辑,将注解内容转化为 Mapper Model。

    ModelWriter 负责将 Mapper Model 写入 ftl 模板中。

    整个逻辑都是围绕 Mapper model 展开的, Mapper 包含如下内容:

    	private final String packageName; // 包的名称
    
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">final</span> String interfaceName; <span class="hljs-comment">// 接口名称</span>
    
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">final</span> String implementationName; <span class="hljs-comment">// 应用名称</span>
    
    <span class="hljs-keyword">private</span> <span class="hljs-keyword">final</span> List&lt;BeanMapping&gt; beanMappings; <span class="hljs-comment">// 一系列的 mapping 信息, 每个 method 对应一个 BeanMapping</span>
    

    每一个 BeanMapping 对应一个转换函数,它的格式如下:

    
    	private final Type sourceType; // 函数的输入参数类型
    	private final Type targetType; // 函数的结果参数类型
    	private final List<PropertyMapping> propertyMappings; // 转换函数的每个属性的信息
    	private final MappingMethod mappingMethod; // 映射的函数
    	private final MappingMethod reverseMappingMethod; // 翻转映射的函数
    	private final boolean isIterableMapping; // 是不是迭代
    

    例如 SourceTargetMapper 接口:

    
    @Mapper
    public interface SourceTargetMapper {
    
    <span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> SourceTargetMapper INSTANCE = Mappers.getMapper( SourceTargetMapper.class );
    
    <span class="hljs-meta">@Mappings</span>({
    		<span class="hljs-meta">@Mapping</span>(source = <span class="hljs-string">"qax"</span>, target = <span class="hljs-string">"baz"</span>),
    		<span class="hljs-meta">@Mapping</span>(source = <span class="hljs-string">"baz"</span>, target = <span class="hljs-string">"qax"</span>)
    })
    <span class="hljs-function">Target <span class="hljs-title">sourceToTarget</span><span class="hljs-params">(Source source)</span></span>;
    
    <span class="hljs-function">Source <span class="hljs-title">targetToSource</span><span class="hljs-params">(Target target)</span></span>;
    

    }

    映射为 Mapper Model 为:

    {
        "beanMappings":[
            {
                "iterableMapping":false,
                "mappingMethod":{
                    "name":"sourceToTarget",
                    "parameterName":"source"
                },
                "propertyMappings":[
                    {
                        "fromConversion":"target.getFoo().intValue()",
                        "sourceName":"foo",
                        "sourceType":{
                            "name":"int",
                            "primitive":true
                        },
                        "targetName":"foo",
                        "targetType":{
                            "name":"Long",
                            "packageName":"java.lang",
                            "primitive":false
                        },
                        "toConversion":"Long.valueOf( source.getFoo() )"
                    },
                    Object{...},
                    Object{...},
                    Object{...},
                    Object{...}
                ],
                "reverseMappingMethod":{
                    "name":"targetToSource",
                    "parameterName":"target"
                },
                "sourceType":{
                    "name":"Source",
                    "packageName":"org.mapstruct.ap.test.conversion",
                    "primitive":false
                },
                "targetType":{
                    "name":"Target",
                    "packageName":"org.mapstruct.ap.test.conversion",
                    "primitive":false
                }
            }
        ],
        "implementationName":"SourceTargetMapperImpl",
        "interfaceName":"SourceTargetMapper",
        "packageName":"org.mapstruct.ap.test.conversion"
    }
    

    写入模板

    写入模板是使用 freemarker 进行编写的,最初写入逻辑很简单,直接使用 ModelWriter 进行写入。ftl 模板的部分内容如下:

    
    package ${packageName};
    

    import java.util.ArrayList;
    import java.util.List;

    public class ${implementationName} implements ${interfaceName} {

    上面的 ${packageName}对应的就是 Mapper Model 中的 packageName。

    参考

    1. javax.lang.model.element.Element
    2. 编译器 API
    原文地址:https://www.cnblogs.com/SpeakSoftlyLove/p/9794661.html
  • 相关阅读:
    使用C语言实现面相对对象三大特性
    ResNet王者归来:ImageNet上刷新到80.7!
    VAE生成模型
    DeeplabV3++语义分割训练自制数据集
    CUDA编程入门极简教程
    加载预训练模型修改类别数与不修改类别数
    python使用opencv将Labelme生成的分割图转化成二值化分割图
    pytorch 单卡加载多卡模型module
    【pytorch】常用图像处理与数据增强方法合集(torchvision.transforms)(详细)
    C++11:原子交换函数compare_exchange_weak和compare_exchange_strong
  • 原文地址:https://www.cnblogs.com/jpfss/p/10899238.html
Copyright © 2020-2023  润新知