【Java DTO、VO类型转换工具类，对象与对象之间赋值】全部一行代码搞定！爽

ZuuuuYao

已于 2024-09-20 11:27:01 修改

阅读量1.6k

点赞数 30

分类专栏： Java # SpringBoot 文章标签： java 开发语言

于 2024-09-20 11:23:21 首次发布

本文链接：https://blog.csdn.net/weixin_42703501/article/details/142377665

版权

Java 同时被 2 个专栏收录

7 篇文章

订阅专栏

SpringBoot

4 篇文章

订阅专栏

对象转换工具

一、modelmapper 介绍
二、安装
- （一）引入依赖
- （二）添加工具类
三、使用示例

一、modelmapper 介绍

简化对象转换操作
在Java 应用开发中，经常需要在不同层次（如持久层、业务逻辑层、表示层）之间转换对象。例如，将数据库查询得到的实体对象（Entity）转换为适合在网络上传输的数据传输对象（DTO），或者将用户输入的表单对象转换为业务逻辑处理的领域对象（Domain Object）。ModelMapper 能够自动完成大部分属性的映射，减少了手动编写大量属性赋值语句的工作量。
假设存在一个UserEntity类，包含id、username、password、createdAt等属性，以及一个UserDTO类，包含id、username和isAdmin属性。使用 ModelMapper 可以轻松地将UserEntity转换为UserDTO，而不需要为每个属性手动编写转换代码。
支持复杂对象结构的转换
当处理具有嵌套结构的对象时，ModelMapper 能够递归地进行映射。例如，在一个电商系统中，有Order类包含Customer对象和List，对应的OrderDTO也有类似的嵌套结构。ModelMapper 可以自动处理这种嵌套对象的映射，将Order对象中的Customer和Product相关属性正确地映射到OrderDTO中的相应部分。

二、安装

（一）引入依赖

        <!-- 对象转换工具-->
        <dependency>
            <groupId>org.modelmapper</groupId>
            <artifactId>modelmapper</artifactId>
            <version>3.2.0</version>
        </dependency>

（二）添加工具类

需要修改一下包名

package org.github.zuuuyao.common.util;

import org.modelmapper.ModelMapper;
import org.modelmapper.convention.MatchingStrategies;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Consumer;

/**
 * 对象映射转换工具类,转换逻辑属性名完全匹配进行转换
 *
 * @Description:
 * @Time: 2019-11-28 20:18
 * @Author: HuangZhangYao
 */
public final class ModelMapperUtil {

    public static final ModelMapper MODEL_MAPPER;

    static {

        MODEL_MAPPER = new ModelMapper();
        // 完全类型匹配
        //MODEL_MAPPER.getConfiguration().setFullTypeMatchingRequired(true);
        // 设置属性匹配规则,设置为最严格匹配,必须属性名相同
        MODEL_MAPPER.getConfiguration().setMatchingStrategy(MatchingStrategies.STRICT);
    }

    /**
     * 禁止实列化该类
     * @throws InstantiationException 不能实列化
     */
    private ModelMapperUtil() throws InstantiationException {
        throw new InstantiationException("Tool Class Cannot Be Created Instantiation !");
    }

    /**
     * 将对象转换为指定class类型对象。
     * @param source 源对象
     * @param targetClass 转换目标类型
     * @return 转换后对象
     * @param <Target> 目标类型
     */
    public static <Target> Target map(Object source, Class<Target> targetClass) {
        return source == null ? null : MODEL_MAPPER.map(source, targetClass);
    }


    /**
     * 将源对象中的属性转换到目标对象中,源对象与目标对象属性名相同的则转换
     * @param source 源对象
     * @param target 目标对象
     */
    public static void map(Object source, Object target) {
        if (source == null || target == null) {
            return;
        } else {
            MODEL_MAPPER.map(source, target);
        }
    }

    /**
     * 将对象转换为指定class类型对象,并对转换后对象进行处理
     * @param source 源对象
     * @param targetClass 转换目标类型
     * @param consumer 对转换后对象进行消费处理
     * @return 转换后对象
     * @param <Target> 目标类型
     */
    public static <Target> Target map(Object source, Class<Target> targetClass, Consumer<Target> consumer) {
        Target target = source == null ? null : MODEL_MAPPER.map(source, targetClass);
        if (consumer != null) {
            consumer.accept(target);
        }
        return target;
    }

    /**
     * 将对象转换为指定class类型对象,并对转换后对象进行处理
     * @param source 源对象
     * @param targetClass 转换目标类型
     * @param consumer 对转换后对象进行消费处理
     * @return 转换后对象
     * @param <Source> 源对象类型
     * @param <Target> 目标类型
     */
    public static <Source, Target> Target map(Source source, Class<Target> targetClass, BiConsumer<Source, Target> consumer) {
        Target target = source == null ? null : MODEL_MAPPER.map(source, targetClass);
        if (consumer != null) {
            consumer.accept(source, target);
        }
        return target;
    }

    /**
     * 将集合中的元素抓换为指定类型
     * @param sourceList 源集合
     * @param targetClass 转换目标类型
     * @return 转换后的目标类型集合
     * @param <TSource> 源类型
     * @param <Target> 目标类型
     */
    public static <TSource, Target> List<Target> mapList(Collection<TSource> sourceList, Class<Target> targetClass) {

        if (sourceList == null) {
            return new ArrayList<Target>();
        }

        ArrayList<Target> targets = new ArrayList<>(sourceList.size());

        sourceList.forEach(p -> {
            Target item = map(p, targetClass);
            targets.add(item);
        });

        return targets;
    }

    /**
     * 将集合中的元素抓换为指定类型,并对转换后的元素处理
     * @param sourceList 源集合
     * @param targetClass 转换目标类型
     * @param consumer 对转换后元素处理
     * @return 转换后的集合
     * @param <TSource> 源类型
     * @param <Target> 目标类型
     */
    public static <TSource, Target> List<Target> mapList(Collection<TSource> sourceList, Class<Target> targetClass, Consumer<Target> consumer) {

        if (sourceList == null) {
            return new ArrayList<Target>();
        }

        ArrayList<Target> targets = new ArrayList<>(sourceList.size());

        sourceList.forEach(p -> {
            Target item = map(p, targetClass);

            if (consumer != null) {
                consumer.accept(item);
            }
            targets.add(item);
        });

        return targets;
    }

    /**
     * 将集合中的元素抓换为指定类型,并对转换后的元素处理
     * @param sourceList 源集合
     * @param targetClass 转换目标类型
     * @param consumer 对转换后元素处理
     * @return 转换后的集合
     * @param <TSource> 源类型
     * @param <Target> 目标类型
     */
    public static <TSource, Target> List<Target> mapList(Collection<TSource> sourceList, Class<Target> targetClass, BiConsumer<TSource, Target> consumer) {

        if (sourceList == null) {
            return new ArrayList<Target>();
        }

        ArrayList<Target> targets = new ArrayList<>(sourceList.size());

        sourceList.forEach(p -> {
            Target map = ModelMapperUtil.map(p, targetClass);
            if (consumer != null) {
                consumer.accept(p, map);
            }
            targets.add(map);
        });
        return targets;
    }

}

三、使用示例

准备 UserEntity 实体

package org.github.zuuuyao.entity.system;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.*;
import org.github.zuuuyao.common.base.entity.AbstractBaseEntity;
import org.github.zuuuyao.entity.enums.GenderEnum;

import java.io.Serial;
import java.time.LocalDateTime;

/**
 * @Desc 系统用户表
 * @Time 2024-07-11 16:31
 * @Author HuangZhongYao
 */
@Getter
@Setter
@Builder
@ToString
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
@TableName("sys_user")
public class UserEntity extends AbstractBaseEntity {

    @Serial
    private static final long serialVersionUID = -4075127738715995785L;

    /**
     * 用户名
     */
    private String username;

    /**
     * 账号
     */
    private String account;

    /**
     * 密码
     */
    private String password;

    /**
     * 密码盐
     */
    private String salt;

    /**
     * 性别
     */
    private GenderEnum gender = GenderEnum.UNKNOWN;

    /**
     * 手机号
     */
    private String phone;

    /**
     * 头像url
     */
    private String avatarUrl;

    /**
     * 备注
     */
    private String remark;

    /**
     * 最后登录时间
     */
    private LocalDateTime lastLoginTime;

    /**
     * 启用状态
     */
    private Boolean enable;

}

准备 UserVo 实体

package org.github.zuuuyao.service.user.dto.output;

import io.swagger.v3.oas.annotations.media.Schema;
import java.io.Serial;
import java.time.LocalDateTime;
import java.util.List;
import lombok.Getter;
import lombok.Setter;
import org.github.zuuuyao.common.base.dto.output.BaseOutputIdAndTimeAndOperationDTO;
import org.github.zuuuyao.entity.enums.GenderEnum;
import org.github.zuuuyao.service.role.dto.output.RoleVo;
import org.github.zuuuyao.service.user.model.UserRoleModel;

/**
 * @Desc
 * @Time 2024-07-16 16:29
 * @Author HuangZhongYao
 */
@Getter
@Setter
public class UserVo extends BaseOutputIdAndTimeAndOperationDTO {

    @Serial
    private static final long serialVersionUID = -7091624991626890336L;

    /**
     * 用户名
     */
    @Schema(description = "用户名")
    private String username;

    /**
     * 账号
     */
    @Schema(description = "账号")
    private String account;

    /**
     * 性别枚举
     */
    @Schema(description = "性别")
    private GenderEnum gender;

    /**
     * 性别枚举表示值
     */
    @Schema(description = "性别枚举表示值")
    private int genderEnumValue;

    /**
     * 性别枚举描述
     */
    @Schema(description = "性别枚举描述")
    private String genderEnumDesc;
    
    /**
     * 手机号
     */
    @Schema(description = "手机号")
    private String phone;

    /**
     * 头像url
     */
    @Schema(description = "头像url")
    private String avatarUrl;

    /**
     * 备注
     */
    @Schema(description = "备注")
    private String remark;

    /**
     * 最后登录时间
     */
    @Schema(description = "最后登录时间")
    private LocalDateTime lastLoginTime;

    /**
     * 启用状态
     */
    @Schema(description = "启用状态")
    private Boolean enable;

    /**
     * 用户角色列表
     */
    @Schema(description = "用户角色列表")
    private List<UserRoleModel> roles;
}

（一）单个对象转换

（一）简单转换

    public static void main(String[] args) {

        // 创建一个用户实体对象
        UserEntity admin = UserEntity.builder()
                .username("ZuuuYao")
                .phone("1888888888")
                .account("zy9527")
                .avatarUrl("http://xxx.com/avatar.png")
                .gender(GenderEnum.MALE)
                .remark("管理员")
                .enable(Boolean.TRUE)
                .build();

        // 方式1: 转换为指定类型
        UserVo adminDetailsVo = ModelMapperUtil.map(admin, UserVo.class);

        // 方式2: 转换到指定对象上
        UserVo userVo = new UserVo();
        // 将admin中的同名的数据映射到userVo中
        ModelMapperUtil.map(admin, userVo);

    }

（二）转换时对转换后的对象处理

    public static void main(String[] args) {

        // 创建一个用户实体对象
        UserEntity admin = UserEntity.builder()
                .username("ZuuuYao")
                .phone("1888888888")
                .account("zy9527")
                .avatarUrl("http://xxx.com/avatar.png")
                .gender(GenderEnum.MALE)
                .remark("管理员")
                .enable(Boolean.TRUE)
                .build();

        // 转换为指定类型, 并使用Consumer设置自定义属性
        UserVo adminDetailsVo = ModelMapperUtil.map(admin, UserVo.class, target -> {
            // 模拟执行逻辑
            target.setGenderEnumDesc(target.getGender().getDesc());
            target.setGenderEnumValue(target.getGenderEnumValue());
        });


    }

（二）转换时对转换后的对象、源对象处理

    public static void main(String[] args) {

        // 创建一个用户实体对象
        UserEntity admin = UserEntity.builder()
                .username("ZuuuYao")
                .phone("1888888888")
                .account("zy9527")
                .avatarUrl("http://xxx.com/avatar.png")
                .gender(GenderEnum.MALE)
                .remark("管理员")
                .enable(Boolean.TRUE)
                .build();

        // 转换为指定类型, 并使用Consumer设置自定义属性
        UserVo adminDetailsVo = ModelMapperUtil.map(admin, UserVo.class, (source, target) -> {

            // source 是 admin
            // target 是 转换后的adminDetailsVo

            // 模拟执行逻辑
            target.setRemark("用户：" + source.getUsername() + "，描述：" + source.getRemark());
        });

    }

（一）批量转换

（一）简单转换

    public static void main(String[] args) {

        // stream 生成100个对象
        List<UserEntity> userEntityList = Stream.generate(() -> UserEntity.builder()
                        .username("ZuuuYao")
                        .phone("1888888888")
                        .account("zy9527")
                        .avatarUrl("http://xxx.com/avatar.png")
                        .gender(GenderEnum.MALE)
                        .remark("管理员")
                        .enable(Boolean.TRUE)
                        .build())
                .limit(100)
                .toList();

        // 转换为指定类型
        List<UserVo> userVos = ModelMapperUtil.mapList(userEntityList, UserVo.class);

    }

（二）转换时对转换后的对象处理

    public static void main(String[] args) {

        // stream 生成100个对象
        List<UserEntity> userEntityList = Stream.generate(() -> UserEntity.builder()
                        .username("ZuuuYao")
                        .phone("18888889898")
                        .account("zy9527")
                        .avatarUrl("http://xxx.com/avatar.png")
                        .gender(GenderEnum.MALE)
                        .remark("管理员")
                        .enable(Boolean.TRUE)
                        .build())
                .limit(100)
                .toList();

        // 转换为指定类型
        List<UserVo> userVos = ModelMapperUtil.mapList(userEntityList, UserVo.class, target -> {
            // 将手机号脱敏
            String phone = target.getPhone();
            String desensitizationPhone = phone.substring(0, 3) + "*****" + phone.substring(8);
            target.setPhone(desensitizationPhone);
        });

    }

（二）转换时对转换后的对象、源对象处理

    public static void main(String[] args) {

        // stream 生成100个对象
        List<UserEntity> userEntityList = Stream.generate(() -> UserEntity.builder()
                        .username("ZuuuYao")
                        .phone("18888889898")
                        .account("zy9527")
                        .avatarUrl("http://xxx.com/avatar.png")
                        .gender(GenderEnum.MALE)
                        .remark("管理员")
                        .enable(Boolean.TRUE)
                        .build())
                .limit(100)
                .toList();

        // 转换为指定类型
        List<UserVo> userVos = ModelMapperUtil.mapList(userEntityList, UserVo.class, (source, target) -> {
            // 可以获取到源对象和转换后对象

            // 假如源对象中有的属性，目标对象没有可以手动赋值
            // target.setA(source.getB());

        });

    }

四、扩展

可以结合mybatis、JPA做一些封装
如下：

// 查询结果就转换为UserVo了就不用再转换了，写起来也比较舒服
Page<UserVo> page = userRepository.selectPage(inputDTO.toMybatisPageObject(), queryWrapper, UserVo.class);

完