spring boot 使用net.sf.dozer进行entity和dto、vo 实体类、集合之间的转换（不支持jdk1.8的日期类型转换，需要支持的看最后的）

需要注意：

• net.sf.dozer是一个很方便的bean映射工具包，可以很轻松地做到两个bean对象的属性值复制，但是dozer包在2014年的时候停止更新了，

• 而jdk1.8也是2014年发布的，所以对于java8中的新日期的映射关系并没有在dozer中配置，在Java8里面新出来了一些API，如LocalDate、LocalTime、LocalDateTime非常好用

• 而在项目中jdk使用了1.8，在使用了LocalDateTime类型设置日期的时候，即使两个bean对象都是相同的LocalDateTime，使用net.sf.dozer的api，即DozerBeanMapper.map()方法进行日期类映射的时候，是会报错的：java.lang.NoSuchMethodException:

• java.time.LocalDateTime.()，如果继续使用dozer的话解决这个问题很麻烦

• 默认的情况下，在mybatis也不支持java8的时间、日期。直接使用会报错**

首先需要在项目的pom.xml文件中添加以下依赖包：

 <dependency>
	 <groupId>net.sf.dozer</groupId>
	 <artifactId>dozer-spring</artifactId>
	 <version>5.5.1</version>
</dependency>
<dependency>
	 <groupId>net.sf.dozer</groupId>
	 <artifactId>dozer</artifactId>
	 <version>5.5.1</version>
</dependency>

转换工具类：

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

import org.dozer.DozerBeanMapper;
import org.dozer.Mapper;

public class EntityConvertDtoAndVOUtils {

	private static Mapper mapper = new DozerBeanMapper();

	public static <D, E> E convertBean(D t, Class<E> clazz) {
		if (t == null) {
			return null;
		}
		return mapper.map(t, clazz);
	}

	/**
	 * 实例数组之间转换
	 */
	public static <D, E> List<E> convertArray(D[] ts, Class<E> clazz) {
		List<E> es = new ArrayList<E>();
		if (ts == null) {
			return es;
		}
		for (D d : ts) {
			E e = (E) convertBean(d, clazz);
			if (e != null)
				es.add(e);
		}

		return es;
	}

	/**
	 * List集合之间转换
	 */
	public static <D, E> List<E> convertList(List<D> ts, Class<E> clazz) {
		List<E> es = new ArrayList<E>();
		if (ts == null) {
			return es;
		}
		for (D d : ts) {
			E e = (E) convertBean(d, clazz);
			if (e != null)
				es.add(e);
		}
		return es;
	}
}

import org.dozer.Mapper;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

/**
 * dozer 转换器
 */
@Component
public class GeneralConvertorUtils {

	@Resource
	Mapper mapper;

	/**
	 * List 实体类 转换器
	 *
	 * @param source 原数据
	 * @param clz    转换类型
	 * @param <T>
	 * @param <S>
	 * @return
	 */
	public <T, S> List<T> convertor(List<S> source, Class<T> clz) {
		if (source == null)
			return null;
		List<T> map = new ArrayList<>();
		for (S s : source) {
			map.add(mapper.map(s, clz));
		}
		return map;
	}

	/**
	 * Set 实体类 深度转换器
	 *
	 * @param source 原数据
	 * @param clz    目标对象
	 * @param <T>
	 * @param <S>
	 * @return
	 */
	public <T, S> Set<T> convertor(Set<S> source, Class<T> clz) {
		if (source == null)
			return null;
		Set<T> set = new TreeSet<>();
		for (S s : source) {
			set.add(mapper.map(s, clz));
		}
		return set;
	}

	/**
	 * 实体类 深度转换器
	 *
	 * @param source
	 * @param clz
	 * @param <T>
	 * @param <S>
	 * @return
	 */
	public <T, S> T convertor(S source, Class<T> clz) {
		if (source == null)
			return null;
		return mapper.map(source, clz);
	}

	public void convertor(Object source, Object object) {
		mapper.map(source, object);
	}

	public <T> void copyConvertor(T source, Object object) {
		mapper.map(source, object);
	}

}

/**
调用如下：
@Service
public class UsersService{
    @Resource
    GeneralConvertorUtils convertorUtils;
    
    @Override
    public List<UsersDTO> findAll() {
        List<Users> list = usersMapper.findAll();
        //关键代码
        List<UsersDTO> usersDTO =convertorUtils.convertor(list, UsersDTO.class);
        return usersDTO ;
    }
}
*/

具体使用如下：
//下面两段代码是将entity转换成dto；分别是单个对象转换和集合对象转换；一般用于向consumer提供数据。

//user是entity，从数据库中获取的对象
UserEnity user = new UserEntity();
EntityConvertDtoAndVOUtils.convertBean(user, UserDTO.class);
 

//userList是List集合，里面的对象是UserEntity的实例
List<UserEntity> userList = new ArrayList<>();
List<UserDTO> userDTOs = (List<UserDTO>)EntityConvertDtoAndVOUtils.convertList(userList,  UserDTO.class);

//下面例子是dto转entity，一般用于向provider传入对象

UserDTO userDto = new UserDTO();
UserEntity userEntity = (UserEntity)EntityConvertDtoAndVOUtils.convertBean(userDto, UserEntity.class);//将userDto转换成userEntity 

List<UserDTO> userDTOs= new ArrayList<>();
List<UserEntity> users = DtoEntityUtil.trans(userDtOs, UserEntity.class);//将dto集合userDTOs转换成entityList users

以上的映射工具不支持jdk1.8的新api

引入包：

dependency>
	<groupId>com.github.dozermapper</groupId>
	<artifactId>dozer-spring-boot-starter</artifactId>
	<version>6.5.2</version>
</dependency>

支持jdk1.8的新日期类型，如LocalDateTime的映射

package com.management.hospital.utils;

import com.github.dozermapper.core.DozerBeanMapperBuilder;
import com.github.dozermapper.core.Mapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.lang.NonNull;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 *
 * dozer转换类  （支持jdk1.8的新日期类型，如LocalDateTime的映射）
 *
 * net.sf.dozer是一个很方便的bean映射工具包，可以很轻松地做到两个bean对象的属性值复制，但是dozer包在2014年的时候停止更新了，
 * 而jdk1.8也是2014年发布的，所以对于java8中的新日期的映射关系并没有在dozer中配置，在Java8里面新出来了一些API，如LocalDate、LocalTime、LocalDateTime
 * 非常好用，而在项目中jdk使用了1.8，在使用了LocalDateTime类型设置日期的时候，即使两个bean对象都是相同的LocalDateTime，使用dozer的api，即DozerBeanMapper.map()方法进行日期类映射的时候，是会报错的：java.lang.NoSuchMethodException:
 * java.time.LocalDateTime.<init>()，如果继续使用dozer的话解决这个问题很麻烦
 * 
 * 默认的情况下，在mybatis也不支持java8的时间、日期。直接使用会报错
 *
 * 
 */
@Component
public class DozerConvertorUtils {

	/**
	 * dozer转换的核心mapper对象
	 */
	private static Mapper dozerMapper;

	@Autowired
	private Mapper mapper;

	@PostConstruct
	private void construct() {
		DozerConvertorUtils.setDozerMapper(mapper);
	}

	private static void setDozerMapper(Mapper dozerMapper) {
		DozerConvertorUtils.dozerMapper = dozerMapper;
	}

	@Bean
	public Mapper dozerBeanMapper() {
		return DozerBeanMapperBuilder.buildDefault();
	}

	/**
	 * 转换实体为另一个指定的实体 任意一个参数为NULL时 会抛出NPE
	 * {@link com.github.dozermapper.core.util.MappingValidator#validateMappingRequest}
	 *
	 * @param source 源实体 不能为NULL
	 * @param clazz  目标实体 不能为NULL
	 * @param <T>    泛型
	 * @return 转换后的结果
	 */
	@NonNull
	public static <T> T convert(@NonNull Object source, @NonNull Class<T> clazz) {
		return dozerMapper.map(source, clazz);
	}

	/**
	 * 转换List实体为另一个指定的实体 source如果为NULL 会使用空集合 在目标实体为NULL时 会抛出NPE
	 * {@link com.github.dozermapper.core.util.MappingValidator#validateMappingRequest}
	 *
	 * @param source 源集合 可以为NULL
	 * @param clazz  目标实体 不能为NULL
	 * @param <T>    泛型
	 * @return 转换后的结果
	 */
	@Nullable
	public static <T> List<T> convert(@Nullable List<?> source, @NonNull Class<T> clazz) {
		return Optional.ofNullable(source).orElse(Collections.emptyList()).stream()
				.map(bean -> dozerMapper.map(bean, clazz)).collect(Collectors.toList());
	}
}