属性拷贝MapStruct

于 2024-10-08 08:41:18 发布
阅读量324 收藏 5
点赞数 8
文章标签： idea java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014755700/article/details/142750450
版权

端请求通过VO对象接收，并通过DTO对象进行流转，最后转换成DO对象与数据库DAO层进行交互，反之亦然。

当业务简单的时候，可以通过手动编码getter/setter函数来复制对象属性。但是当业务变的复杂，对象属性变得很多，那么手写复制属性代码不仅十分繁琐，非常耗时间，并且还可能容易出错。

为了解决这个痛点，在项目初期，项目的解决方法是随手写的转换工具函数：根据变量名进行反射，对基础类型和枚举的变量进行赋值。

总结下目前该工具函数的优缺点：

优点：

  1. 开发效率高，随时想要转换的时候，传入源对象以及指定class，调用下函数即可。

缺点：

  1. 项目中大量的反射会严重影响代码执行效率
  2. 由于使用了反射，所以成员变量的使用被追踪就很麻烦
  3. 转换失败只有在运行中报错才会发现
  4. 对于嵌套对象字段的情况无能为力
  5. 只能对基础类型进行复制
  6. 对字段名不一致的属性无法赋值

接下来就要介绍MapStruct 这个工具类，这个工具类之所以运行速度与硬编码差不多，这是因为MapStruct在编译期间就生成属性复制的代码，运行期间就无需使用反射或者字节码技术，从而确保了高性能。

另外，由于编译期间就生成了代码，所以如果有任何问题，编译期间就可以提前暴露，这对于开发人员来讲就可以提前解决问题，而不用等到代码应用上线了，运行之后才发现错误。

所以，为了克服项目中当前函数的被提到的五个缺点，笔者引入了MapStruct。

2. 如何引入MapStruct

只需要引入MapStruct的依赖，同时由于MapStruct需要在编译器期间生成代码，所以我们需要maven-compiler-plugin插件中配置

复制

// pom.xml
        <dependency>
            <groupId>org.MapStruct</groupId>
            <artifactId>MapStruct</artifactId>
            <version>1.4.1.Final</version>
        </dependency>

.高效性：

1.编译期   自动生成映射代码          

类型检查报错

2.灵活性：支持复杂映射（对象、集合列表）  

   支持属性不同字段名、类型的赋值

3.直观性：使用注解来定义映射规则     （根据需求指定返回类型、忽略属性，添加        条件判断来决定是否执行映射操作） 

 

package com.mdgyl.hussar.basic.supplier.changeorder.converter.struct;


import com.mdgyl.common.util.DateUtils;
import com.mdgyl.hussar.basic.model.supplier.masterdata.*;
import com.mdgyl.hussar.basic.model.supplier.supplierchangeorder.*;
import com.mdgyl.hussar.basic.supplier.changeorder.domain.*;
import org.apache.commons.lang3.StringUtils;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;

@Mapper
public interface ChangeOrderMapperConverter {
    ChangeOrderMapperConverter INSTANCE = Mappers.getMapper(ChangeOrderMapperConverter.class);

    @Mappings({
            @Mapping(target = "score", expression = "java(exchangeRateDO.getScore() == null? null:exchangeRateDO.getScore().toString())"),
            @Mapping(target = "operatingStartTime", expression = "java(exchangeRateDO.getOperatingStartTime() == null? null:formatDate(exchangeRateDO.getOperatingStartTime()))"),
    })
    SupplierChangeOrderModel doToModel(SupplierChangeOrderDo exchangeRateDO);

    @Mappings({
            @Mapping(target = "id", ignore = true),
            @Mapping(source = "tenantId", target = "tenantId"),
            @Mapping(target = "status", ignore = true),
            @Mapping(source = "id", target = "supplierDataId"),
            @Mapping(target = "deleteFlag", constant = "0")
    })
    SupplierChangeOrderModel converterSupplierToChangeOrder(SupplierModel supplierModel);

    @Mappings({
            @Mapping(target = "id", ignore = true),
            @Mapping(source = "id", target = "supplierAddressId")
    })
    SupplierChangeOrderAddressModel convertAddressesModel(SupplierAddressModel supplierAddressModel);

    @Mappings({
            @Mapping(target = "id", ignore = true),
            @Mapping(source = "id", target = "supplierBankId")
    })
    SupplierChangeOrderBankModel convertBankModel(SupplierBankModel supplierBankModel);

    @Mappings({
            @Mapping(target = "id", ignore = true),
            @Mapping(source = "id", target = "supplierContactsId"),
    })
    SupplierChangeOrderContactsModel convertContactModel(SupplierContactsModel supplierContactsModel);

    @Mappings({
            @Mapping(target = "id", ignore = true),
            @Mapping(source = "id", target = "supplierInfoId"),
    })
    SupplierChangeOrderInfoModel convertOderInfoModel(SupplierInfoModel supplierInfo);

    @Mappings({
            @Mapping(target = "score", expression = "java(parseBigDecimal(supplierChangeOrderModel.getScore()))"),
            @Mapping(target = "operatingStartTime", expression = "java(supplierChangeOrderModel.getOperatingStartTime() == null ? null : parseDate(supplierChangeOrderModel.getOperatingStartTime()))"),
    })
    SupplierChangeOrderDo converterModelToDo(SupplierChangeOrderModel supplierChangeOrderModel);

    @Mappings({
            @Mapping(target = "taxRate", expression = "java(parseBigDecimal(supplierChangeOrderModel.getTaxRate()))"),
            @Mapping(target = "staffSize", expression = "java(supplierChangeOrderModel.getStaffSize() == null || supplierChangeOrderModel.getStaffSize().isEmpty() ? null : new Integer(supplierChangeOrderModel.getStaffSize()))"),
            @Mapping(target = "numberOfInsured", expression = "java(supplierChangeOrderModel.getNumberOfInsured() == null || supplierChangeOrderModel.getNumberOfInsured().isEmpty() ? null : new Integer(supplierChangeOrderModel.getNumberOfInsured()))")
    })
    SupplierChangeOrderInfo converterInfoModelToDo(SupplierChangeOrderInfoModel supplierChangeOrderModel);

    SupplierChangeOrderAddress converterAddressModelToDo(SupplierChangeOrderAddressModel supplierChangeOrderAddressModel);

    SupplierChangeOrderBank converterBankModelToDo(SupplierChangeOrderBankModel supplierChangeOrderBankModel);

    SupplierChangeOrderContacts converterContactsModel(SupplierChangeOrderContactsModel supplierChangeOrderContactsModel);

    @Mappings({
            @Mapping(target = "taxRate", expression = "java(supplierInfo.getTaxRate() == null? null:supplierInfo.getTaxRate().toString())"),
            @Mapping(target = "staffSize", expression = "java(supplierInfo.getStaffSize() == null? null:supplierInfo.getStaffSize().toString())"),
            @Mapping(target = "numberOfInsured", expression = "java(supplierInfo.getNumberOfInsured() == null? null:supplierInfo.getNumberOfInsured().toString())")
    })
    SupplierChangeOrderInfoModel converterInfoDoToModel(SupplierChangeOrderInfo supplierInfo);

    SupplierChangeOrderAddressModel convertAddressesDoToModel(SupplierChangeOrderAddress supplierChangeOrderAddress);

    SupplierChangeOrderContactsModel convertContactsDoToModel(SupplierChangeOrderContacts supplierChangeOrderContacts);

    SupplierChangeOrderBankModel convertBankDoToModel(SupplierChangeOrderBank supplierChangeOrderContacts);

    @Mappings({
            @Mapping(source = "supplierDataId", target = "id"),
            @Mapping(source = "status", target = "status", ignore = true),
            @Mapping(target = "score", expression = "java(parseBigDecimal(changeOrderModel.getScore()))"),
            @Mapping(target = "operatingStartTime", expression = "java(parseLocalDateTime(changeOrderModel.getOperatingStartTime()))")
    })
    SupplierModel converterChangeOrderToSupplier(SupplierChangeOrderModel changeOrderModel);

    @Mappings({
            @Mapping(source = "supplierInfoId", target = "id"),
            @Mapping(target = "staffSize", expression = "java(changeOrderInfo.getStaffSize() == null|| changeOrderInfo.getStaffSize().isEmpty() ? null : Integer.parseInt(changeOrderInfo.getStaffSize()))"),
            @Mapping(target = "taxRate", expression = "java(parseBigDecimal(changeOrderInfo.getTaxRate()))"),
            @Mapping(target = "numberOfInsured", expression = "java(changeOrderInfo.getNumberOfInsured() == null || changeOrderInfo.getNumberOfInsured().isEmpty()? null : Integer.parseInt(changeOrderInfo.getNumberOfInsured()))"),

    })
    SupplierInfoModel convertOderInfoToSupplierModel(SupplierChangeOrderInfoModel changeOrderInfo);

    @Mappings({
            @Mapping(source = "supplierAddressId", target = "id")
    })
    SupplierAddressModel convertAddressesToSupplierModel(SupplierChangeOrderAddressModel supplierChangeOrderAddressModel);

    @Mappings({
            @Mapping(source = "supplierBankId", target = "id")
    })
    SupplierBankModel convertBankToSupplierModel(SupplierChangeOrderBankModel supplierBankModel);

    @Mappings({

            @Mapping(source = "supplierContactsId", target = "id"),
    })
    SupplierContactsModel convertContactToSupplierModel(SupplierChangeOrderContactsModel supplierContactsModel);

    default Date parseDate(String dateString) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return format.parse(dateString);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    default BigDecimal parseBigDecimal(String taxRate) {
        if (StringUtils.isEmpty(taxRate)) {
            return null;
        }
        return new BigDecimal(taxRate);
    }

    default String formatDate(Date date) {
        SimpleDateFormat format = new SimpleDateFormat(DateUtils.YYYY_MM_DD);
        return format.format(date);
    }

    // 自定义方法用于解析日期字符串
    default LocalDate parseLocalDate(String dateString) {
        if (dateString == null) {
            return null;
        }
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(DateUtils.YYYY_MM_DD);
        try {
            LocalDateTime dateTime = LocalDateTime.parse(dateString, formatter);
            return dateTime.toLocalDate();
        } catch (Exception e) {
            return null;
        }
    }

    // 自定义方法用于解析日期字符串
    default LocalDateTime parseLocalDateTime(String dateStr) {
        if (StringUtils.isBlank(dateStr)) {
            return null;
        }

        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(DateUtils.YYYY_MM_DD_HH_MM_SS);
            return LocalDateTime.parse(dateStr, formatter);
        } catch (Exception e) {
            return null;
        }
    }
}


package com.mdgyl.hussar.basic.supplier.changeorder.converter.service;

import com.google.common.collect.Lists;
import com.jxdinfo.hussar.support.audit.plugin.mongodb.support.query.entity.Page;
import com.mdgyl.common.helper.CollectionHelper;
import com.mdgyl.common.helper.MapHelper;
import com.mdgyl.hussar.basic.enums.SupplierChangeOrderStatusEnum;
import com.mdgyl.hussar.basic.enums.SupplierStatusEnum;
import com.mdgyl.hussar.basic.model.supplier.masterdata.SupplierAddressModel;
import com.mdgyl.hussar.basic.model.supplier.masterdata.SupplierBankModel;
import com.mdgyl.hussar.basic.model.supplier.masterdata.SupplierContactsModel;
import com.mdgyl.hussar.basic.model.supplier.masterdata.SupplierModel;
import com.mdgyl.hussar.basic.model.supplier.supplierchangeorder.*;
import com.mdgyl.hussar.basic.supplier.changeorder.converter.struct.ChangeOrderMapperConverter;
import com.mdgyl.hussar.basic.supplier.changeorder.domain.*;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class ChangeOrderServiceConverter {

    public static SupplierChangeOrderModel converterModel(SupplierChangeOrderDo supplierChangeOrderDo) {
        if (supplierChangeOrderDo == null) {
            return null;
        }
        SupplierChangeOrderModel supplierChangeOrderModel = ChangeOrderMapperConverter.INSTANCE.doToModel(supplierChangeOrderDo);
        supplierChangeOrderModel.setStatus(SupplierChangeOrderStatusEnum.getDescByCode(supplierChangeOrderDo.getStatus()));
        return supplierChangeOrderModel;
    }


    public static Page<SupplierChangeOrderModel> converterModelPage(Page<SupplierChangeOrderDo> supplierChangeOrderDos) {
        if (supplierChangeOrderDos == null) {
            return new Page<SupplierChangeOrderModel>(); // 如果输入是 null，返回一个空的 Page
        }

        // 转换数据列表
        List<SupplierChangeOrderModel> modelList = supplierChangeOrderDos.getRecords().stream()
                .map(ChangeOrderServiceConverter::converterModel)
                .collect(Collectors.toList());


        // 创建并返回新的 Page<SupplierChangeOrderModel> 对象
        Page<SupplierChangeOrderModel> page = new Page<>(supplierChangeOrderDos.getCurrent(), supplierChangeOrderDos.getSize(), supplierChangeOrderDos.getTotal());
        page.setRecords(modelList);
        return page;
    }

    public static SupplierChangeOrderModel converterSupplierToChangeOrderModel(SupplierModel supplierModel) {
        if (supplierModel == null) {
            return null;
        }
        SupplierChangeOrderModel supplierChangeOrderModel = ChangeOrderMapperConverter.INSTANCE.converterSupplierToChangeOrder(supplierModel);
        SupplierStatusEnum supplierStatus = supplierModel.getStatus();
        supplierChangeOrderModel.setAddresses(CollectionHelper.collectNotNullList(supplierModel.getAddresses(), ChangeOrderMapperConverter.INSTANCE::convertAddressesModel));
        supplierChangeOrderModel.setBanks(CollectionHelper.collectNotNullList(supplierModel.getBanks(), ChangeOrderMapperConverter.INSTANCE::convertBankModel));
        supplierChangeOrderModel.setContacts(CollectionHelper.collectNotNullList(supplierModel.getContacts(), ChangeOrderMapperConverter.INSTANCE::convertContactModel));
        SupplierChangeOrderInfoModel supplierChangeOrderInfoModel = ChangeOrderMapperConverter.INSTANCE.convertOderInfoModel(supplierModel.getSupplierInfo());
        if (ObjectUtils.isEmpty(supplierChangeOrderInfoModel)) {
            supplierChangeOrderInfoModel=new SupplierChangeOrderInfoModel();
            supplierChangeOrderInfoModel.setSupplierDataId(supplierModel.getId());
        }
        supplierChangeOrderInfoModel.setSupplierStatus(supplierStatus);
        supplierChangeOrderModel.setChangeOrderInfo(supplierChangeOrderInfoModel);
        return supplierChangeOrderModel;
    }

    public static SupplierChangeOrderModel converterToChangeOrderModel(SupplierChangeOrderDo supplierChangeOrder, SupplierChangeOrderInfo changeOrderInfoDo, List<SupplierChangeOrderAddress> addresses, List<SupplierChangeOrderBank> banks, List<SupplierChangeOrderContacts> contacts) {
        if (supplierChangeOrder == null) {
            return null;
        }
        SupplierChangeOrderModel supplierChangeOrderModel = ChangeOrderMapperConverter.INSTANCE.doToModel(supplierChangeOrder);
        supplierChangeOrderModel.setAddresses(CollectionHelper.collectNotNullList(addresses, ChangeOrderMapperConverter.INSTANCE::convertAddressesDoToModel));
        supplierChangeOrderModel.setBanks(CollectionHelper.collectNotNullList(banks, ChangeOrderMapperConverter.INSTANCE::convertBankDoToModel));
        supplierChangeOrderModel.setContacts(CollectionHelper.collectNotNullList(contacts, ChangeOrderMapperConverter.INSTANCE::convertContactsDoToModel));
        supplierChangeOrderModel.setChangeOrderInfo(ChangeOrderMapperConverter.INSTANCE.converterInfoDoToModel(changeOrderInfoDo));
        return supplierChangeOrderModel;
    }


    public static SupplierChangeOrderDo converterModelToDo(SupplierChangeOrderModel supplierChangeOrderModel) {
        if (supplierChangeOrderModel == null) {
            return null;
        }
        return ChangeOrderMapperConverter.INSTANCE.converterModelToDo(supplierChangeOrderModel);
    }

    public static SupplierChangeOrderInfo converterInfoModelToDo(SupplierChangeOrderInfoModel supplierChangeOrderInfoModel) {
        if (supplierChangeOrderInfoModel == null) {
            return null;
        }
        return ChangeOrderMapperConverter.INSTANCE.converterInfoModelToDo(supplierChangeOrderInfoModel);
    }


    public static List<SupplierChangeOrderAddress> converterAddressModelToDoList(List<SupplierChangeOrderAddressModel> supplierChangeOrderAddressList) {
        if (CollectionUtils.isEmpty(supplierChangeOrderAddressList)) {
            return Lists.newArrayList();
        }
        return supplierChangeOrderAddressList.stream().map(ChangeOrderMapperConverter.INSTANCE::converterAddressModelToDo).collect(Collectors.toList());
    }

    public static List<SupplierChangeOrderBank> converterBankModelToDoList(List<SupplierChangeOrderBankModel> supplierChangeOrderBankList) {
        if (CollectionUtils.isEmpty(supplierChangeOrderBankList)) {
            return Lists.newArrayList();
        }
        return supplierChangeOrderBankList.stream().map(ChangeOrderMapperConverter.INSTANCE::converterBankModelToDo).collect(Collectors.toList());
    }

    public static List<SupplierChangeOrderContacts> converterContactsModelToDoList(List<SupplierChangeOrderContactsModel> supplierChangeOrderContactList) {
        if (CollectionUtils.isEmpty(supplierChangeOrderContactList)) {
            return Lists.newArrayList();
        }
        return supplierChangeOrderContactList.stream().map(ChangeOrderMapperConverter.INSTANCE::converterContactsModel).collect(Collectors.toList());
    }


    public static List<SupplierChangeOrderAddressModel> converterChangeOrderAddressList(List<SupplierChangeOrderAddress> addressesList) {
        if (CollectionUtils.isEmpty(addressesList)) {
            return Lists.newArrayList();
        }
        return addressesList.stream().map(ChangeOrderMapperConverter.INSTANCE::convertAddressesDoToModel).collect(Collectors.toList());
    }

    public static List<SupplierChangeOrderAddressModel> converterAddressList(List<SupplierAddressModel> addressesList) {
        if (CollectionUtils.isEmpty(addressesList)) {
            return Lists.newArrayList();
        }
        return addressesList.stream().map(ChangeOrderMapperConverter.INSTANCE::convertAddressesModel).collect(Collectors.toList());
    }


    public static List<SupplierChangeOrderBankModel> converterBankList(List<SupplierBankModel> bankList) {
        if (CollectionUtils.isEmpty(bankList)) {
            return Lists.newArrayList();
        }
        return bankList.stream().map(ChangeOrderMapperConverter.INSTANCE::convertBankModel).collect(Collectors.toList());
    }

    public static List<SupplierChangeOrderContactsModel> converterContactsList(List<SupplierContactsModel> bankList) {
        if (CollectionUtils.isEmpty(bankList)) {
            return Lists.newArrayList();
        }
        return bankList.stream().map(ChangeOrderMapperConverter.INSTANCE::convertContactModel).collect(Collectors.toList());
    }

    public static SupplierChangeOrderInfoModel converterInfoModel(SupplierChangeOrderInfo supplierInfo) {
        if (supplierInfo == null) {
            return null;
        }
        return ChangeOrderMapperConverter.INSTANCE.converterInfoDoToModel(supplierInfo);
    }

    public static List<SupplierChangeOrderContactsModel> converterChangeOrdeContactsList(List<SupplierChangeOrderContacts> contactList) {
        if (CollectionUtils.isEmpty(contactList)) {
            return Lists.newArrayList();
        }
        return contactList.stream().map(ChangeOrderMapperConverter.INSTANCE::convertContactsDoToModel).collect(Collectors.toList());
    }

    public static List<SupplierChangeOrderBankModel> converterChangeOrdeBankList(List<SupplierChangeOrderBank> banks) {
        if (CollectionUtils.isEmpty(banks)) {
            return Lists.newArrayList();
        }
        return banks.stream().map(ChangeOrderMapperConverter.INSTANCE::convertBankDoToModel).collect(Collectors.toList());
    }

    public static List<Long> getAddressDeleteIds(List<SupplierChangeOrderAddressModel> supplierAddressModels, Map<Long, SupplierChangeOrderAddressModel> addressUpdateMap) {
        // 对比出删除的现场考察数据
        return CollectionHelper.collectNotNullList(supplierAddressModels, param -> {
            Long addressId = param.getId();
            SupplierChangeOrderAddressModel supplierChangeOrderAddressModel = MapHelper.getValue(addressUpdateMap, addressId);
            if (supplierChangeOrderAddressModel == null) {
                return addressId;
            }
            return null;
        });
    }

    public static List<Long> getBankDeleteIds(List<SupplierChangeOrderBankModel> supplierBankModels, Map<Long, SupplierChangeOrderBankModel> bankUpdateMap) {

        // 对比出删除的样品检测数据
        return CollectionHelper.collectNotNullList(supplierBankModels, param -> {
            Long bankId = param.getId();
            SupplierChangeOrderBankModel supplierChangeOrderBankModel = MapHelper.getValue(bankUpdateMap, bankId);
            if (supplierChangeOrderBankModel == null) {
                return bankId;
            }
            return null;
        });
    }

    public static List<Long> getContactsDeleteIds(List<SupplierChangeOrderContactsModel> supplierContactsModels, Map<Long, SupplierChangeOrderContactsModel> contactUpdateMap) {
        // 对比出删除的资质审查数据
        return CollectionHelper.collectNotNullList(supplierContactsModels, param -> {
            Long contactsId = param.getId();
            SupplierChangeOrderContactsModel supplierChangeOrderContactsModel = MapHelper.getValue(contactUpdateMap, contactsId);
            if (supplierChangeOrderContactsModel == null) {
                return contactsId;
            }
            return null;
        });
    }

    public static SupplierModel converterChangeOrderToSupplierModel(SupplierChangeOrderModel changeOrderModel) {
        if (changeOrderModel == null) {
            return null;
        }
        SupplierModel supplierModel = ChangeOrderMapperConverter.INSTANCE.converterChangeOrderToSupplier(changeOrderModel);
        supplierModel.setStatus(changeOrderModel.getChangeOrderInfo().getSupplierStatus());
        supplierModel.setAddresses(CollectionHelper.collectNotNullList(changeOrderModel.getAddresses(), ChangeOrderMapperConverter.INSTANCE::convertAddressesToSupplierModel));
        supplierModel.setBanks(CollectionHelper.collectNotNullList(changeOrderModel.getBanks(), ChangeOrderMapperConverter.INSTANCE::convertBankToSupplierModel));
        supplierModel.setContacts(CollectionHelper.collectNotNullList(changeOrderModel.getContacts(), ChangeOrderMapperConverter.INSTANCE::convertContactToSupplierModel));
        supplierModel.setSupplierInfo(ChangeOrderMapperConverter.INSTANCE.convertOderInfoToSupplierModel(changeOrderModel.getChangeOrderInfo()));
        return supplierModel;
    }
}

小裕哥略帅
关注
MapStruct参数拷贝
只为成功找方法 不为失败找借口
06-26 321
我们上面代码里面可以看到，处理参数和返回参数都要经过不同的转换，这里面看似乎增加了不少工作量，主要是测试案例写的比较简单，真实场景中，如果你不区分，就有可能引起各种问题，如信息泄露等。所以定义了不同的层次，当然，根据需要选择。好了，上面就是基本用法了，至于更复杂的用法，推荐查看官网案例。2.添加转换接口类，可以按照不同业务写多个接口，加上注解。来拷贝对象，但是这不是完全的深拷贝，我们可以用。这上面只是简单的参数相同和集合映射的例子，我们先看看前面的部分代码。另外，上面我们使用了。
【精品】基于 MapStruct实现 JavaBean克隆及属性拷贝
哈
11-15 2641
MapStruct简介 简介 性能高 这是相对反射来说的，反射需要去读取字节码的内容，花销会比较大。而通过 MapStruct 来生成的代码，其类似于人手写。速度上可以得到保证。 用简单 如果是完全映射的，使用起来肯定没有反射简单。用类似 BeanUtils 这些工具一条语句就搞定了。但是，如果需要进行特殊的匹配（特殊类型转换，多对一转换等），其相对来说也是比较简单的。 基本上，使用的时候，我们只需要声明一个接口，接口下写对应的方法，就可以使用了。当然，如果有特殊情况，是需要额外处理的。推荐：Java进阶
使用mapstruct实现对象拷贝
前行的博客
01-26 780
【代码】使用mapstruct实现对象拷贝。
Java的属性拷贝工具类---Mapstruct
GeGe&YoYo的博客
11-14 504
Mapstruct正是在java文件到class这一步帮我们实现了转换方法，即做了预处理，提前编译好文件，如果用过lombok的同学一定能理解其好处，通过查看class文件，可以看出IPersonMapper被打上org.mapstruct.Mapper注解后，编译器自动会帮我们生成一个实现类IPersonMapperImpl，并实现了po2entity这个方法。接口中有一个常量和一个方法，常量的值是接口的实现类，这个实现类是Mapstruct默认帮我们实现的，下文会讲到。
MapStruct 对象值拷贝
廖金龙的博客
05-31 2091
介绍 前提 在Java 项目开发中，存在需要连个不同类的对象的转化的情况， 例如VO与DO 的中同一逻辑对象的值转换。 @AllArgsConstructor @Data public class UserVo { private Long id; private String username; private String password; private String phoneNum; private String email; private Ro
MapStruct 解决 Bean 属性拷贝性能问题
Java笔记虾
02-16 493
点击关注公众号，利用碎片时间学习无意间看到项目中有小伙伴用到了 MapStruct 来做对象映射转换当时我就很好奇，这个是什么框架，能够解决什么问题，带着这两个疑问就有了下面的文章。简介M...
Java对象拷贝MapStruct
lonelymanontheway的博客
06-10 2322
介绍，入门实战； Internal error in the mapping processor:NullPointerException； No target bean properties found: can't map Collection element, Consider to declare/implement a mapping method
Bean拷贝之MapStruct
水蓝
07-23 965
Bean拷贝之MapStruct
MapStruct 对象间属性复制
万物皆字节
12-11 1216
在JAVA项目开发过程中，经常会设计到对象间属性值拷贝，这种场景有多个框架或者技术可以实现，比如Spring和Apache给我们提供了BeatUtils工具，但是他的实现机制是通过反射，导致拷贝属性的花费时间较长，性能很低。 这里我们介绍一个新的框架MapStruct来实现。 ...
高效的 bean 拷贝工具：MapStruct
08-18 2991
mapper可以用接口来实现，也可以完全由抽象来完全代替/*** @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则* 在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制*/@Mapper/*** 获取该类自动生成的实现类的实例* 接口中的属性都是 public static final 的 方法都是public abstract的*//*** 这个方法就是用于实现对象属性复制的方法。
mapstruct.zip
06-03
MapStruct默认提供了基本类型的转换和深拷贝功能，并支持复杂的对象嵌套映射。 二、MapStruct的优点 1. 性能优异：MapStruct的运行时性能优于手动编写的映射代码，因为它生成的是优化过的Java字节码。 2. 易于维护...
对象拷贝-优雅的解决方案Mapstruct.docx
10-26
传统的对象属性拷贝方式如 `BeanUtils.copyProperties` 虽然简单易用，但存在一些问题： 1. **性能问题**：基于反射的拷贝方式相对较慢。 2. **灵活性不足**：对于同名字段无法进行特殊处理，这可能导致某些不希望...
推荐一款Java实体映射工具---mapstruct（csdn）————程序.pdf
12-05
MapStruct 的工作原理是基于Java的JSR 269注释处理器，它通过getter和setter方法进行字段拷贝，避免了反射带来的性能损耗。如果源对象和目标对象的字段名称相同，MapStruct会自动进行映射；对于字段名称不同的情况，...
【微服务】springboot整合对象映射工具MapStruct使用详解
congge
08-25 4352
springboot 整合 MapStruct 使用详解
IntelliJ IDEA中有什么让你相见恨晚的好用插件?
jakpopc的博客
06-22 5253
我是Jackpop，我们交个朋友吧！IntelliJ IDEA在开发者中的受欢迎程度，想必不用多说。开箱即用、功能强大，备受欢迎。虽然IDEA已经提供了丰富的功能，但是，我们仍然可以通过配置插件来满足个性化的需求。JetBrains Marketplace 上有着大量实用插件，但是，并非每个都称得上优秀。今天，就给大家精选12款非常好用的IDEA插件。命名规范对于编程语言重要，而且不同编程语言有不同的命名规范要求。有的要求驼峰命名，有的要求下划线命名。通过CamelCase这款插件，我们可以在CamelCa
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 270
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 482
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1353
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 821
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
mapstruct拷贝
09-22
mapstruct是一个Java注解处理器，可以简化对象之间的转换操作。使用mapstruct可以通过定义转换接口和注解，自动生成转换代码。在转换过程中，mapstruct会调用目标对象的setter方法和源对象的getter方法进行属性拷贝，而不是使用反射机制。这也是mapstruct具有较好性能的原因之一。 根据提供的引用内容，可以看到一个示例的OrderMapper接口，它使用@Mapper注解来标记转换接口。在该接口中，定义了一个entity2queryParam方法，用于将Order对象转换为OrderQueryParam对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值