精华内容
下载资源
问答
  • java中map和对象互转工具

    万次阅读 热门讨论 2019-01-05 13:33:41
    在项目开发中,经常碰到map实体对象或者对象转map的场景,工作中,很多时候我们可能比较喜欢使用第三方jar包的API对他们进行转化,而且用起来也还算方便,比如像fastJson就可以轻松实现map和对象互转,但这里,...

    在项目开发中,经常碰到map转实体对象或者对象转map的场景,工作中,很多时候我们可能比较喜欢使用第三方jar包的API对他们进行转化,而且用起来也还算方便,比如像fastJson就可以轻松实现map和对象的互转,但这里,我想通过反射的方式对他们做转化,也算是对反射的学习和研究吧;

    1、map转对象;
    主要思路,将map中的key-value取出来,然后和给定的对象去匹配,为了使工具方法更具通用性,直接通过反射的方式将给定对象的属性获取到,然后调用反射相关的API和map中的key-value进行匹配即可,下面直接上代码,

    /**
    	 * 利用反射将map集合封装成bean对象
    	 * 
    	 * @param params
    	 * @param clazz
    	 * @return
    	 */
    	public static <T> T mapToBean(Map<String, Object> map, Class<?> clazz) throws Exception {
    		Object obj = clazz.newInstance();
    		if (map != null && !map.isEmpty() && map.size() > 0) {
    			for (Map.Entry<String, Object> entry : map.entrySet()) {
    				String propertyName = entry.getKey(); 	// 属性名
    				Object value = entry.getValue();		// 属性值
    				String setMethodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
    				Field field = getClassField(clazz, propertyName);	//获取和map的key匹配的属性名称
    				if (field == null){
    					continue;
    				}
    				Class<?> fieldTypeClass = field.getType();
    				value = convertValType(value, fieldTypeClass);
    				try {
    					clazz.getMethod(setMethodName, field.getType()).invoke(obj, value);
    				} catch (NoSuchMethodException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    		return (T) obj;
    	}
    
    	/**
    	 * 根据给定对象类匹配对象中的特定字段
    	 * @param clazz
    	 * @param fieldName
    	 * @return
    	 */
    	private static Field getClassField(Class<?> clazz, String fieldName) {
    		if (Object.class.getName().equals(clazz.getName())) {
    			return null;
    		}
    		Field[] declaredFields = clazz.getDeclaredFields();
    		for (Field field : declaredFields) {
    			if (field.getName().equals(fieldName)) {
    				return field;
    			}
    		}
    		Class<?> superClass = clazz.getSuperclass();	//如果该类还有父类,将父类对象中的字段也取出
    		if (superClass != null) {						//递归获取
    			return getClassField(superClass, fieldName);
    		}
    		return null;
    	}
    
    	/**
    	 * 将map的value值转为实体类中字段类型匹配的方法
    	 * @param value
    	 * @param fieldTypeClass
    	 * @return
    	 */
    	private static Object convertValType(Object value, Class<?> fieldTypeClass) {
    		Object retVal = null;
    		
    		if (Long.class.getName().equals(fieldTypeClass.getName())
    				|| long.class.getName().equals(fieldTypeClass.getName())) {
    			retVal = Long.parseLong(value.toString());
    		} else if (Integer.class.getName().equals(fieldTypeClass.getName())
    				|| int.class.getName().equals(fieldTypeClass.getName())) {
    			retVal = Integer.parseInt(value.toString());
    		} else if (Float.class.getName().equals(fieldTypeClass.getName())
    				|| float.class.getName().equals(fieldTypeClass.getName())) {
    			retVal = Float.parseFloat(value.toString());
    		} else if (Double.class.getName().equals(fieldTypeClass.getName())
    				|| double.class.getName().equals(fieldTypeClass.getName())) {
    			retVal = Double.parseDouble(value.toString());
    		} else {
    			retVal = value;
    		}
    		return retVal;
    	}
    

    我们写一个测试方法来验证一下上述代码,我提前建好了一个实体类productInfo,

    public class ProductInfo {
    	
    	private Long id;
    	private String name;
    	private Double price;
    	public Long getId() {
    		return id;
    	}
    	public void setId(Long id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Double getPrice() {
    		return price;
    	}
    	public void setPrice(Double price) {
    		this.price = price;
    	}
    	
    	public ProductInfo(Long id, String name, Double price) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.price = price;
    	}
    	
    	public ProductInfo() {
    		super();
    	}
    	
    	@Override
    	public String toString() {
    		return "ProductInfo [id=" + id + ", name=" + name + ", price=" + price + "]";
    	}
    }
    
    
    public static void main(String[] args) throws Exception {
    		Map<String, Object> param = new HashMap<>();
    		param.put("id", 12232);
    		param.put("name", "banana");
    		param.put("price", 12.25);
    		ProductInfo info = mapToBean(param, ProductInfo.class);
    		System.out.println(info.getName());
    	}
    

    运行main函数,查看结果,可以看到控制台已经成功打印出结果,
    在这里插入图片描述

    2、对象转map,
    思路,同上述的分析类似,这不过这里需要反过来,给定一个待转化的实体类,通过反射,将实体类中的字段名称和字段值获取到,然后一一设置到map的key-value中,下面看代码,

    /**
    	 * 对象转map
    	 * @param obj
    	 * @return
    	 */
    	private static Map<String, Object> objToMap(Object obj) {
    
    		Map<String, Object> map = new HashMap<String, Object>();
    		Field[] fields = obj.getClass().getDeclaredFields();	// 获取f对象对应类中的所有属性域
    		for (int i = 0, len = fields.length; i < len; i++) {
    			String varName = fields[i].getName();
    			varName = varName.toLowerCase();					// 将key置为小写,默认为对象的属性
    			try {
    				boolean accessFlag = fields[i].isAccessible();	// 获取原来的访问控制权限
    				fields[i].setAccessible(true);					// 修改访问控制权限
    				Object o = fields[i].get(obj);					// 获取在对象f中属性fields[i]对应的对象中的变量
    				if (o != null){
    					map.put(varName, o.toString());
    				}
    				fields[i].setAccessible(accessFlag);			// 恢复访问控制权限
    			} catch (IllegalArgumentException ex) {
    				ex.printStackTrace();
    			} catch (IllegalAccessException ex) {
    				ex.printStackTrace();
    			}
    		}
    		return map;
    	}
    

    下面写个测试方法,

    public static void main(String[] args) throws Exception {
    
    		Map<String, Object> param = new HashMap<>();
    		param.put("id", 12232);
    		param.put("name", "banana");
    		param.put("price", 12.25);
    
    		ProductInfo info = mapToBean(param, ProductInfo.class);
    
    		System.out.println(info.getName());
    		
    		System.out.println("---------------------");
    		
    		Map<String, Object> map = objToMap(info);
    		
    		System.out.println("对象转map后的结果 : " + map);
    
    	}
    

    运行,查看控制台的输出结果,说明已经成功转化,
    在这里插入图片描述

    以上,就是map和对象之间实现互相转化的工具类,各位今后工作中如有需要可直接拿去使用,不足之处,敬请见谅哈!

    展开全文
  • 注 : 2019-06-16日 增加第六节 map与实体互转工具类,直接看第6节; 1.调用这个方法BeanMapUtils.mapToBean(),实现map集合实体类对象; 注意:这个方法转换时我这边老是报类型转换错误,引用这段代码没有报错的小伙伴...

    注 : 2019-06-16日 增加第六节 map与实体互转工具类,直接看第6节;

     1.调用这个方法BeanMapUtils.mapToBean(),实现map集合转实体类对象;

    注意: 这个方法转换时我这边老是报类型转换错误,引用这段代码没有报错的小伙伴可继续使用,此方法扩展性好,报错的小伙伴请看最下面的一个map转实体类对象方法;

            //1.通过map构造permission对象
            Permission perm = BeanMapUtils.mapToBean(map,Permission.class);
    

    2.工具类

    package com.ihrm.common.utils;
    
    import org.springframework.cglib.beans.BeanMap;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class BeanMapUtils {
    
        /**
         * 将对象属性转化为map结合
         */
        public static <T> Map<String, Object> beanToMap(T bean) {
            Map<String, Object> map = new HashMap<>();
            if (bean != null) {
                BeanMap beanMap = BeanMap.create(bean);
                for (Object key : beanMap.keySet()) {
                    map.put(key+"", beanMap.get(key));
                }
            }
            return map;
        }
    
        /**
         * 将map集合中的数据转化为指定对象的同名属性中
         */
        public static <T> T mapToBean(Map<String, Object> map,Class<T> clazz) throws Exception {
            T bean = clazz.newInstance();
            BeanMap beanMap = BeanMap.create(bean);
            beanMap.putAll(map);
            return bean;
        }
    }
    

    3.BeanMap 内置工具类

    //
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.cglib.beans;
    
    import java.security.ProtectionDomain;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import org.springframework.asm.ClassVisitor;
    import org.springframework.cglib.core.AbstractClassGenerator;
    import org.springframework.cglib.core.KeyFactory;
    import org.springframework.cglib.core.ReflectUtils;
    import org.springframework.cglib.core.AbstractClassGenerator.Source;
    
    public abstract class BeanMap implements Map {
        public static final int REQUIRE_GETTER = 1;
        public static final int REQUIRE_SETTER = 2;
        protected Object bean;
    
        public static BeanMap create(Object bean) {
            BeanMap.Generator gen = new BeanMap.Generator();
            gen.setBean(bean);
            return gen.create();
        }
    
        public abstract BeanMap newInstance(Object var1);
    
        public abstract Class getPropertyType(String var1);
    
        protected BeanMap() {
        }
    
        protected BeanMap(Object bean) {
            this.setBean(bean);
        }
    
        public Object get(Object key) {
            return this.get(this.bean, key);
        }
    
        public Object put(Object key, Object value) {
            return this.put(this.bean, key, value);
        }
    
        public abstract Object get(Object var1, Object var2);
    
        public abstract Object put(Object var1, Object var2, Object var3);
    
        public void setBean(Object bean) {
            this.bean = bean;
        }
    
        public Object getBean() {
            return this.bean;
        }
    
        public void clear() {
            throw new UnsupportedOperationException();
        }
    
        public boolean containsKey(Object key) {
            return this.keySet().contains(key);
        }
    
        public boolean containsValue(Object value) {
            Iterator it = this.keySet().iterator();
    
            Object v;
            do {
                if (!it.hasNext()) {
                    return false;
                }
    
                v = this.get(it.next());
            } while((value != null || v != null) && (value == null || !value.equals(v)));
    
            return true;
        }
    
        public int size() {
            return this.keySet().size();
        }
    
        public boolean isEmpty() {
            return this.size() == 0;
        }
    
        public Object remove(Object key) {
            throw new UnsupportedOperationException();
        }
    
        public void putAll(Map t) {
            Iterator it = t.keySet().iterator();
    
            while(it.hasNext()) {
                Object key = it.next();
                this.put(key, t.get(key));
            }
    
        }
    
        public boolean equals(Object o) {
            if (o != null && o instanceof Map) {
                Map other = (Map)o;
                if (this.size() != other.size()) {
                    return false;
                } else {
                    Iterator it = this.keySet().iterator();
    
                    while(true) {
                        if (!it.hasNext()) {
                            return true;
                        }
    
                        Object key = it.next();
                        if (!other.containsKey(key)) {
                            return false;
                        }
    
                        Object v1 = this.get(key);
                        Object v2 = other.get(key);
                        if (v1 == null) {
                            if (v2 == null) {
                                continue;
                            }
                            break;
                        } else if (!v1.equals(v2)) {
                            break;
                        }
                    }
    
                    return false;
                }
            } else {
                return false;
            }
        }
    
        public int hashCode() {
            int code = 0;
    
            Object key;
            Object value;
            for(Iterator it = this.keySet().iterator(); it.hasNext(); code += (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode())) {
                key = it.next();
                value = this.get(key);
            }
    
            return code;
        }
    
        public Set entrySet() {
            HashMap copy = new HashMap();
            Iterator it = this.keySet().iterator();
    
            while(it.hasNext()) {
                Object key = it.next();
                copy.put(key, this.get(key));
            }
    
            return Collections.unmodifiableMap(copy).entrySet();
        }
    
        public Collection values() {
            Set keys = this.keySet();
            List values = new ArrayList(keys.size());
            Iterator it = keys.iterator();
    
            while(it.hasNext()) {
                values.add(this.get(it.next()));
            }
    
            return Collections.unmodifiableCollection(values);
        }
    
        public String toString() {
            StringBuffer sb = new StringBuffer();
            sb.append('{');
            Iterator it = this.keySet().iterator();
    
            while(it.hasNext()) {
                Object key = it.next();
                sb.append(key);
                sb.append('=');
                sb.append(this.get(key));
                if (it.hasNext()) {
                    sb.append(", ");
                }
            }
    
            sb.append('}');
            return sb.toString();
        }
    
        public static class Generator extends AbstractClassGenerator {
            private static final Source SOURCE = new Source(BeanMap.class.getName());
            private static final BeanMap.Generator.BeanMapKey KEY_FACTORY;
            private Object bean;
            private Class beanClass;
            private int require;
    
            public Generator() {
                super(SOURCE);
            }
    
            public void setBean(Object bean) {
                this.bean = bean;
                if (bean != null) {
                    this.beanClass = bean.getClass();
                }
    
            }
    
            public void setBeanClass(Class beanClass) {
                this.beanClass = beanClass;
            }
    
            public void setRequire(int require) {
                this.require = require;
            }
    
            protected ClassLoader getDefaultClassLoader() {
                return this.beanClass.getClassLoader();
            }
    
            protected ProtectionDomain getProtectionDomain() {
                return ReflectUtils.getProtectionDomain(this.beanClass);
            }
    
            public BeanMap create() {
                if (this.beanClass == null) {
                    throw new IllegalArgumentException("Class of bean unknown");
                } else {
                    this.setNamePrefix(this.beanClass.getName());
                    return (BeanMap)super.create(KEY_FACTORY.newInstance(this.beanClass, this.require));
                }
            }
    
            public void generateClass(ClassVisitor v) throws Exception {
                new BeanMapEmitter(v, this.getClassName(), this.beanClass, this.require);
            }
    
            protected Object firstInstance(Class type) {
                return ((BeanMap)ReflectUtils.newInstance(type)).newInstance(this.bean);
            }
    
            protected Object nextInstance(Object instance) {
                return ((BeanMap)instance).newInstance(this.bean);
            }
    
            static {
                KEY_FACTORY = (BeanMap.Generator.BeanMapKey)KeyFactory.create(BeanMap.Generator.BeanMapKey.class, KeyFactory.CLASS_BY_NAME);
            }
    
            interface BeanMapKey {
                Object newInstance(Class var1, int var2);
            }
        }
    }
    

     

    方法二 :

     map转对象: 解决类型转换问题

    实体类:

    实体类属性建议用包装类,不要用基本数据类型 !!!

    package com.ihrm.domain.system;
    
    import lombok.Getter;
    import lombok.NoArgsConstructor;
    import lombok.Setter;
    import lombok.ToString;
    import org.hibernate.annotations.DynamicInsert;
    import org.hibernate.annotations.DynamicUpdate;
    
    import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.Table;
    import java.io.Serializable;
    
    @Entity
    @Table(name = "pe_permission")
    @Getter
    @Setter
    @ToString
    @NoArgsConstructor
    @DynamicInsert(true)
    @DynamicUpdate(true)
    public class Permission implements Serializable {
        private static final long serialVersionUID = -4990810027542971546L;
        /**
         * 主键
         */
        @Id
        private String id;
        /**
         * 权限名称
         */
        private String name;
        /**
         * 权限类型 1为菜单 2为功能 3为API
         */
        private Integer type;
    
        private String code;
    
        /**
         * 权限描述
         */
        private String description;
    
        private String pid;
    
        private Integer enVisible;
    
        public Permission(String name, Integer type, String code, String description) {
            this.name = name;
            this.type = type;
            this.code = code;
            this.description = description;
        }
    
    
    }

    转换工具:

    /**
         * map 转 实体类
         * @param map
         * @return
         * @throws Exception
         */
        public Permission mapToBean(Map<String,Object> map)
                throws Exception
        {
            Permission permission = new Permission();
            if(map != null){
                Field[] declaredFields = Permission.class.getDeclaredFields();
                if(declaredFields != null){
    
                    for (Field declaredField : declaredFields)
                    {
                        declaredField.setAccessible(true);
                        Set<String> mapKeys = map.keySet();
                   
                        for (String mapKey : mapKeys)
                        {
    
                        if(declaredField.getType().toString().contains("Integer"))//判断属性类型 进行转换,map中存放的是Object对象需要转换 实体类中有多少类型就加多少类型,实体类属性用包装类;
                            if(declaredField.getName().equals(mapKey)){
                                declaredField.set(permission,Integer.valueOf(map.get(mapKey).toString()));
                                break;
                            }
                            if(declaredField.getType().toString().contains("String") )//判断属性类型 进行转换;
                                if(declaredField.getName().equals(mapKey)){
                                    declaredField.set(permission,map.get(mapKey));
                        
                                    break;
                                }
                        }
                    }
                }
                
            }
    
            return permission;
        }
    

    service使用:

     

    /**
         * 1.保存权限
         */
        public void save(Map<String,Object> map) throws Exception {
            //设置主键的值
            String id = idWorker.nextId()+"";
    
            //1.通过map构造permission对象 扩展性比较好,但我运行时报类型转换错误
        /*   BeanMapUtils.mapToBean(map, Permission.class);
            Permission perm = BeanMapUtils.mapToBean(map,Permission.class);*/
            Permission perm = mapToBean(map);//新做的方法
            perm.setId(id);
            //2.根据类型构造不同的资源对象(菜单,按钮,api)
            int type = perm.getType();
            switch (type) {
                case PermissionConstants.PERMISSION_MENU:
                    PermissionMenu menu = BeanMapUtils.mapToBean(map,PermissionMenu.class);
                    menu.setId(id);
                    permissionMenuDao.save(menu);
                    break;
                case PermissionConstants.PERMISSION_POINT:
                    PermissionPoint point = BeanMapUtils.mapToBean(map,PermissionPoint.class);
                    point.setId(id);
                    permissionPointDao.save(point);
                    break;
                case PermissionConstants.PERMISSION_API:
                    PermissionApi api = BeanMapUtils.mapToBean(map,PermissionApi.class);
                    api.setId(id);
                    permissionApiDao.save(api);
                    break;
                default:
                    throw new CommonException(ResultCode.FAIL);
            }
            //3.保存
            permissionDao.save(perm);
        }

    补充:

    判断类型

        Object param;
    
       if (param instanceof Integer) {
        
    
       } else if (param instanceof String) {
         
       } else if (param instanceof Double) {
         
       } else if (param instanceof Float) {
         
    
       } else if (param instanceof Long) {
        
    
       } else if (param instanceof Boolean) {
      
    
       } else if (param instanceof Date) {
        
    
       }  
    

     

    ========================================================================================

     

    六.以下是最优先最稳定最有效的map与模型互转类

    6.1 map与模型互转工具类

    BeanUtils

    import java.beans.PropertyDescriptor;
    import java.beans.PropertyEditor;
    import java.beans.PropertyEditorSupport;
    import java.sql.Time;
    import java.sql.Timestamp;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.Map.Entry;
    import java.util.concurrent.ConcurrentHashMap;
    import org.springframework.beans.BeanWrapper;
    import org.springframework.beans.BeanWrapperImpl;
    
    public class BeanUtils {
        public static final String PROPERTY_NAME = "com.context.key.lowercase";
        private static final boolean LOWERCASE = isLowercase();
        private static ConcurrentHashMap<Class<?>, PropertyEditor> customEditors = new ConcurrentHashMap();
        static ThreadLocal<Set> recurseBeanSet;
    
        private static boolean isLowercase() {
            String lowercase = System.getProperty("com..context.key.lowercase", "false");
            return Boolean.valueOf(lowercase).booleanValue();
        }
    
        private BeanUtils() {
        }
    
        public static void registerCustomEditor(Class<?> clazz, PropertyEditor editor) {
            customEditors.put(clazz, editor);
        }
    
        public static String getConvertedName(String name) {
            return name != null && name.length() != 0 && !LOWERCASE ? Character.toUpperCase(name.charAt(0)) + name.substring(1) : name;
        }
    
        public static <T> T map2Bean(Map map, T obj) {
            BeanWrapper bw = new BeanWrapperImpl(obj);
            PropertyDescriptor[] props = bw.getPropertyDescriptors();
            PropertyDescriptor[] var4 = props;
            int var5 = props.length;
    
            for(int var6 = 0; var6 < var5; ++var6) {
                PropertyDescriptor pd = var4[var6];
                String name = pd.getName();
                if (bw.isWritableProperty(name) && bw.isReadableProperty(name)) {
                    Class class0 = pd.getPropertyType();
                    String convertedName;
                    Object value;
                    if (Enum.class.isAssignableFrom(class0)) {
                        convertedName = getConvertedName(name);
                        value = map.get(convertedName);
                        if (value != null) {
                            if (value.getClass() == class0) {
                                bw.setPropertyValue(name, value);
                            } else {
                                String enumValue = String.valueOf(value);
                                if (enumValue.length() > 0) {
                                    Enum v = Enum.valueOf(class0, enumValue);
                                    bw.setPropertyValue(name, v);
                                }
                            }
                        }
                    } else {
                        convertedName = getConvertedName(name);
                        value = map.get(convertedName);
                        if (value != null) {
                            bw.setPropertyValue(name, value);
                        }
                    }
                }
            }
    
            return bw.getWrappedInstance();
        }
    
        public static <T> T map2Bean(Map map, Class<T> clazz) {
            BeanWrapper bw = new BeanWrapperImpl(clazz);
            Iterator var3 = customEditors.entrySet().iterator();
    
            while(var3.hasNext()) {
                Entry<Class<?>, PropertyEditor> en = (Entry)var3.next();
                bw.registerCustomEditor((Class)en.getKey(), (PropertyEditor)en.getValue());
            }
    
            PropertyDescriptor[] props = bw.getPropertyDescriptors();
            PropertyDescriptor[] var15 = props;
            int var5 = props.length;
    
            for(int var6 = 0; var6 < var5; ++var6) {
                PropertyDescriptor pd = var15[var6];
                String name = pd.getName();
                if (bw.isWritableProperty(name) && bw.isReadableProperty(name)) {
                    Class class0 = pd.getPropertyType();
                    String convertedName;
                    Object value;
                    if (Enum.class.isAssignableFrom(class0)) {
                        convertedName = getConvertedName(name);
                        value = map.get(convertedName);
                        if (value != null) {
                            if (value.getClass() == class0) {
                                bw.setPropertyValue(name, value);
                            } else {
                                String enumValue = String.valueOf(value);
                                if (enumValue.length() > 0) {
                                    Enum v = Enum.valueOf(class0, String.valueOf(value));
                                    bw.setPropertyValue(name, v);
                                }
                            }
                        }
                    } else {
                        convertedName = getConvertedName(name);
                        value = map.get(convertedName);
                        if (value != null) {
                            bw.setPropertyValue(name, value);
                        }
                    }
                }
            }
    
            return bw.getWrappedInstance();
        }
    
        public static Map bean2Map(Object beanObject) {
            BeanWrapperImpl bean = new BeanWrapperImpl(beanObject);
            PropertyDescriptor[] desc = bean.getPropertyDescriptors();
            HashMap dataMap = new HashMap(desc.length);
    
            try {
                for(int i = 0; i < desc.length; ++i) {
                    String name = desc[i].getName();
                    if (bean.isWritableProperty(name) && bean.isReadableProperty(name)) {
                        Object object = bean.getPropertyValue(name);
                        if (object != null) {
                            String convertedName = getConvertedName(name);
                            dataMap.put(convertedName, object);
                        }
                    }
                }
    
                return dataMap;
            } catch (Exception var8) {
                throw new PeRuntimeException("pe.core.util.bean2map_fail", var8);
            }
        }
    
        public static List<Map> listBean2ListMap(List list) {
            List<Map> result = new ArrayList();
            Iterator it = list.iterator();
    
            while(it.hasNext()) {
                Map tmp = bean2Map(it.next());
                result.add(tmp);
            }
    
            return result;
        }
    
        public static <T> List<T> listMap2ListBean(List list, Class<T> class0) {
            List<T> result = new ArrayList();
            Iterator it = list.iterator();
    
            while(it.hasNext()) {
                T t = map2Bean((Map)it.next(), class0);
                result.add(t);
            }
    
            return result;
        }
    
        public static Map bean2MapRecurse(Object beanObject) {
            Set set = (Set)recurseBeanSet.get();
            if (set.contains(beanObject)) {
                return null;
            } else {
                set.add(beanObject);
    
                try {
                    BeanWrapperImpl bean = new BeanWrapperImpl(beanObject);
                    PropertyDescriptor[] desc = bean.getPropertyDescriptors();
                    HashMap dataMap = new HashMap(desc.length);
    
                    try {
                        for(int i = 0; i < desc.length; ++i) {
                            String name = desc[i].getName();
                            if (bean.isWritableProperty(name) && bean.isReadableProperty(name)) {
                                Object object = bean.getPropertyValue(name);
                                if (object != null) {
                                    String convertedName = getConvertedName(name);
                                    Class class0 = object.getClass();
                                    if (!class0.getName().startsWith("java") && !Enum.class.isAssignableFrom(class0)) {
                                        Map subMap = bean2MapRecurse(object);
                                        if (subMap != null) {
                                            Iterator it = subMap.entrySet().iterator();
    
                                            while(it.hasNext()) {
                                                Entry entry = (Entry)it.next();
                                                dataMap.put(convertedName + "_" + entry.getKey(), entry.getValue());
                                            }
                                        }
                                    } else {
                                        dataMap.put(convertedName, object);
                                    }
                                }
                            }
                        }
    
                        HashMap var18 = dataMap;
                        return var18;
                    } catch (Exception var16) {
                        throw new PeRuntimeException("pe.core.util.bean2map_fail", var16);
                    }
                } finally {
                    set.remove(beanObject);
                }
            }
        }
    
        public static void list2Bean(List<?> srcBeanObject, Object destBeanObject, String listPropName) {
            BeanWrapperImpl destBean = new BeanWrapperImpl(destBeanObject);
            destBean.setPropertyValue(listPropName, srcBeanObject);
        }
    
        public static <T> T bean2Bean(Object srcBeanObject, Class<T> class0) {
            try {
                T t = class0.newInstance();
                if (srcBeanObject instanceof List) {
                    list2Bean((List)srcBeanObject, t, "list");
                } else {
                    bean2Bean(srcBeanObject, t);
                }
    
                return t;
            } catch (Exception var3) {
                throw new PeRuntimeException("pe.core.util.bean2bean_fail", var3);
            }
        }
    
        public static void bean2Bean(Object srcBeanObject, Object destBeanObject) {
            BeanWrapperImpl srcBean = new BeanWrapperImpl(srcBeanObject);
            BeanWrapperImpl destBean = new BeanWrapperImpl(destBeanObject);
            PropertyDescriptor[] destDesc = destBean.getPropertyDescriptors();
    
            try {
                for(int i = 0; i < destDesc.length; ++i) {
                    String name = destDesc[i].getName();
                    if (destBean.isWritableProperty(name) && srcBean.isReadableProperty(name)) {
                        Object srcValue = srcBean.getPropertyValue(name);
                        if (srcValue != null) {
                            destBean.setPropertyValue(name, srcValue);
                        }
                    }
                }
    
            } catch (Exception var8) {
                throw new PeRuntimeException("pe.core.util.bean2bean_fail", var8);
            }
        }
    
        public static <T> T map2BeanStrict(Map map, T obj) {
            BeanWrapper bw = new BeanWrapperImpl(obj);
            PropertyDescriptor[] props = bw.getPropertyDescriptors();
            PropertyDescriptor[] var4 = props;
            int var5 = props.length;
    
            for(int var6 = 0; var6 < var5; ++var6) {
                PropertyDescriptor pd = var4[var6];
                String name = pd.getName();
                if (bw.isWritableProperty(name) && bw.isReadableProperty(name)) {
                    Class class0 = pd.getPropertyType();
                    Object value;
                    if (Enum.class.isAssignableFrom(class0)) {
                        value = map.get(name);
                        if (value != null) {
                            if (value.getClass() == class0) {
                                bw.setPropertyValue(name, value);
                            } else {
                                Enum v = Enum.valueOf(class0, String.valueOf(value));
                                bw.setPropertyValue(name, v);
                            }
                        }
                    } else {
                        value = map.get(name);
                        if (value != null) {
                            bw.setPropertyValue(name, value);
                        }
                    }
                }
            }
    
            return bw.getWrappedInstance();
        }
    
        public static <T> T map2BeanStrict(Map map, Class<T> clazz) {
            BeanWrapper bw = new BeanWrapperImpl(clazz);
            PropertyDescriptor[] props = bw.getPropertyDescriptors();
            PropertyDescriptor[] var4 = props;
            int var5 = props.length;
    
            for(int var6 = 0; var6 < var5; ++var6) {
                PropertyDescriptor pd = var4[var6];
                String name = pd.getName();
                if (bw.isWritableProperty(name) && bw.isReadableProperty(name)) {
                    Class class0 = pd.getPropertyType();
                    Object value;
                    if (Enum.class.isAssignableFrom(class0)) {
                        value = map.get(name);
                        if (value != null) {
                            if (value.getClass() == class0) {
                                bw.setPropertyValue(name, value);
                            } else {
                                Enum v = Enum.valueOf(class0, String.valueOf(value));
                                bw.setPropertyValue(name, v);
                            }
                        }
                    } else {
                        value = map.get(name);
                        if (value != null) {
                            bw.setPropertyValue(name, value);
                        }
                    }
                }
            }
    
            return bw.getWrappedInstance();
        }
    
        static {
            registerCustomEditor(Date.class, new BeanUtils.CustomPropertyEditor() {
                public Object getValue() {
                    return DateUtils.toDate(this.value);
                }
            });
            registerCustomEditor(java.sql.Date.class, new BeanUtils.CustomPropertyEditor() {
                public Object getValue() {
                    return DateUtils.toSqlDate(this.value);
                }
            });
            registerCustomEditor(Time.class, new BeanUtils.CustomPropertyEditor() {
                public Object getValue() {
                    return DateUtils.toTime(this.value);
                }
            });
            registerCustomEditor(Timestamp.class, new BeanUtils.CustomPropertyEditor() {
                public Object getValue() {
                    return DateUtils.toTimestamp(this.value);
                }
            });
            recurseBeanSet = new ThreadLocal<Set>() {
                protected synchronized Set initialValue() {
                    return new HashSet();
                }
            };
        }
    
        private static class CustomPropertyEditor extends PropertyEditorSupport {
            protected Object value;
    
            private CustomPropertyEditor() {
            }
    
            public void setAsText(String text) throws IllegalArgumentException {
                this.value = text;
            }
    
            public void setValue(Object value) {
                this.value = value;
            }
        }
    }
    

    使用

    6.2 模型转map

    User user = new user("小明",18)
    
    Map map = BeanUtils.bean2Map(user)

    6.3 map转模型

    Map resultMap =  new HashMap();
    resultMap .put("Username","小明");
    resultMap .put("Age","18");
    User user = BeanUusertils.map2Bean(resultMap, User.class);

    感谢赞助与支持!

    展开全文
  •  这种错误就是xml转对象的时候不识别造成的,需要在对应的对象或字段上加上别名namespace  (就是你报错信息中的uri)即可。 这个错误花了一天多才理清,嗯现在是凌晨3点   感谢偶然间看到这个 帖子 和这...
    public class JaxbXmlUtil {
        private static final String DEFAULT_ENCODING = "UTF-8";
        /**
         * pojo转换成xml 默认编码UTF-8
         */
        public static String convertBeanToXml(Object obj) throws Exception {
            return convertBeanToXml(obj, DEFAULT_ENCODING);
        }
        /**
         * pojo转换成xml
         */
        public static String convertBeanToXml(Object obj, String encoding) throws Exception {
            String result;
            JAXBContext context = JAXBContext.newInstance(obj.getClass());
            Marshaller marshaller = context.createMarshaller();
            // 生成报文的格式化
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding);
            StringWriter writer = new StringWriter();
            marshaller.marshal(obj, writer);
            result = writer.toString();
            return result;
        }
        /**
         * xml转换成pojo
         */
        @SuppressWarnings("unchecked")
        public static <T> T convertXmlToJavaBean(String xml, Class<T> t) throws Exception {
            T obj;
            JAXBContext context = JAXBContext.newInstance(t);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            obj = (T) unmarshaller.unmarshal(new StringReader(xml));
            return obj;
        }
    }
    
    public class TestJaxbClass {
    
        /**
         * 调用示例
         */
        public static void main(String[] args) {
            String respXml = "xml报文";
            // 将返回报文转成对象 (ResponseDTO 修改成你需要的对象)
            ResponseDTO respDTO = JaxbXmlUtil.convertXmlToJavaBean(respXml, ResponseDTO.class);
               
        }
    }
    
    
    jaxb:xml和pojo相互转换,上面这种工具类就不说了,看代码就行  这次主要是soapXML请求webservice接口,返回报文再进行解析。
    本来使用的wsdl直接生成客户端代码,但由于种种原因最后选择了org.apache.commons.httpclient 调用webservice的接口
    就想仿照生成的客户端代码自己写下转换 
    
    这里主要说一下使用时需要注意的地方(这次遇到的两个坑) pojo---》soapXML: 
    
        1: 需要用到xml格式的时间时注意中间有个T 如:<trxDate>2017-11-05T02:57:56</trxDate> 转换的时候注意下边的name 
           值为dateTime ,切不可写成date
           @XmlSchemaType(name = "dateTime") 
           protected XMLGregorianCalendar trxDate;
    
        2: 生成的soap XML报文如果有多个xmlns:的情况,请检查pojo里面字段或引入对象的namespace
        
        3: 如果有别名需要,请注意 @XmlElement 的name自定义
        
    soapXML---》:pojo
        1:javax.xml.bind.UnmarshalException: unexpected element (uri:"", local:"xxx")
         这种错误就是xml转对象的时候不识别造成的,需要在对应的对象或字段上加上别名namespace
         (就是你报错信息中的uri)即可。 这个错误花了一天多才理清,嗯现在是凌晨3点
     

    感谢偶然间看到这个 帖子 和这个 博客

    展开全文
  • import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation....
  • dart中json和对象互转

    万次阅读 2019-04-01 21:06:25
    dart中json和对象互转 开发过程中,json是必不可少的基础技能之一。这里记录下,在Dart语言中,如何将json解析成实例对象,以及如何将实例对象转化成json字符串。 这里使用的工具是dart:convert包。 我们的目的很...

    dart中json和对象互转

    开发过程中,json是必不可少的基础技能之一。这里记录下,在Dart语言中,如何将json解析成实例对象,以及如何将实例对象转化成json字符串。

    这里使用的工具是dart:convert包。

    我们的目的很简单,待解析的json字符串格式如下:

    {
    "key":"wangdandan",
    "value":"王蛋蛋的father"
    }
    

    json字符串解析成实例对象

    1、创建model对象
    class JsonModelDemo {
      String key;
      String value;
    }
    
    2、将实体类对象解析成json字符串。

    我们创建一个实例对象,然后给这个实例对象赋值,接着使用jsonDecode方法解析实例对象。代码如下,

    import 'dart:convert';
    
    import 'package:dart_demo1/json/json_model.dart';
    
    ///  将实体类对象解析成json字符串
    String generatePlatformJson({String key, String value}) {
      JsonModelDemo jsonModelDemo = new JsonModelDemo();
      jsonModelDemo.key = key;
      jsonModelDemo.value = value;
      String jsonStr = jsonEncode(jsonModelDemo);
      return jsonStr;
    }
    
    /// 这里写测试方法
    main() {
      String result1 = generatePlatformJson(key: "result1", value: "result1Value");
      print('result1:$result1');
    }
    

    执行代码,报错如下:

    
    lib/json/json_parse_util.dart:1: Warning: Interpreting this as package URI, 'package:dart_demo1/json/json_parse_util.dart'.
    Unhandled exception:
    Converting object to an encodable object failed: Instance of 'JsonModelDemo'
    #0      _JsonStringifier.writeObject (dart:convert/json.dart:645:7)
    #1      _JsonStringStringifier.printOn (dart:convert/json.dart:832:17)
    #2      _JsonStringStringifier.stringify (dart:convert/json.dart:817:5)
    #3      JsonEncoder.convert (dart:convert/json.dart:253:30)
    #4      JsonCodec.encode (dart:convert/json.dart:164:45)
    #5      jsonEncode (dart:convert/json.dart:76:10)
    #6      generatePlatformJson (package:dart_demo1/json/json_parse_util.dart:10:20)
    #7      main (package:dart_demo1/json/json_parse_util.dart:16:20)
    #8      _startIsolate.<anonymous closure> (dart:isolate/runtime/libisolate_patch.dart:300:19)
    #9      _RawReceivePortImpl._handleMessage (dart:isolate/runtime/libisolate_patch.dart:171:12)
    
    Process finished with exit code 255
    

    查找Converting object to an encodable object failed: Instance of 'xxx'这个错误,在stackoverflow上找到答案:https://stackoverflow.com/questions/27739434/dart-object-json-string-failing-to-convert-to-json

    我们给model实体类添加toJson方法:

    class JsonModelDemo {
      String key;
      String value;
    
      /// jsonDecode(jsonStr) 方法中会调用实体类的这个方法。如果实体类中没有这个方法,会报错。
      Map toJson() {
        Map map = new Map();
        map["key"] = this.key;
        map["value"] = this.value;
        return map;
      }
    }
    

    这次再运行代码,解析成功,输出如下:

    result1:{"key":"result1","value":"result1Value"}
    

    实例对象转化成json字符串

    解析代码如下:

    /// 将json字符串解析成实体类对象
    JsonModelDemo parsePlatformJson(String jsonStr) {
      JsonModelDemo result = jsonDecode(jsonStr);
      return result;
    }
    

    测试代码如下:

    JsonModelDemo modelDemo = parsePlatformJson(result1);
      print('parsePlatformJson:$modelDemo');
    

    为了方便测试,在JsonModelDemo中重写toString方法;

    @override
    String toString() {
    return 'JsonModelDemo{key: $key, value: $value}';
    }
    

    运行代码,报错如下:

    Unhandled exception:
    type '_InternalLinkedHashMap<String, dynamic>' is not a subtype of type 'JsonModelDemo'
    #0      parsePlatformJson (package:dart_demo1/json/json_parse_util.dart:16:17)
    #1      main (package:dart_demo1/json/json_parse_util.dart:25:29)
    #2      _startIsolate.<anonymous closure> (dart:isolate/runtime/libisolate_patch.dart:300:19)
    #3      _RawReceivePortImpl._handleMessage (dart:isolate/runtime/libisolate_patch.dart:171:12)
    

    仔细观察报错,发现是类型不匹配,具体原因是jsonDecode方法返回的是Map<String, dynamic>,不是我们期望的实例对象。所以,我们还需要将Map<String, dynamic>转化为我们想要的实例对象。

    在model中添加转化方法:

    /// jsonDecode(jsonStr)方法返回的是Map<String, dynamic>类型,需要这里将map转换成实体类
    static JsonModelDemo fromMap(Map<String, dynamic> map) {
        JsonModelDemo jsonModelDemo = new JsonModelDemo();
        jsonModelDemo.key = map['key'];
        jsonModelDemo.value = map['value'];
        return jsonModelDemo;
    }
    

    接着修改解析方法:

    /// 将json字符串解析成实体类对象
    JsonModelDemo parsePlatformJson(String jsonStr) {
      JsonModelDemo result = JsonModelDemo.fromMap(jsonDecode(jsonStr));
      return result;
    }
    

    运行代码,解析成功,输出如下:

    result1:{"key":"result1","value":"result1Value"}
    parsePlatformJson:JsonModelDemo{key: result1, value: result1Value}
    

    参考:

    https://stackoverflow.com/questions/27739434/dart-object-json-string-failing-to-convert-to-json

    https://www.dartlang.org/guides/libraries/library-tour#dartconvert—decoding-and-encoding-json-utf-8-and-more

    https://medium.com/flutter-community/parsing-complex-json-in-flutter-747c46655f51

    展开全文
  • 总结的一些json格式和对象/String/Map/List等的互转工具类 源代码下载地址:http://www.zuidaima.com/share/1550463691508736.htm
  • * 将JSON对象转换为传入类型的对象 * * @param * @param jsonObject * @param beanClass * @return */ public static <T> T toBean(JSONObject jsonObject, Class<T> beanClass) { return (T) ...
  • Json与Java对象互转之Gson学习

    千次阅读 2014-09-29 19:21:43
    我曾在《XML,Object,Json转换之浅析Xstream的使用》一文中介绍过使用XStream进行XML,Object,Json之间的转换,虽然XStream内置了对Json的支持,但是效果不是特别好,毕竟XStream重点不在...下面就介绍另外一种工具
  • 一、从json字符串转换出对象 Pager类: import com.fasterxml.jackson.annotation.JsonIgnoreProperties; @JsonIgnoreProperties(ignoreUnknown=true) public class Pager { private int nowPage; private int ...
  • jackson工具类,对象字符串互转

    千次阅读 2018-03-22 11:37:03
    * 把JavaBean转换为json字符串 (1)普通对象转换:toJson(Student) (2)List转换:toJson(List) * (3)Map转换:toJson(Map) 我们发现不管什么类型,都可以直接传入这个方法 * * @param object * JavaBean...
  • JAXBTool工具,可以将对象转换为xml,也可将xml转换成对象 代码: import java.io.StringReader; import java.io.StringWriter; import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBException; ...
  • Jackson使用,String与对象互转

    千次阅读 2017-12-19 17:15:26
    准备 // jackson转换工具 private static final ObjectMapper objectMapper = new ObjectMapper() .configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);使用对象转jsonString str = obje
  • JAXB:xml与java对象互转

    千次阅读 2017-07-01 15:51:54
    JaxbContext生成xml文件或java类对象转化注解 JAXB提供了一个快速便捷的方式将Java对象与XML进行转换。在JAX-WS(Java的WebService规范之一)中,JDK1.6 自带的版本JAX-WS2.1,其底层支持就是JAXB。 JAXB 可以实现...
  • js中JSON字符串和对象互转

    千次阅读 2019-06-17 16:57:48
    1. Json字符串JavaScript对象-----》JSON.parse() var str = '{ "name":"runoob", "alexa":10000, "site":"www.runoob.com" }'; var obj = JSON.parse(str); 2. JavaScript对象转Json字符串-----》JSON....
  • 采用Jaxb工具类实现Java对象与XML文件互转时,有一些注意的地方,记录如下: 1、model类需要加注解 @XmlRootElement 否则报错; 2、如果mode类的属性与XML节点名称不同,使用注解 @XmlElement(name="xxx"...
  • * 将map转换为对象,必须保证属性名称相同 * @return */ public static Object map2Object(Map,Object> map,Class<?> clzz){ try { Object target = clzz.newInstance(); if(CollectionUtils.isEmpty(map)){ ...
  • C++ 两行代码实现json与类对象互转

    千次阅读 2020-10-02 17:44:19
    于是有了自己写一个简单的json类 | 结构体的工具的想法。 需求如下: 只有头文件,方便使用 最多三行代码解决转换 支持类|结构体 与 json的相互转换 支持多种基本数据类型,如int、float、string、bool等 支持STL...
  • java基础之泛型对象与json互转

    千次阅读 2019-10-09 16:14:32
    把泛型对象转成字符串放到缓存中,获取后使用有点问题,记录下,有碰到的朋友,参考下。 2. 解决方案 2.1 操作类及说明 /** * @auther: 软件老王 */ public static void main(String[] args) { VO<UserParm&...
  • 自定义JSON与Object互转工具类(一)

    万次阅读 2014-06-24 12:33:50
    这里我们不讨论GSON的使用,而是自定义一个工具类,来实现JSON与Object之间的互转。 废话不多说,先来看一个实例: 首先定义一个POJO对象User [java] view plaincopy publ
  • 实体类与Map互转工具

    万次阅读 2017-03-06 17:18:52
    * 将一个 Map 对象转化为一个 JavaBean * @param clazz 要转化的类型 * @param map 包含属性值的 map * @return 转化出来的 JavaBean 对象 * @throws IntrospectionException 如果分析类属性失败 * @...
  • json字符串与Object、List、Map的互转工具

    万次阅读 热门讨论 2015-04-03 10:47:02
    * 泛型返回,json字符串转对象 * 2015年4月3日上午10:42:19 * auther:shijing * @param jsonAsString * @param pojoClass * @return * @throws JsonMappingException * @throws JsonParseException ...
  • Json与Map互转工具类-JsonToMap

    千次阅读 2018-07-05 16:03:58
    * Description: 使用Gson把json字符串成Map * History: * * {xxx} 22:36 1.0 Create */ public class JsonToMap { /** * 将Map成json * @param map * @return */ ...
  • C# 对象与JSON互转

    千次阅读 2016-04-12 13:18:08
    1:JSON工具类 static class JsonHelper { /// /// 格式化为JSON /// /// 泛型 /// 对象 /// JSON字符串 public static string Serialize(this IEnumerable entity
  • 前台JSON对象和JSON字符串互转

    千次阅读 2017-08-10 13:32:27
    浏览器支持的转换方式(Firefox,chrome,opera,safari,ie9,ie8)等浏览器: JSON.parse(jsonstr); //可以将json字符串转换成json对象 JSON.stringify(jsonobj); //可以将json对象转换成json对符串
  • Jackson实现Object对象与Json字符串的互转 url: http://blog.csdn.net/a123demi/article/details/43112547   一准备二不带日期的对象实体与json互转 定义实体UserBeanjavaDeptBeanjavajackson数据转换...
  • 一、摘要 在实际开发过程中,经常碰到需要进行对象与map之间互转的问题,其实对于对象、Map 之间进行互转有很多种方式,下面我们一起来梳理一下:利用 JSON 工具包,将对象转成字符串,...
  •  之前的项目 实体类 属性字段比较少,偷懒的做法 是 遍历 dictionary 利用objectForKey 逐个对 实体对象属性赋值; 但是现在的项目开始变态了,实体非常多,而且 实体属性字段 动辄几十个,就像下面这种类型: @...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,263
精华内容 19,705
关键字:

对象互转的工具