简化Java代码的组件 MapStruct使用

@航空母舰

已于 2023-08-28 10:58:13 修改

阅读量2.7k

点赞数 2

分类专栏： Java 文章标签： java spring maven

于 2021-02-03 13:18:53 首次发布

本文链接：https://blog.csdn.net/hudeyong926/article/details/113598813

版权

Java 专栏收录该内容

32 篇文章 0 订阅

订阅专栏

我们在实际开发过程中会出现很多bean之间的拷贝动作，这样的动作需要不停的去进行set操作。容易造成代码的耦合和维护困难。通过MapStruct我们只需要定义一个接口，这个工具包会帮我们自动生成一个实现类，并且这个类是不可编辑的，代码自动生成帮我们省去了开发维护成本同时做了一定的解耦。

MapStruct注解

@Mapper：注解在接口、类上，这样 MapStruct 才会去实现该接口
- componentModel：该属性用于指定实现类的类型，有几个属性：
  - default：默认，不使用任何组建类型，可以通过Mappers.getMapper(Class) 方式获取实例对象
  - spring：在实现类上注解 @Component，可通过 @Autowired 方式注入
  - jsr330：实现类上添加@javax.inject.Named 和@Singleton注解，可以通过 @Inject注解获取。
@Mappings：配置多个@Mapping
@Mapping：配置属性映射，若源对象属性与目标对象名字一致，会自动映射对应属性
- source：源属性、target：目标属性
- dateFormat：可将 String 到 Date 日期之间相互转换，通过 SimpleDateFormat，该值为 SimpleDateFormat 的日期格式

Maven依赖

使用MapStruct我们需要通过maven导入相关的依赖：

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-jdk8</artifactId>
    <version>1.3.0.Beta2</version> 
</dependency>

同时我们需要添加maven-compiler-plugin，其中mapstruct-processor用于构建mapper实现类的生成器。

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.5.1</version>
    <configuration>
        <source>1.8</source>
        <target>1.8</target>
        <annotationProcessorPaths>
            <path>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct-processor</artifactId>
                <version>1.3.0.Beta2</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>

@Autowired
private GoodInfoMapper goodInfoMapper;

@RequestMapping(value = "/detail/{id}")
public GoodInfoDTO details(@PathVariable("id")Long id){
    GoodInfo goodInfo = goodInfoRepository.findOne(id);
    GoodType goodType = goodTypeRepository.findOne(goodInfo.getId());
    return goodInfoMapper.fromGoodInfoDTO(goodInfo,goodType);
}

1.MapStruct是用来做什么的？

现在有这么个场景，从数据库查询出来了一个user对象（包含id，用户名，密码，手机号，邮箱，角色这些字段）和一个对应的角色对象role（包含id，角色名，角色描述这些字段），现在在controller需要用到user对象的id，用户名，和角色对象的角色名三个属性。一种方式是直接把两个对象传递到controller层，但是这样会多出很多没用的属性。更通用的方式是需要用到的属性封装成一个类(DTO)，通过传输这个类的实例来完成数据传输。
User.java

@AllArgsConstructor
@Data
public class User {
    private Long id;
    private String username;
    private String password;
    private String phoneNum;
    private String email;
    private Role role;
}

Role.java

@AllArgsConstructor
@Data
public class Role {
    private Long id;
    private String roleName;
    private String description;
}

UserRoleDto.java，这个类就是封装的类

@Data
public class UserRoleDto {
    /**
     * 用户id
     */
    private Long userId;
    /**
     * 用户名
     */
    private String name;
    /**
     * 角色名
     */
    private String roleName;
}

测试类，模拟将user对象转换成UserRoleDto对象

public class MainTest {
    User user = null;

    /**
     * 模拟从数据库中查出user对象
     */
    @Before
    public void before() {
       Role role  = new Role(2L, "administrator", "超级管理员");
       user  = new User(1L, "zhangsan", "12345", "17677778888", "123@qq.com", role);
    }

    /**
     * 模拟把user对象转换成UserRoleDto对象
     */
    @Test
    public void test1() {
        UserRoleDto userRoleDto = new UserRoleDto();
        userRoleDto.setUserId(user.getId());
        userRoleDto.setName(user.getUsername());
        userRoleDto.setRoleName(user.getRole().getRoleName());
        System.out.println(userRoleDto);
    }
}

从上面代码可以看出，通过getter、setter的方式把一个对象属性值复制到另一个对象中去还是很麻烦的，尤其是当属性过多的时候。而MapStruct就是用于解决这种问题的。

2.使用MapStruct解决上述问题

这里我们沿用User.java、Role.java、UserRoleDto.java。新建一个UserRoleConvert.java，这个来用来定义User.java、Role.java和UserRoleDto.java之间属性对应规则：
UserRoleConvert.java

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

/**
 * @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则
 *          在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制
 */
@Mapper
public interface UserRoleConvert {

    /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);

    /**
     * 这个方法就是用于实现对象属性复制的方法
     *
     * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
     *
     * @param user 这个参数就是源对象，也就是需要被复制的对象
     * @return 返回的是目标对象，就是最终的结果对象
     */
    @Mappings({
            @Mapping(source = "id", target = "userId"),
            @Mapping(source = "username", target = "name"),
            @Mapping(source = "role.roleName", target = "roleName")
    })
    UserRoleDto toUserRoleDto(User user);
}

在测试类中测试：

public class MainTest {
    User user = null;

    /**
     * 模拟从数据库中查出user对象
     */
    @Before
    public void before() {
       Role role  = new Role(2L, "administrator", "超级管理员");
       user  = new User(1L, "zhangsan", "12345", "17677778888", "123@qq.com", role);
    }

    /**
     * 模拟通过MapStruct把user对象转换成UserRoleDto对象
     */
    @Test
    public void test2() {
        UserRoleDto userRoleDto = UserRoleConvert.INSTANCES.toUserRoleDto(user);
        System.out.println(userRoleDto);
    }
}

通过上面的例子可以看出，使用MapStruct方便许多。

3.添加默认方法

添加默认方法是为了这个类（接口）不只是为了做数据转换用的，也可以做一些其他的事。将null设置成""空字符串

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

/**
 * @Mapper 将null设置成""空字符串
 */
@Mapper(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_DEFAULT,
		nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
public interface UserRoleConvert {

    /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);

    /**
     * 这个方法就是用于实现对象属性复制的方法
     *
     * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
     *
     * @param user 这个参数就是源对象，也就是需要被复制的对象
     * @return 返回的是目标对象，就是最终的结果对象
     */
    @Mappings({
            @Mapping(source = "id", target = "userId"),
            @Mapping(source = "username", target = "name"),
            @Mapping(source = "role.roleName", target = "roleName")
    })
    UserRoleDto toUserRoleDto(User user);

    /**
     * 提供默认方法，方法自己定义，这个方法是我随便写的，不是要按照这个格式来的
     * @return
     */
    default UserRoleDto defaultConvert() {
        UserRoleDto userRoleDto = new UserRoleDto();
        userRoleDto.setUserId(0L);
        userRoleDto.setName("None");
        userRoleDto.setRoleName("None");
        return userRoleDto;
    }

}

测试代码：

@Test
public void test3() {
    UserRoleConvert userRoleConvertInstances = UserRoleConvert.INSTANCES;
    UserRoleDto userRoleDto = userRoleConvertInstances.defaultConvert();
    System.out.println(userRoleDto);
}

4. 可以使用abstract class来代替接口

mapper可以用接口来实现，也可以完全由抽象来完全代替

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

/**
 * @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则
 *          在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制
 */
@Mapper
public abstract class UserRoleConvert {

    /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    public static final UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);

    /**
     * 这个方法就是用于实现对象属性复制的方法
     *
     * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
     *
     * @param user 这个参数就是源对象，也就是需要被复制的对象
     * @return 返回的是目标对象，就是最终的结果对象
     */
    @Mappings({
            @Mapping(source = "id", target = "userId"),
            @Mapping(source = "username", target = "name"),
            @Mapping(source = "role.roleName", target = "roleName")
    })
    public abstract UserRoleDto toUserRoleDto(User user);

    /**
     * 提供默认方法，方法自己定义，这个方法是我随便写的，不是要按照这个格式来的
     * @return
     */
    UserRoleDto defaultConvert() {
        UserRoleDto userRoleDto = new UserRoleDto();
        userRoleDto.setUserId(0L);
        userRoleDto.setName("None");
        userRoleDto.setRoleName("None");
        return userRoleDto;
    }

}

5.可以使用多个参数

可以绑定多个对象的属性值到目标对象中：

package com.mapstruct.demo;

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

/**
 * @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则
 *          在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制
 */
@Mapper
public interface UserRoleConvert {

    /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);

    /**
     * 这个方法就是用于实现对象属性复制的方法
     *
     * @Mapping 用来定义属性复制规则 source 指定源对象属性 target指定目标对象属性
     *
     * @param user 这个参数就是源对象，也就是需要被复制的对象
     * @return 返回的是目标对象，就是最终的结果对象
     */
    @Mappings({
            @Mapping(source = "id", target = "userId"),
            @Mapping(source = "username", target = "name"),
            @Mapping(source = "role.roleName", target = "roleName")
    })
    UserRoleDto toUserRoleDto(User user);

    /**
     * 多个参数中的值绑定 
     * @param user 源1
     * @param role 源2
     * @return 从源1、2中提取出的结果
     */
    @Mappings({
            @Mapping(source = "user.id", target = "userId"), // 把user中的id绑定到目标对象的userId属性中
            @Mapping(source = "user.username", target = "name"), // 把user中的username绑定到目标对象的name属性中
            @Mapping(source = "role.roleName", target = "roleName") // 把role对象的roleName属性值绑定到目标对象的roleName中
    })
    UserRoleDto toUserRoleDto(User user, Role role);

对比两个方法~

6.直接使用参数作为属性值

package com.mapstruct.demo;

import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Mappings;
import org.mapstruct.factory.Mappers;

/**
 * @Mapper 定义这是一个MapStruct对象属性转换接口，在这个类里面规定转换规则
 *          在项目构建时，会自动生成改接口的实现类，这个实现类将实现对象属性值复制
 */
@Mapper
public interface UserRoleConvert {

    /**
     * 获取该类自动生成的实现类的实例
     * 接口中的属性都是 public static final 的 方法都是public abstract的
     */
    UserRoleConvert INSTANCES = Mappers.getMapper(UserRoleConvert.class);

    /**
     * 直接使用参数作为值
     * @param user
     * @param myRoleName
     * @return
     */
    @Mappings({
            @Mapping(source = "user.id", target = "userId"), // 把user中的id绑定到目标对象的userId属性中
            @Mapping(source = "user.username", target = "name"), // 把user中的username绑定到目标对象的name属性中
            @Mapping(source = "myRoleName", target = "roleName") // 把role对象的roleName属性值绑定到目标对象的roleName中
    })
    UserRoleDto useParameter(User user, String myRoleName);

}

测试类：

public class Test1 {
    Role role = null;
    User user = null;

    @Before
    public void before() {
        role = new Role(2L, "administrator", "超级管理员");
        user = new User(1L, "zhangsan", "12345", "17677778888", "123@qq.com", role);
    }
    @Test
    public void test1() {
        UserRoleConvert instances = UserRoleConvert.INSTANCES;
        UserRoleDto userRoleDto = instances.useParameter(user, "myUserRole");
        System.out.println(userRoleDto);
    }
}

7.更新对象属性

在之前的例子中UserRoleDto useParameter(User user, String myRoleName);都是通过类似上面的方法来生成一个对象。而MapStruct提供了另外一种方式来更新一个对象中的属性。@MappingTarget

public interface UserRoleMapper1 {

    UserRoleMapper1 INSTANCES = Mappers.getMapper(UserRoleMapper1.class);

    @Mappings({
            @Mapping(source = "userId", target = "id"),
            @Mapping(source = "name", target = "username"),
            @Mapping(source = "roleName", target = "role.roleName")
    })
    void updateDto(UserRoleDto userRoleDto, @MappingTarget User user);


    @Mappings({
            @Mapping(source = "id", target = "userId"),
            @Mapping(source = "username", target = "name"),
            @Mapping(source = "role.roleName", target = "roleName")
    })
    void update(User user, @MappingTarget UserRoleDto userRoleDto);

}

通过@MappingTarget来指定目标类是谁（谁的属性需要被更新）。@Mapping还是用来定义属性对应规则。
以此为例说明：

 @Mappings({
            @Mapping(source = "id", target = "userId"),
            @Mapping(source = "username", target = "name"),
            @Mapping(source = "role.roleName", target = "roleName")
    })
    void update(User user, @MappingTarget UserRoleDto userRoleDto);

@MappingTarget标注的类UserRoleDto 为目标类，user类为源类，调用此方法，会把源类中的属性更新到目标类中。更新规则还是由@Mapping指定。

8.没有getter/setter也能赋值

对于没有getter/setter的属性也能实现赋值操作

public class Customer {

    private Long id;
    private String name;

    //getters and setter omitted for brevity
}

public class CustomerDto {

    public Long id;
    public String customerName;
}

@Mapper
public interface CustomerMapper {

    CustomerMapper INSTANCE = Mappers.getMapper( CustomerMapper.class );

    @Mapping(source = "customerName", target = "name")
    Customer toCustomer(CustomerDto customerDto);

    @InheritInverseConfiguration
    CustomerDto fromCustomer(Customer customer);
}

@Mapping(source = “customerName”, target = “name”)不是用来指定属性映射的，如果两个对象的属性名相同是可以省略@Mapping的。
MapStruct生成的实现类：

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2019-02-14T15:41:21+0800",
    comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
public class CustomerMapperImpl implements CustomerMapper {

    @Override
    public Customer toCustomer(CustomerDto customerDto) {
        if ( customerDto == null ) {
            return null;
        }

        Customer customer = new Customer();

        customer.setName( customerDto.customerName );
        customer.setId( customerDto.id );

        return customer;
    }

    @Override
    public CustomerDto toCustomerDto(Customer customer) {
        if ( customer == null ) {
            return null;
        }

        CustomerDto customerDto = new CustomerDto();

        customerDto.customerName = customer.getName();
        customerDto.id = customer.getId();

        return customerDto;
    }
}

@InheritInverseConfiguration在这里的作用就是实现customerDto.customerName = customer.getName();功能的。如果没有这个注解，toCustomerDto这个方法则不会有customerName 和name两个属性的对应关系的。

9.使用Spring依赖注入

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Customer {
    private Long id;
    private String name;
}

@Data
public class CustomerDto {
    private Long id;
    private String customerName;
}

// 这里主要是这个componentModel 属性，它的值就是当前要使用的依赖注入的环境
@Mapper(componentModel = "spring")
public interface CustomerMapper {

    @Mapping(source = "name", target = "customerName")
    CustomerDto toCustomerDto(Customer customer);
}

@Mapper(componentModel = “spring”)，表示把当前Mapper类纳入spring容器。可以在其它类中直接注入了：

@SpringBootApplication
@RestController
public class DemoMapstructApplication {

	// 注入Mapper
    @Autowired
    private CustomerMapper mapper;

    public static void main(String[] args) {
        SpringApplication.run(DemoMapstructApplication.class, args);
    }

    @GetMapping("/test")
    public String test() {
        Customer customer = new Customer(1L, "zhangsan");
        CustomerDto customerDto = mapper.toCustomerDto(customer);
        return customerDto.toString();
    }

}

看一下由mapstruct自动生成的类文件，会发现标记了@Component注解。

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2019-02-14T15:54:17+0800",
    comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
@Component
public class CustomerMapperImpl implements CustomerMapper {

    @Override
    public CustomerDto toCustomerDto(Customer customer) {
        if ( customer == null ) {
            return null;
        }

        CustomerDto customerDto = new CustomerDto();

        customerDto.setCustomerName( customer.getName() );
        customerDto.setId( customer.getId() );

        return customerDto;
    }
}

10.自定义类型转换

有时候，在对象转换的时候可能会出现这样一个问题，就是源对象中的类型是Boolean类型，而目标对象类型是String类型，这种情况可以通过@Mapper的uses属性来实现：

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Customer {
    private Long id;
    private String name;
    private Boolean isDisable;
}

@Data
public class CustomerDto {
    private Long id;
    private String customerName;
    private String disable;
}

定义转换规则的类：

public class BooleanStrFormat {
    public String toStr(Boolean isDisable) {
        if (isDisable) {
            return "Y";
        } else {
            return "N";
        }
    }
    public Boolean toBoolean(String str) {
        if (str.equals("Y")) {
            return true;
        } else {
            return false;
        }
    }
}

定义Mapper，@Mapper( uses = { BooleanStrFormat.class})，注意，这里的uses属性用于引用之前定义的转换规则的类：

@Mapper( uses = { BooleanStrFormat.class})
public interface CustomerMapper {

    CustomerMapper INSTANCES = Mappers.getMapper(CustomerMapper.class);

    @Mappings({
            @Mapping(source = "name", target = "customerName"),
            @Mapping(source = "isDisable", target = "disable")
    })
    CustomerDto toCustomerDto(Customer customer);
}

这样子，Customer类中的isDisable属性的true就会转变成CustomerDto中的disable属性的yes。
MapStruct自动生成的类中的代码：

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2019-02-14T16:49:18+0800",
    comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
public class CustomerMapperImpl implements CustomerMapper {

	// 引用 uses 中指定的类
    private final BooleanStrFormat booleanStrFormat = new BooleanStrFormat();

    @Override
    public CustomerDto toCustomerDto(Customer customer) {
        if ( customer == null ) {
            return null;
        }

        CustomerDto customerDto = new CustomerDto();
		// 转换方式的使用
        customerDto.setDisable( booleanStrFormat.toStr( customer.getIsDisable() ) );
        customerDto.setCustomerName( customer.getName() );
        customerDto.setId( customer.getId() );

        return customerDto;
    }
}

要注意的是，如果使用了例如像spring这样的环境，Mapper引入uses类实例的方式将是自动注入，那么这个类也应该纳入Spring容器：
CustomerMapper.java指定使用spring

转换类要加入Spring容器：

@Component
public class BooleanStrFormat {
    public String toStr(Boolean isDisable) {
        if (isDisable) {
            return "Y";
        } else {
            return "N";
        }
    }
    public Boolean toBoolean(String str) {
        if (str.equals("Y")) {
            return true;
        } else {
            return false;
        }
    }
}

MapStruct自动生成的类：

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2019-02-14T16:55:35+0800",
    comments = "version: 1.3.0.Final, compiler: javac, environment: Java 1.8.0_181 (Oracle Corporation)"
)
@Component
public class CustomerMapperImpl implements CustomerMapper {

	// 使用自动注入的方式引入
    @Autowired
    private BooleanStrFormat booleanStrFormat;

    @Override
    public CustomerDto toCustomerDto(Customer customer) {
        if ( customer == null ) {
            return null;
        }

        CustomerDto customerDto = new CustomerDto();

        customerDto.setDisable( booleanStrFormat.toStr( customer.getIsDisable() ) );
        customerDto.setCustomerName( customer.getName() );
        customerDto.setId( customer.getId() );

        return customerDto;
    }
}

类型不一致，默认值和常量

@Mapper(nullValuePropertyMappingStrategy = NullValuePropertyMappingStrategy.SET_TO_DEFAULT,
		nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
public interface UserConvert {
	UserConvert INSTANCE = Mappers.getMapper(UserConvert.class);

	Page<UserVO3> convert(Page<User> listPage);
	@Mappings({
			@Mapping(target = "createTime", source = "createTime", dateFormat = "yyyy-MM-dd HH:mm:ss"),
			@Mapping(source = "price", numberFormat = "$#.00"),
			@Mapping(target = "integerConstant", constant = "14"),
			@Mapping(target = "number", expression = "java(DettRitMapper.getLastDett(dvocRit).getNumber())"),
			@Mapping(target = "agNickName", source = "agNickname", defaultValue = ""),
	})
	UserVO3 toConvertVO3(User user);

qualifiedByName的意思就是使用这个Mapper接口中的指定的默认方法去处理这个属性的转换，而不是简单的get set

public class UserVO5 {
    /**
     * 原始通话类型 1  呼入 2 呼出
     */
    private Integer callType;

    /**
     * 原始通话类型名称 呼入 呼出
     */
    private String callTypeStr;
}

@Mapping(source = "callTypeStr", target = "callType", qualifiedByName = "callType")
UserVO5 convert(User user);

//列表
Page<UserVO5> convertList(Page<User> list);

@Named("callType") //需要起个名字，不然报错,可以与方法名一致，当然也可以不一致
default String getCallType(String value) {
    if (value == 1) {
        return "呼出";
    } else {
        return "呼入";
    }
}

注意问题

改动Convert后，需要删除包重新编译生成实现类。在代码运行的时候总报找不到实现类–java.lang.ClassNotFoundException:Cannot find implementation for xxxx于是本能想到查看注解，发现注解[@Mapper]引用的jar包是对的（org.mapstruct），再一到target/generated-sources目录下查找实现类,发现没有.原来IDEA 没有自动编译生成我们接口的实现类。用IDEA 自带的maven编译（compile）一下,这时发现目录下已经可以正常生成实现类了。执行一下命令

mvn clean compile

生成impl文件就正常运行不报错了

更新依赖

右键项目-找到maven-reload project

@航空母舰

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
简化Java代码的组件 MapStruct使用

我们在实际开发过程中会出现很多bean之间的拷贝动作，这样的动作需要不停的去进行set操作。容易造成代码的耦合和维护困难。通过MapStruct我们只需要定义一个接口，这个工具包会帮我们自动生成一个实现类，并且这个类是不可编辑的，代码自动生成帮我们省去了开发维护成本同时做了一定的解耦。Maven依赖使用MapStruct我们需要通过maven导入相关的依赖：<dependency> <groupId>org.mapstruct</groupId>
复制链接

扫一扫