Java类型转换框架MapstructPlus使用分享

字数统计: 2.6k字   |   阅读时长≈ 13分

前言

       在Java系统中经常要对不同数据类型对象如VO/DTO/BO等进行转换，传统写法用 Getter/Setter 方法复制属性非常繁琐且代码可读性差，有些人会使用 BeanUtil.copyproperties 方法转换属性，但该方法用反射方式实现，在数据量大的时候存在性能问题，且只支持名称和类型完全相同的属性之间转换，不够灵活；基于上面的问题，我推荐使用 MapstructPlus 框架，MapstructPlus 是 Mapstruct 的增强工具，在 Mapstruct 的基础上，实现了自动生成 Mapper 接口的功能，生成的代码是基于 Getter/Setter 方法，不会有较大的性能消耗，使 Java 类型转换更加便捷、优雅。

1.引入依赖

这里我推荐一个IDEA插件maven-search，方便快速搜索和复制maven依赖
1).若项目中引入了lombok，官方文档提供了整合Lombok的Maven配置
2).若项目中有jar包引入了MapStruct，为避免冲突最好排除掉，官方文档有提到Mapstruct依赖冲突问题

maven引入依赖配置，项目中swagger2模块存在Mapstruct，故在配置中排除了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!-- 依赖版本号 -->
<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>
    <maven-compiler-plugin.verison>3.8.1</maven-compiler-plugin.verison>
    <lombok.version>1.18.12</lombok.version>
    <mapstruct-plus.version>1.3.4</mapstruct-plus.version>
</properties>

<!-- 项目依赖 -->
<dependencies>
    <dependency>
        <groupId>io.github.linpeilie</groupId>
        <artifactId>mapstruct-plus-spring-boot-starter</artifactId>
        <version>${mapstruct-plus.version}</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>${springfox.version}</version>
        <exclusions>
            <exclusion>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

maven编译插件配置，整合Lombok在编译时自动生成代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>${maven-compiler-plugin.verison}</version>
            <configuration>
                <source>${maven.compiler.source}</source>
                <target>${maven.compiler.target}</target>
                <encoding>${project.build.sourceEncoding}</encoding>
                <!-- 编译时注解处理配置，Lombok和Mapstruct Plus -->
                <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>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>

2.示例代码

配置多个类转换、配置指定类转换的规则等更多使用方法参考MapstructPlus 官方文档 和 MapStruct官方文档 ，这里就不展开了。

  • 方式1：实体类添加@AutoMapper注解
    如果能直接修改其中一个实体类，那么只需要其中一个实体类添加@AutoMapper注解，就可以实现两者之间的转换。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    import io.github.linpeilie.annotations.AutoMapMapper;
    import io.github.linpeilie.annotations.AutoMapper;
    import lombok.Data;

    /**
     * @author yinshuang
     * @date 2023/7/19 20:43
     * @description UserAttrVO
     */
    @Data
    @AutoMapper(target = UserBasicVO.class)
    @AutoMapMapper
    public class UserAttrVO {

        /**
         * 物理主键
         */
        private Long userId;

        /**
         * 角色
         */
        private String role;

        /**
         * 所属部门
         */
        private String department;

        /**
         * 岗位
         */
        private String position;
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52

    import io.github.linpeilie.annotations.AutoMapMapper;
    import lombok.Data;

    /**
     * @author yinshuang
     * @date 2023/7/19 20:42
     * @description UserBasicVO
     */
    @Data
    @AutoMapMapper
    public class UserBasicVO {
        /**
         * 物理主键
         */
        private Long userId;

        /**
         * 用户账号
         */
        private String username;

        /**
         * 用户昵称
         */
        private String nickName;

        /**
         * 手机号码
         */
        private String mobile;

        /**
         * 电子邮箱
         */
        private String email;

        /**
         * 角色
         */
        private String role;

        /**
         * 所属部门
         */
        private String department;

        /**
         * 岗位
         */
        private String position;
    }
    用 @AutoWare 或 @Resource 注解注入Convertor后，使用convert方法即可。
  • 方式2：Mapstruct用法，定义Mapper接口添加@Mapper注解
    适用于无法修改实体类源码的场景

componentModel: 指定Mapper模式（实现类添加指定的注解类型），可选值有：default、cdi、spring、jsr330和jakarta。
default: 默认情况，可以通过Mappers.getMapper(Class)方式获取实例对象；
cdi: 生成的实现类上面会添加 @ApplicationScoped 注解，可以通过 @Inject 注解获取实例对象；
spring: 生成的实现类上面会添加 @Component 注解，可以通过 @Autowired 或 @Resource 注解获取实例对象
jsr330: 生成的实现类上面会添加 @javax.inject.Named 和 @Singleton 注解，可以通过 @Inject 注解获取实例对象；
jakarta: 生成的实现类上面会添加 @RequestScoped 注解，可以通过 @Inject 注解获取实例对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import com.xxx.vo.UserAttrVO;
import com.xxx.vo.UserBasicVO;
import org.mapstruct.Mapper;
import org.mapstruct.MappingConstants;

import java.util.List;

@Mapper(componentModel = MappingConstants.ComponentModel.SPRING)
public interface UserAttrMapper {

    UserBasicVO toUserBasicVO(UserAttrVO userAttr);

    UserAttrVO toUserAttrVO(UserBasicVO userBasic);

    List<UserBasicVO> toUserBasicVOList(List<UserAttrVO> userAttrList);

    List<UserAttrVO> toUserAttrVOList(List<UserBasicVO> userBasicList);

}

用 @AutoWare 或 @Resource 注解注入UserAttrMapper后，使用UserAttrMapper接口中定义方法即可。

  • 方式3：MapstructPlus用法，定义Mapper接口添加@Mapper注解，并且extends BaseMapper<S,T>
    适用于无法修改实体类源码的场景
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import com.xxx.vo.UserAttrVO;
    import com.xxx.vo.UserBasicVO;
    import io.github.linpeilie.BaseMapper;
    import org.mapstruct.Mapper;
    import org.mapstruct.MappingConstants;

    import java.util.List;

    @Mapper(componentModel = MappingConstants.ComponentModel.SPRING)
    public interface UserAttrMapper extends BaseMapper<UserAttrVO, UserBasicVO> {

    }
    用 @AutoWare 或 @Resource 注解注入UserAttrMapper或Convertor，使用convert方法即可。

2.测试类代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import com.xxx.vo.UserAttrVO;
import com.xxx.vo.UserBasicVO;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Assert;
import io.github.linpeilie.Converter;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

/**
 * @author yinshuang
 * @date 2023/7/19 20:54
 * @description MapstructPlusController
 */
@Slf4j
@ApiModel(value = "Mapstruct Plus API")
@RequestMapping(value = "/mapstruct/plus")
@RestController
@RequiredArgsConstructor(onConstructor_ = {@Autowired})
public class MapstructPlusController {

    private final Converter converter;

    @ApiOperation("converter Api test")
    @GetMapping("/test")
    public void mapstructPlusConverterApiTest() {
        UserAttrVO userAttr1 = new UserAttrVO();
        userAttr1.setUserId(1L);
        userAttr1.setRole("角色A");
        userAttr1.setPosition("岗位A");
        userAttr1.setDepartment("部门A");

        UserBasicVO userBasic1 = new UserBasicVO();
        userBasic1.setUserId(1L);
        userBasic1.setUsername("zhangsan");
        userBasic1.setNickName("张三");
        userBasic1.setMobile("13600012345");
        userBasic1.setEmail("zhangsan@163.com");

        List<UserAttrVO> listUserAttr1 = new ArrayList<>();
        List<UserBasicVO> listUserBasic1 = new ArrayList<>();
        listUserAttr1.add(userAttr1);
        listUserBasic1.add(userBasic1);



        // source对象相同属性转换到target对象
        log.info("userBasic1 convert before: " + userBasic1);
        converter.convert(userAttr1, userBasic1);
        log.info("userBasic1 convert after: " + userBasic1);

        // source对象转换到targetType类型新对象
        UserBasicVO userBasic2 = converter.convert(userAttr1, UserBasicVO.class);
        UserAttrVO userAttr2 = converter.convert(userBasic1, UserAttrVO.class);
        log.info("userBasic2 convert after: " + userBasic2);
        log.info("userAttr2 convert after: " + userAttr2);

        // source集合List转换到targetType类型新集合List
        List<UserBasicVO> listUserBasic2 = converter.convert(listUserAttr1, UserBasicVO.class);
        List<UserAttrVO> listUserAttr2 = converter.convert(listUserBasic1, UserAttrVO.class);
        log.info("listUserBasic2 convert after: " + listUserBasic2);
        log.info("listUserAttr2 convert after: " + listUserAttr2);

        // Map<String, Object> map转换到targetType类型新对象 (targetType.java需要加 @AutoMapMapper 注解)
        Map<String, Object> userAttaMap = BeanUtil.beanToMap(userAttr1);
        Map<String, Object> userBasicMap = BeanUtil.beanToMap(userBasic1);
        log.info("userAttaMap: " + userAttaMap);
        log.info("userBasicMap: " + userBasicMap);
        UserBasicVO userBasic3 = converter.convert(userBasicMap, UserBasicVO.class);
        UserAttrVO userAttr3 = converter.convert(userAttaMap, UserAttrVO.class);
        log.info("userBasic3 convert after: " + userBasic3);
        log.info("userAttr3 convert after: " + userAttr3);
        Assert.equals(userBasic3, userBasic1);
        Assert.equals(userAttr3, userAttr1);
    }
}

3.生成代码

下面是加上 @AutoMapper 和 @AutoMapMapper 注解后，MapStruct Plus 框架自动生成的代码；
自动生生成的代码在对应模块根目录的 /target/generated-sources/annotations/ 中，
第一类是MapStruct Puls 相关的配置类，第二类是extends BaseMapMapper 的接口和对应的实现
1).MapStruct Puls 相关的配置类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package io.github.linpeilie;

import org.mapstruct.Builder;
import org.mapstruct.MapperConfig;
import org.mapstruct.NullValueMappingStrategy;
import org.mapstruct.NullValuePropertyMappingStrategy;
import org.mapstruct.ReportingPolicy;

@MapperConfig(
    componentModel = "spring",
    uses = {ConvertMapperAdapter.class},
    unmappedSourcePolicy = ReportingPolicy.IGNORE,
    unmappedTargetPolicy = ReportingPolicy.IGNORE,
    nullValueMappingStrategy = NullValueMappingStrategy.RETURN_NULL,
    nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_NULL,
    builder = @Builder(buildMethod = "build", disableBuilder = true)
)
public interface AutoMapperConfig {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package io.github.linpeilie;

import com.xxx.vo.UserAttrVO;
import com.xxx.vo.UserAttrVOToUserBasicVOMapper;
import com.xxx.vo.UserBasicVO;
import com.xxx.vo.UserBasicVOToUserAttrVOMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
public class ConvertMapperAdapter {
  @Autowired
  @Lazy
  private UserAttrVOToUserBasicVOMapper userAttrVOToUserBasicVOMapper;

  @Autowired
  @Lazy
  private UserBasicVOToUserAttrVOMapper userBasicVOToUserAttrVOMapper;

  public UserBasicVO com_chinacscs_cmaster_cicc_common_vo_UserAttrVOToUserBasicVO(UserAttrVO param) {
    return userAttrVOToUserBasicVOMapper.convert(param);}

  public UserAttrVO com_chinacscs_cmaster_cicc_common_vo_UserBasicVOToUserAttrVO(UserBasicVO param) {
    return userBasicVOToUserAttrVOMapper.convert(param);}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package io.github.linpeilie;

import org.mapstruct.Builder;
import org.mapstruct.MapperConfig;
import org.mapstruct.NullValueMappingStrategy;
import org.mapstruct.NullValuePropertyMappingStrategy;
import org.mapstruct.ReportingPolicy;

@MapperConfig(
    componentModel = "spring",
    uses = {MapConvertMapperAdapter.class},
    unmappedSourcePolicy = ReportingPolicy.IGNORE,
    unmappedTargetPolicy = ReportingPolicy.IGNORE,
    nullValueMappingStrategy = NullValueMappingStrategy.RETURN_NULL,
    nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_NULL,
    builder = @Builder(buildMethod = "build", disableBuilder = true)
)
public interface AutoMapMapperConfig {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package io.github.linpeilie;

import com.xxx.vo.MapToUserAttrVOMapper;
import com.xxx.vo.MapToUserBasicVOMapper;
import com.xxx.vo.UserAttrVO;
import com.xxx.vo.UserBasicVO;
import java.lang.Object;
import java.lang.String;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
public class MapConvertMapperAdapter {
  @Autowired
  @Lazy
  private MapToUserBasicVOMapper mapToUserBasicVOMapper;

  @Autowired
  @Lazy
  private MapToUserAttrVOMapper mapToUserAttrVOMapper;

  public UserBasicVO mapToUserBasicVO(Map<String, Object> param) {
    return mapToUserBasicVOMapper.convert(param);}

  public UserAttrVO mapToUserAttrVO(Map<String, Object> param) {
    return mapToUserAttrVOMapper.convert(param);}

  public UserBasicVO objectToUserBasicVO(Object param) {
    return mapToUserBasicVOMapper.convertByObj(param);}

  public UserAttrVO objectToUserAttrVO(Object param) {
    return mapToUserAttrVOMapper.convertByObj(param);}
}

2).Mapper 接口和对应的实现
以UserAttrVO为例，UserBasicVO类似就不列举了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.xxx.vo;

import io.github.linpeilie.AutoMapperConfig;
import io.github.linpeilie.BaseMapper;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;

@Mapper(
    config = AutoMapperConfig.class,
    uses = {},
    imports = {}
)
public interface UserAttrVOToUserBasicVOMapper extends BaseMapper<UserAttrVO, UserBasicVO> {
  UserBasicVO convert(UserAttrVO source, @MappingTarget UserBasicVO target);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com.xxx.vo;

import javax.annotation.Generated;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2023-07-19T20:16:33+0800",
    comments = "version: 1.5.5.Final, compiler: javac, environment: Java 1.8.0_251 (Oracle Corporation)"
)
@Component
public class UserAttrVOToUserBasicVOMapperImpl implements UserAttrVOToUserBasicVOMapper {

    @Override
    public UserBasicVO convert(UserAttrVO arg0) {
        if ( arg0 == null ) {
            return null;
        }

        UserBasicVO userBasicVO = new UserBasicVO();

        userBasicVO.setUserId( arg0.getUserId() );
        userBasicVO.setRole( arg0.getRole() );
        userBasicVO.setDepartment( arg0.getDepartment() );
        userBasicVO.setPosition( arg0.getPosition() );

        return userBasicVO;
    }

    @Override
    public UserBasicVO convert(UserAttrVO source, UserBasicVO target) {
        if ( source == null ) {
            return target;
        }

        target.setUserId( source.getUserId() );
        target.setRole( source.getRole() );
        target.setDepartment( source.getDepartment() );
        target.setPosition( source.getPosition() );

        return target;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.xxx.vo;

import io.github.linpeilie.AutoMapMapperConfig;
import io.github.linpeilie.BaseMapMapper;
import io.github.linpeilie.map.MapObjectConvert;
import java.util.Map;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;

@Mapper(
    config = AutoMapMapperConfig.class,
    uses = {MapObjectConvert.class},
    imports = {}
)
public interface MapToUserAttrVOMapper extends BaseMapMapper<UserAttrVO> {
  UserAttrVO convert(Map source, @MappingTarget UserAttrVO target);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package com.xxx.vo;

import io.github.linpeilie.map.MapObjectConvert;
import java.util.Map;
import javax.annotation.Generated;
import org.springframework.stereotype.Component;

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2023-07-19T20:16:33+0800",
    comments = "version: 1.5.5.Final, compiler: javac, environment: Java 1.8.0_251 (Oracle Corporation)"
)
@Component
public class MapToUserAttrVOMapperImpl implements MapToUserAttrVOMapper {

    @Override
    public UserAttrVO convert(Map<String, Object> arg0) {
        if ( arg0 == null ) {
            return null;
        }

        UserAttrVO userAttrVO = new UserAttrVO();

        if ( arg0.containsKey( "userId" ) ) {
            userAttrVO.setUserId( MapObjectConvert.objToLong( arg0.get( "userId" ) ) );
        }
        if ( arg0.containsKey( "role" ) ) {
            userAttrVO.setRole( MapObjectConvert.objToString( arg0.get( "role" ) ) );
        }
        if ( arg0.containsKey( "department" ) ) {
            userAttrVO.setDepartment( MapObjectConvert.objToString( arg0.get( "department" ) ) );
        }
        if ( arg0.containsKey( "position" ) ) {
            userAttrVO.setPosition( MapObjectConvert.objToString( arg0.get( "position" ) ) );
        }

        return userAttrVO;
    }

    @Override
    public UserAttrVO convert(Map source, UserAttrVO target) {
        if ( source == null ) {
            return target;
        }

        return target;
    }
}

赏

谢谢你请我吃糖果

微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置：

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发


联系QQ:875038467

很惭愧

只做了一点微小的工作
谢谢大家