PO封装到VO的方法，用spring、hutool、MapStruct和ModelMapper，简单转化/自定义转化

当进行PO到VO或者其他类型的转换时，可以使用第三方的映射工具类来简化代码编写，其中两个常用的工具是spring的BeanUtils.copyProperties()方法和hutool的BeanUtil.copyProperties。它们都可以帮助我们自动生成PO到VO的映射代码，从而减少手动编写转换逻辑的工作量。

spring的方式：

下面是使用spring的BeanUtils.copyProperties()进行PO到VO转换的示例：

首先，需要确保引入了Spring的依赖。

假设我们有以下的User PO类和UserVO类：

public class User {
    private Long id;
    private String username;
    private String email;
    // 其他属性和方法
    // ...
}

public class UserVO {
    private Long id;
    private String username;
    // 其他属性和方法
    // ...
}

现在我们使用BeanUtils.copyProperties()进行PO到VO的转换：

import org.springframework.beans.BeanUtils;

public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.setId(1L);
        user.setUsername("John");
        user.setEmail("john@example.com");
        // 设置其他属性...

        UserVO userVO = new UserVO();
        BeanUtils.copyProperties(user, userVO);

        System.out.println(userVO.getId());       // 输出：1
        System.out.println(userVO.getUsername()); // 输出："John"
        // 输出其他属性...
    }
}

在上述示例中，我们创建了一个新的UserVO对象，并使用BeanUtils.copyProperties()将User PO对象的属性值复制到UserVO对象中。由于UserVO和User类具有相同的属性名，因此BeanUtils.copyProperties()会自动匹配对应的属性进行复制。

使用BeanUtils.copyProperties()方法是一种非常简单和便捷的方式进行PO到VO的转换，特别适用于简单的属性拷贝场景。**spring的方法和hutool的方法类似，导入hutool依赖就行。**但需要注意，如果PO和VO类之间的属性名不完全匹配，或者存在其他复杂的转换逻辑，可能需要考虑使用更强大的映射工具，如MapStruct或ModelMapper。

第三方MapStruct和ModelMapper:

在给定的User和UserVO类中，我们可以通过MapStruct或ModelMapper来实现User到UserVO的转换。由于属性名和类型不完全匹配，我们需要使用映射注解来指定属性的映射关系。

以下是使用第三方MapStruct和ModelMapper的示例：

需求：把下面的user转化为uservo

public class User {
    private Long userId;
    private String username;
    private String email;
}

public class UserVO {
    private Integer id;
    private String name;

}

MapStruct

首先，让我们使用MapStruct来实现User到UserVO的转换：

1. 添加MapStruct的依赖。在Maven项目中，可以在pom.xml中添加如下依赖：

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct</artifactId>
    <version>1.4.2.Final</version>
</dependency>

1. 创建Mapper接口，并使用@Mapper注解标记为MapStruct的Mapper：

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

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

    @Mapping(source = "userId", target = "id")
    @Mapping(source = "username", target = "name")
    UserVO toUserVO(User user);
}

在上述代码中，我们使用@Mapper注解标记了Mapper接口，并通过@Mapping注解指定了User和UserVO之间的映射关系。userId映射到id，username映射到name。

1. 现在，我们可以进行转换：

public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.setUserId(1L);
        user.setUsername("John");
        user.setEmail("john@example.com");

        UserVO userVO = UserMapper.INSTANCE.toUserVO(user);
        System.out.println(userVO.getId());   // 输出：1
        System.out.println(userVO.getName()); // 输出："John"
    }
}

在上述代码中，我们创建了一个User对象，并设置了其属性值。然后使用UserMapper.INSTANCE.toUserVO(user)调用MapStruct生成的转换方法将User对象转换为UserVO对象，输出了转换后的结果。

ModelMapper

现在，让我们使用ModelMapper来实现User到UserVO的转换：

1. 添加ModelMapper的依赖。在Maven项目中，可以在pom.xml中添加如下依赖：

<dependency>
    <groupId>org.modelmapper</groupId>
    <artifactId>modelmapper</artifactId>
    <version>2.4.4</version>
</dependency>

1. 创建ModelMapper对象，并进行转换：

import org.modelmapper.ModelMapper;

public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.setUserId(1L);
        user.setUsername("John");
        user.setEmail("john@example.com");

        ModelMapper modelMapper = new ModelMapper();
        UserVO userVO = modelMapper.map(user, UserVO.class);

        System.out.println(userVO.getId());   // 输出：1
        System.out.println(userVO.getName()); // 输出："John"
    }
}

在上述代码中，我们创建了一个User对象，并设置了其属性值。然后使用ModelMapper对象调用modelMapper.map(user, UserVO.class)方法将User对象转换为UserVO对象，输出了转换后的结果。

无论是使用MapStruct还是ModelMapper，都能够帮助我们实现PO到VO的转换，灵活地处理属性名不匹配和属性类型不一致的情况，从而简化对象映射的过程。

用modelmapper来实现自定义映射的例子：

假设我们有以下的User类和UserVO类：

public class User {
    private Long userId;
    private String username;
    private String email;
    private Address address;
    // 其他属性和方法
    // ...
}

public class UserVO {
    private Integer id;
    private String name;
    private String emailAddress;
    private String city;
    // 其他属性和方法
    // ...
}

public class Address {
    private String city;
    private String country;
    // 其他属性和方法
    // ...
}

现在，我们使用ModelMapper来实现正确的自定义映射：

import org.modelmapper.ModelMapper;
import org.modelmapper.PropertyMap;

public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.setUserId(1L);
        user.setUsername("John");
        user.setEmail("john@example.com");
        user.setAddress(new Address("New York", "USA"));

        ModelMapper modelMapper = new ModelMapper();

        // 自定义映射规则
        modelMapper.addMappings(new PropertyMap<User, UserVO>() {
            @Override
            protected void configure() {
                map().setId(source.getUserId());
                map().setName(source.getUsername());
                map().setEmailAddress(source.getEmail());
                map().setCity(source.getAddress().getCity());
            }
        });

        UserVO userVO = modelMapper.map(user, UserVO.class);

        System.out.println(userVO.getId());          // 输出：1
        System.out.println(userVO.getName());        // 输出："John"
        System.out.println(userVO.getEmailAddress());// 输出："john@example.com"
        System.out.println(userVO.getCity());        // 输出："New York"
    }
}

在上述例子中，我们使用modelMapper.addMappings()方法创建一个PropertyMap对象，并在其中通过map().setId(), map().setName(), map().setEmailAddress()和map().setCity()方法分别指定了User类和UserVO类之间的自定义映射规则。