参考：https://blog.csdn.net/segegefe/article/details/123942010

方式一: 利用FastJson 把对象转化为Map

引入依赖

  1.  <!--操作JSON字符串-->
  2.         <dependency>
  3.             <groupId>com.alibaba</groupId>
  4.             <artifactId>fastjson</artifactId>
  5.             <version>1.2.80</version>
  6.         </dependency>
  1.  @Override
  2.     public List<Map> getTreeMenu(VueMenu vueMenu) {
  3.         List<Map> list = new ArrayList<>();
  4.         //构造条件构造器
  5.         LambdaQueryWrapper<VueMenu> lqw = new LambdaQueryWrapper();
  6.         //添加过滤条件
  7.         lqw.eq(VueMenu::getTjclass, 1);
  8.         lqw.eq(VueMenu::getParent, vueMenu.getId());
  9.         lqw.orderByAsc(VueMenu::getSortnum);
  10.         //查询出符合条件的菜单数据多条
  11.         List<VueMenu> vueMenus = vueMenuMapper.selectList(lqw);
  12.         if (vueMenus.size() > 0) {
  13.             vueMenus.forEach(item -> {
  14.                 Map<String, Object> map = new HashMap<String, Object>();
  15.                 //Java对象转JSON字符串
  16.                 String json = JSON.toJSONString(item);
  17.                 log.info("json字符串：{}", json);
  18.                 //把JSON字符串转成JSON对象，再传给map
  19.                 map = JSON.parseObject(json);
  20.                 //递归调用
  21.                 List<Map> treeMenu = getTreeMenu(item);
  22.                 //如果递归有值，则把值传给“children”key，并put到map中
  23.                 if (treeMenu != null) map.put("children", treeMenu);
  24.                 System.out.println("map = " + map);
  25.                 //添加到List集合中
  26.                 list.add(map);
  27.             });
  28.         }
  29.         return list;
  30.     }

方式二: 利用反射进行转换

  1. public class BeanMapUtilByReflect {
  3.     /**
  4.      * 对象转Map
  5.      * @param object
  6.      * @return
  7.      * @throws IllegalAccessException
  8.      */
  9.     public static Map beanToMap(Object object) throws IllegalAccessException {
  10.         Map<String, Object> map = new HashMap<String, Object>();
  11.         Field[] fields = object.getClass().getDeclaredFields();
  12.         for (Field field : fields) {
  13.             field.setAccessible(true);
  14.             map.put(field.getName(), field.get(object));
  15.         }
  16.         return map;
  17.     }
  19.     /**
  20.      * map转对象
  21.      * @param map
  22.      * @param beanClass
  23.      * @param <T>
  24.      * @return
  25.      * @throws Exception
  26.      */
  27.     public static <T> T mapToBean(Map map, Class<T> beanClass) throws Exception {
  28.         T object = beanClass.newInstance();
  29.         Field[] fields = object.getClass().getDeclaredFields();
  30.         for (Field field : fields) {
  31.             int mod = field.getModifiers();
  32.             if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
  33.                 continue;
  34.             }
  35.             field.setAccessible(true);
  36.             if (map.containsKey(field.getName())) {
  37.                 field.set(object, map.get(field.getName()));
  38.             }
  39.         }
  40.         return object;
  41.     }
  42. }

Map转Java对象

先把map转换成JSON字符串，再通过JSON字符串解析成JAVA对象