JAVABEAN递归转MAP实现

最新推荐文章于 2024-07-31 04:31:57 发布
最新推荐文章于 2024-07-31 04:31:57 发布
阅读量452 收藏
点赞数
分类专栏： 随笔

public class ObjectToMap{
    
    public static Map objectToMap(Object obj){
        try{
            Class type = obj.getClass();
            Map returnMap = new HashMap();
            BeanInfo beanInfo = Introspector.getBeanInfo(type);

            PropertyDescriptor[] propertyDescriptors =  beanInfo.getPropertyDescriptors();
            for (int i = 0; i< propertyDescriptors.length; i++) {
                PropertyDescriptor descriptor = propertyDescriptors[i];
                String propertyName = descriptor.getName();
                if (!propertyName.equals("class")) {
                    Method readMethod = descriptor.getReadMethod();
                    Object result = readMethod.invoke(obj, new Object[0]);
                    if(result == null){
                        continue;
                    }
                    //判断是否为 基础类型 String,Boolean,Byte,Short,Integer,Long,Float,Double
                    //判断是否集合类，COLLECTION,MAP              
                    if(result instanceof String
                            || result instanceof Boolean
                            || result instanceof Byte
                            || result instanceof Short
                            || result instanceof Integer
                            || result instanceof Long
                            || result instanceof Float
                            || result instanceof Double
                            || result instanceof Enum
                            ){
                        if (result != null) {
                            returnMap.put(propertyName, result);
                        }
                    }else if(result instanceof Collection){                        
                        Collection<?> lstObj = arrayToMap((Collection<?>)result);
                        returnMap.put(propertyName, lstObj);
                                
                    }else if(result instanceof Map){
                        Map<Object,Object> lstObj = mapToMap((Map<Object,Object>)result);
                        returnMap.put(propertyName, lstObj);
                    } else {
                        Map mapResult = objectToMap(result);
                        returnMap.put(propertyName, mapResult);
                    }
                    
                }
            }
            return returnMap;
        }catch(Exception e){
            throw new RuntimeException(e);
        }
        
    }    
    
    private static Map<Object, Object> mapToMap(Map<Object, Object> orignMap) {
        Map<Object,Object> resultMap = new HashMap<Object,Object>();
        for(Entry<Object, Object> entry:orignMap.entrySet()){
            Object key = entry.getKey();
            Object resultKey = null;
            if(key instanceof Collection){
                resultKey = arrayToMap((Collection)key);
            }else if(key instanceof Map){
                resultKey = mapToMap((Map)key);
            }
            else{
                if(key instanceof String
                        || key instanceof Boolean
                        || key instanceof Byte
                        || key instanceof Short
                        || key instanceof Integer
                        || key instanceof Long
                        || key instanceof Float
                        || key instanceof Double
                        || key instanceof Enum
                        ){
                    if (key != null) {
                        resultKey = key;
                    }
                }else{
                    resultKey = objectToMap(key);
                }                
            }
            

            Object value = entry.getValue();
            Object resultValue = null;
            if(value instanceof Collection){
                resultValue = arrayToMap((Collection)value);
            }else if(value instanceof Map){
                resultValue = mapToMap((Map)value);
            }
            else{
                if(value instanceof String
                        || value instanceof Boolean
                        || value instanceof Byte
                        || value instanceof Short
                        || value instanceof Integer
                        || value instanceof Long
                        || value instanceof Float
                        || value instanceof Double
                        || value instanceof Enum
                        ){
                    if (value != null) {
                        resultValue = value;
                    }
                }else{
                    resultValue = objectToMap(value);
                }                
            }
            
            resultMap.put(resultKey, resultValue);
        }        
        return resultMap;
    }


    private static Collection arrayToMap(Collection lstObj){
        ArrayList arrayList = new ArrayList();
        
        for (Object t : lstObj) {
            if(t instanceof Collection){
                Collection result = arrayToMap((Collection)t);
                arrayList.add(result);
            }else if(t instanceof Map){
                Map result = mapToMap((Map)t);
                arrayList.add(result);
            } else {
                if(t instanceof String
                        || t instanceof Boolean
                        || t instanceof Byte
                        || t instanceof Short
                        || t instanceof Integer
                        || t instanceof Long
                        || t instanceof Float
                        || t instanceof Double
                        || t instanceof Enum
                        ){
                    if (t != null) {
                        arrayList.add(t);
                    }
                }else{
                    Object result = objectToMap(t);
                    arrayList.add(result);    
                }                
            }
        }
        return arrayList;
    }
    
}

 

 

 

/**
 * 将Object对象转换为Map对象
 * @param obj
 * @return
 * @throws Exception
 */
public static Object objectToMap(Object obj) throws Exception {
    if (obj == null) {
        return null;
    }

    Map<String, Object> map = new HashMap<String, Object>();
    if (!isBaseType(obj)) {
        if (obj.getClass().equals(java.util.List.class) || obj.getClass().equals(java.util.ArrayList.class)) {
            List list=new ArrayList();
            for (int i = 0; i < ((List) obj).size(); i++) {
                Object tmp = ((List) obj).get(i);
                if (isBaseType(tmp)) {
                    list.add(tmp);
                } else {
                    list.add(objectToMap(tmp));
                }

            }
            return list;
        } else if(obj.getClass().equals(java.util.Map.class)|| obj.getClass().equals(java.util.LinkedHashMap.class) || obj.getClass().equals(java.util.HashMap.class)){
            for (Map.Entry<String, Object> entry : ((Map<String, Object>)obj).entrySet()) {
                System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
                if (isBaseType(entry.getValue())) {
                    map.put(entry.getKey() + "", entry.getValue());
                } else {
                    map.put(entry.getKey() + "", objectToMap(entry.getValue()));
                }
            }
        }else {
            Field[] declaredFields = obj.getClass().getDeclaredFields();
            for (Field field : declaredFields) {
                Object tmp = getFieldValueByName(field.getName(), obj);
                if (isBaseType(tmp)) {
                    field.setAccessible(true);
                    map.put(field.getName(), field.get(obj));
                } else {
                    map.put(field.getName(), objectToMap(tmp));

                }
            }
            map.put("class", obj.getClass().getName());
        }
    }else{
        return obj;
    }
    return map;
}

public static boolean isBaseType(Object object) {
    if (object != null) {
        Class className = object.getClass();
        if (className.equals(java.lang.Integer.class) ||
                className.equals(java.lang.Byte.class) ||
                className.equals(java.lang.Long.class) ||
                className.equals(java.lang.Double.class) ||
                className.equals(java.lang.Float.class) ||
                className.equals(java.lang.Character.class) ||
                className.equals(java.lang.Short.class) ||
                className.equals(java.lang.Boolean.class)||
                className.equals(java.math.BigDecimal.class)||
                className.equals(java.lang.String.class)||
                className.equals(java.lang.Integer.class)) {
            return true;
        }
        return false;
    }
    return true;
}

/**
 * 根据属性名获取属性值   *
 */
private static Object getFieldValueByName(String fieldName, Object o) {
    String firstLetter = fieldName.substring(0, 1).toUpperCase();
    String getter = "get" + firstLetter + fieldName.substring(1);
    Object value = null;
    try {
        Method method = o.getClass().getMethod(getter, new Class[]{});
        value = method.invoke(o, new Object[]{});
    } catch (Exception e) {
        getFieldValueByIsName(fieldName, o);
    }
    return value;
}

/**
 * 根据属性名获取属性值   *
 */
private static Object getFieldValueByIsName(String fieldName, Object o) {
    String firstLetter = fieldName.substring(0, 1).toUpperCase();
    String getter = "is" + firstLetter + fieldName.substring(1);
    Object value = null;
    try {
        Method method = o.getClass().getMethod(getter, new Class[]{});
        value = method.invoke(o, new Object[]{});
    } catch (Exception e) {
        getFieldValueByGetName(fieldName, o);
    }
    return value;
}

/**
 * 根据属性名获取属性值   *
 */
private static Object getFieldValueByGetName(String fieldName, Object o) {
    String getter = "get" + fieldName;
    Object value = null;
    try {
        Method method = o.getClass().getMethod(getter, new Class[]{});
        value = method.invoke(o, new Object[]{});
    } catch (Exception e) {
        e.printStackTrace();
    }
    return value;
}
bei_fang_du_lang
关注
专栏目录
javabean与map的转换
qq_43526183的博客
07-25 1493
javabean与map的转换
巨坑系列：Java Bean 转 Map 的坑要注意
m0_73493267的博客
09-07 616
Java Bean 转 Map 的坑很多，最常见的就是类型丢失和属性名解析错误的问题。平时使用某些框架时，多写一些 DEMO 进行验证，多读源码，多调试，少趟坑。关键代码：net.sf.cglib.core.ReflectUtils#getBeanGetters 底层也会用到 java.beans.Introspector#decapitalize 所以属性名存在一样的问题就不足为奇了。（2）在某些场景下，Map 的 key 并非和属性名完全对应，像是通过 get set 方法“推断”出来的属性名。
java Bean转Map
运维工程师(Sun Robin)
11-26 746
代码如下： import java.beans.BeanInfo; import java.beans.IntrospectionException; import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.InvocationTargetException;
java的bean转成map
最新发布
weixin_36956807的博客
07-31 109
给大家整理了一些有关【Java,AP】的项目学习资料（附讲解～～）：https://edu.51cto.com/course/35714.htmlhttps://edu.51cto.com/course/19064.htmlJava Bean 转 Map 实现指南 作为一名刚入行的开发者，你可能会遇到需要将 Java ...
java bean 转 map
weixin_35750747的博客
12-30 903
可以使用 java.beans.Introspector 类的 getBeanInfo() 方法来获取 java bean 的属性描述器，然后使用 PropertyDescriptor 类的 getReadMethod() 方法获取属性的 getter 方法，最后调用 getter 方法获取属性值并存储到 map 中。 具体实现如下： import java.beans.BeanInfo; imp...
JavaBean对象转map
Mungo的专栏
08-17 1210
可能会常用的方法，利用反射将javaBean转换为map，稍作修改即可转为想要的其他对象。
Java基础：实现Bean转Map
热门推荐
天涯共明月的博客
06-29 1万+
Java Bean 转 Map 目录Java Bean 转 Map1、Apache commons-beanutils 方式2、Fastjson 方式3、Spring Cglib 方式4、Java 内省机制 的 方式 项目中经常遇到需要实现 Java bean转Map，比如：调用第三方接口传参等 总结了几种方式实现： apache commons-beanutils 方式 fastjson 方式 spring cglib 方式 java 内省机制 的 方式 1、Apache commons-be
Java Bean 转 Map 的巨坑，注意了！！！
Moonxiyue的博客
07-29 723
如使用fastjson，当属性为Long类型但数字小于Integer最大值时，反序列成Map之后，将变为Integer类型。（2）在某些场景下，Map的key并非和属性名完全对应，像是通过getset方法“推断”出来的属性名。JavaBean转Map的坑很多，最常见的就是类型丢失和属性名解析错误的问题。平时使用某些框架时，多写一些DEMO进行验证，多读源码，多调试，少趟坑。如果想严格和属性保持一致，可以使用反射获取属性名和属性值，加缓存机制提升解析的效率。...
Dozer一个JavaBean至JavaBean映射器
08-07
**Dozer：JavaBean到JavaBean的映射神器** Dozer是Java开发中的一款强大工具，主要用于Java Bean之间的数据映射。它简化了在不同对象模型之间传递数据的过程，尤其在处理复杂对象结构时，其功能显得尤为重要。Dozer...
rest接口访问webService soap接口 用XStream javabean和xml的互转
hzhahsz的博客
06-22 2134
创建javabean ,RequestCommonFPKJ@XStreamAlias("REQUEST_COMMON_FPKJ") public class RequestCommonFPKJ { @XStreamAsAttribute    //子元素作为标签属性出现 @XStreamAlias("class")    //标签别名 private String cla...
Bean与Map转换工具类BeanMapConverter.java
06-09
Bean与MAP间互转换的工具类。 1.将一个 Map 对象转化为一个 JavaBean，可指定BEAN的类型； 2.将一个 JavaBean 对象转化为一个 HashMap；
java Map转Bean Bean转Map Map排序
04-19
java Map转Bean Bean转Map Map排序
javaBean转map javaBeanToMap
libing666666的博客
05-31 270
package com.umfwechat.util; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Map; public class SaasPropertyUtil { /** * 将一个类查询方式加入map * */ public static Map<String, String> java
java bean 转 map_JavaBean和Map的相互转换
weixin_29356575的博客
02-12 934
JavaBean和Map的相互转换一、JavaBean1.什么是JavaBean？JavaBean其实就是一种遵循特定写法的类，必须遵循一定的规范：类必须由public修饰，并且保证有公共的无参数的构造器包含操作属性的的public方法，getter setter方法字段是私有的一个JavaBean是由3部分组成，分别是属性、方法、和事件。注意这里的属性是property，表示的是状态，并不是字段...
java bean转map
qq_39922867的博客
12-24 129
public static <T> Map<String,Object> beanToMap(T bean){ Map<String,Object> map = new HashMap<>(16); if(bean != null){ BeanMap beanMap = BeanMap.cre...
利用BeanMap进行对象与Map的相互转换
JIESA的专栏
11-01 5363
javabean与map的转换有很多种方式，比如: 1、通过ObjectMapper先将bean转换为json，再将json转换为map，但是这种方法比较绕，且效率很低，经测试，循环转换10000个bean，就需要12秒！！！不推荐使用 2、通过java反射，获取bean类的属性和值，再转换到map对应的键值对中，这种方法次之，但稍微有点麻烦 3、通过net.sf.cglib.b
java bean 转 map_javabean转换为map对象
weixin_42361796的博客
02-21 147
在调用第三方接口发现对方使用map进行接收(不包括秘钥等)，将bean类属性转换为map，直接贴代码：/*** JavaBean对象转化成Map对象** @param javaBean*/public static Map java2Map(Object javaBean) {Map map = new HashMap(16);try {// 获取javaBean属性BeanInfo beanIn...
java 实体bean 转map
萌萌的土拨鼠
07-02 277
/** * javaBean 转 Map * * @param target 所要的结果集 * @param source 数据来源 * @param c 数据来源 Class * @throws IntrospectionException * @throws InvocationTargetException * @throws IllegalAccessException */ private void beanToMap(Map<String, Object&gt.
java8list集合javabean怎么转map
05-11
可以使用 Java 8 中的流 (Stream) 来将 List 集合中的 JavaBean 转换为 Map，代码如下： ```java import java.util.List; import java.util.Map; import java.util.stream.Collectors; public class JavaBeanToMap...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值