原来不管是实体类对象T 还是List 还是Page 的Entity、Dto、Vo的相互转换还能怎么简单

一、始起

不知道大家在前端传递Dto到后台，是如何把Dto 转换成实体类的
也不知道大家是这么把数据库查询的Entity对象数据是如何转化成Vo数据的

刚开始对象entity 转换vo

 AuthorityAdmin entity = dao.findId()
 AuthorityAdminVo vo = new AuthorityAdminVo();
 BeanUtils.copyProperties(entity , vo);
 return vo;

刚开始对象List 转换List

   //  查询数据
   List<UserAdminVo> entityList = dao.findAll()
 
    //处理方法1 = for 循环
   List<UserAdminVo> voList = new ArrayList<>();
   userList.forEach(entity ->{
            UserAdminVo vo = new UserAdminVo();
            BeanUtils.copyProperties(entity , vo);
            voList.add(vo);
    }); 

    //处理方法2
   List<UserAdminVo> voList2 = authorityAdminPage.getContent().stream().map(item -> {
       UserAdminVoVo vo = new UserAdminVoVo();
       BeanUtils.copyProperties(item, vo);
       return vo;
   }).collect(Collectors.toList());

刚开始的 spring data Jpa 下的 Page 转换 Page

// 查询
Page<UserAdmin> userPage = userAdminServiceImpl.selectPage(........);

// List<entity> 转换List<vo>   -->  userPage .getContent() 
 List<AuthorityAdminVo> collect = userPage .getContent().stream().map(item -> {
       AuthorityAdminVo vo = new AuthorityAdminVo();
       BeanUtils.copyProperties(item, vo);
       return vo;
}).collect(Collectors.toList());

// 重新封装page
Page<V> vs = new PageImpl<>(voList, page.getPageable(), page.getTotalElements());
return vs ；

不知道大家是不是觉得很麻烦，下面我们开始创建工具类

二、创建工具类

package com.ws.ldy.base.entity;

import org.springframework.beans.BeanUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;

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

/**
 * TODO  Dto，Vo，entity 转换工具类
 *
 * @author ws
 * @mail [email protected]
 * @date 2020/2/24 0024 13:08
 */
@SuppressWarnings("all")
public class BeanDtoVoUtils<V, E> {

    /**
     * TODO  dot ,Do ,entity 相互转换
     * 同：BeanUtils.copyProperties(dtoEntity, newInstance);
     *
     * @param oldClass 原数据--Dto，Vo，entity
     * @param newClass 转换为--Dto，Vo，entity
     * @return
     */
    public static <E> E convert(Object oldClass, Class<E> newClass) {
        // 判断oldClass 是否为空!
        if (oldClass == null) {
            return null;
        }
        // 判断newClass 是否为空
        if (newClass == null) {
            return null;
        }
        try {
            // 创建新的对象实例
            E newInstance = newClass.newInstance();
            // 把原对象数据拷贝到新的对象
            BeanUtils.copyProperties(oldClass, newInstance);
            // 返回新对象
            return newInstance;
        } catch (Exception e) {
            return null;
        }
    }



    //TODO  Page<Entity> 分页对象转 Page<Vo>  ( list 循环)
    public static <T, V> Page<V> pageVo(Page<T> page, Class<V> v) {
        try {
            List<T> tList = page.getContent();
            List<V> voList = new ArrayList<>();
            for (T t : tList) {
                V newv = (V) BeanDtoVoUtils.convert(t, v.newInstance().getClass());
                voList.add(newv);
            }
            Page<V> vs = new PageImpl<>(voList, page.getPageable(), page.getTotalElements());
            return vs;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    //TODO  Page<Entity> 分页对象转 Page<Vo> （Stream 方式）
    public static  <T, V> Page<V> pageVoStream(Page<T> page, Class<V> v) {
        List<V> voList = page.getContent().stream().map(item -> {
            try {
                return (V) BeanDtoVoUtils.convert(item, v.newInstance().getClass());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return null;
        }).collect(Collectors.toList());
        Page<V> vs = new PageImpl<>(voList, page.getPageable(), page.getTotalElements());
        return vs;
    }


    //TODO  list<Entity> 集合对象转list<Vo> ( list 循环)
    public static <T, V> List<V> listVo(List<T> oldList, Class<V> v) {
        try {
            List<V> voList = new ArrayList<>();
            for (T t : oldList) {
                V newv = (V) BeanDtoVoUtils.convert(t, v.newInstance().getClass());
                voList.add(newv);
            }
            return voList;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    //TODO  list<Entity> 集合对象转list<Vo> （Stream 方式）
    public static <T, V> List<V> listVoStream(List<T> oldList, Class<V> v) {
        List<V> voList = oldList.stream().map(item -> {
            try {
                return (V) BeanDtoVoUtils.convert(item, v.newInstance().getClass());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return null;
        }).collect(Collectors.toList());
        return voList;
    }
}

把工具类的方法封装到BaseController （非必需）

  /**
     * TODO  dot ,Do ,entity 相互转换
     * 同：BeanUtils.copyProperties(dtoEntity, newInstance);
     *
     * @param oldClass 原数据--Dto，Vo，entity
     * @param newClass 转换为--Dto，Vo，entity
     * @return
     */
    public <E> E convert(Object oldClass, Class<E> newClass) {
        return BeanDtoVoUtils.convert(oldClass, newClass);
    }


    //TODO  Page<Entity> 分页对象转 Page<Vo>  ( list 循环)
    public <T, V> Page<V> pageVo(Page<T> page, Class<V> v) {
        return BeanDtoVoUtils.pageVo(page, v);
    }


    //TODO  Page<Entity> 分页对象转 Page<Vo> （Stream 方式）
    public <T, V> Page<V> pageVoStream(Page<T> page, Class<V> v) {
        return BeanDtoVoUtils.pageVoStream(page, v);
    }


    //TODO  list<Entity> 集合对象转list<Vo> ( list 循环)
    public <T, V> List<V> listVo(List<T> oldList, Class<V> v) {
        return BeanDtoVoUtils.listVo(oldList, v);
    }


    //TODO  list<Entity> 集合对象转list<Vo> （Stream 方式）
    public <T, V> List<V> listVoStream(List<T> oldList, Class<V> v) {
        return BeanDtoVoUtils.listVoStream(oldList, v);
    }

三、使用工具类

Page与List 通过 Stream 方式与 循环方式进行转换

API	参数说明	返回值
BeanDtoVoUtils.convert(Object oldClass, Class newClass)	原对象，转换后类对象	接收类
BeanDtoVoUtils.pageVo(Page page, Class v)	原对象page，转换后类对象	Page<转换后类对象>
BeanDtoVoUtils.listVo(List oldList, Class v)	原对象List	List<转换后类对象>
BeanDtoVoUtils.pageVoStream(Page page, Class v)	原对象page，转换后类对象	Page<转换后类对象>
BeanDtoVoUtils listVoStream(List oldList, Class v)	原对象List	List<转换后类对象>

list展示

page展示