对象Bean与Map互转问题

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

一、摘要

在实际开发过程中，经常碰到需要进行对象与map之间互转的问题，其实对于对象、Map 之间进行互转有很多种方式，下面我们一起来梳理一下：

利用 JSON 工具包，将对象转成字符串，之后再转成 Map，这种需要转换2次，相对来说效率比较底；
利用 Java 反射，获取 Bean 类的属性和值，再转换到 Map 对应的键值对中，相对来说这种方法效率高些，在实现上比较麻烦；
利用 Java 的内省(Introspector) 实现，获取 Bean 类的属性和值，Map与对象互转，效率比较高；
利用 apache 中的 BeanUtils工具包进行操作，底层实现类似方法三；
利用net.sf.cglib.beans.BeanMap类中的方法，这种方式效率也非常高；

二、常用方法

也不多说了，直接show code，为了更接近实际场景，我们新建两个实体类User、Role，假设一个用户有多个角色，如下：

publicclass User { private String userId; private String userName; private List<Role> roleList; //... 省略 setter 和 getter public User() {} public User(String userId, String userName) {
this.userId = userId;
this.userName = userName;
}
}
publicclass Role { private String userId; private String roleName; //... 省略 setter 和 getter public Role(String userId, String roleName) {
this.userId = userId;
this.roleName = roleName;
}
}

2.1、通过 JSON 进行转换

在这里，我们利用阿里巴巴的fastjson包进行转换，通过maven引入 jar，如下：

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.49</version>
</dependency>

方法如下：

publicclass BeanMapUtilByJson { /**
* 对象转Map
* @param object
* @return
*/
public static Map beanToMap(Object object){
return JSONObject.parseObject(JSON.toJSONString(object),Map.class);
} /**
* map转对象
* @param map
* @param beanClass
* @param <T>
* @return
*/
publicstatic <T> T mapToBean(Map map, Class<T> beanClass){
return JSONObject.parseObject(JSON.toJSONString(map),beanClass);
}
}

2.2、利用反射进行转换

这种操作是利用 java 原生提供的反射特性来实现互转，方法如下：

publicclass BeanMapUtilByReflect { /**
* 对象转Map
* @param object
* @return
* @throws IllegalAccessException
*/
public static Map beanToMap(Object object) throws IllegalAccessException {
Map<String, Object> map = new HashMap<String, Object>();
Field[] fields = object.getClass().getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
map.put(field.getName(), field.get(object));
}
return map;
} /**
* map转对象
* @param map
* @param beanClass
* @param <T>
* @return
* @throws Exception
*/
publicstatic <T> T mapToBean(Map map, Class<T> beanClass) throws Exception {
T object = beanClass.newInstance();
Field[] fields = object.getClass().getDeclaredFields();
for (Field field : fields) {
int mod = field.getModifiers();
if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
continue;
}
field.setAccessible(true);
if (map.containsKey(field.getName())) {
field.set(object, map.get(field.getName()));
}
}
return object;
}
}

2.3、利用内省机制进行转换

内省（Introspector）是 Java 语言对 JavaBean 类属性、事件的一种缺省处理方法，也是基于 java 原生实现，操作如下：

publicclass BeanMapUtilByIntros { /**
* 对象转Map
* @param object
* @return
*/
public static Map beanToMap(Object object) throws Exception {
Map<String, Object> map = new HashMap<String, Object>();
BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass());
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor property : propertyDescriptors) {
String key = property.getName();
if (key.compareToIgnoreCase("class") == 0) {
continue;
}
Method getter = property.getReadMethod();
Object value = getter!=null ? getter.invoke(object) : null;
map.put(key, value);
}
return map;
} /**
* map转对象
* @param map
* @param beanClass
* @param <T>
* @return
* @throws Exception
*/
publicstatic <T> T mapToBean(Map map, Class<T> beanClass) throws Exception {
T object = beanClass.newInstance();
BeanInfo beanInfo = Introspector.getBeanInfo(object.getClass());
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor property : propertyDescriptors) {
Method setter = property.getWriteMethod();
if (setter != null) {
setter.invoke(object, map.get(property.getName()));
}
}
return object;
}
}

2.4、利用 apache 中的 BeanUtils 进行转换

在使用这个方法前，需要手动引入 apache 中的 beanutils 包，方法如下：

<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.9.3</version>
</dependency>

想必大家都不会陌生，操作如下：

publicclass BeanMapUtilByApache { /**
* 对象转Map
* @param object
* @return
*/
public static Map beanToMap(Object object){
returnnew org.apache.commons.beanutils.BeanMap(object);
} /**
* map转对象
* @param map
* @param beanClass
* @param <T>
* @return
*/
publicstatic <T> T mapToBean(Map map, Class<T> beanClass) throws Exception {
T object = beanClass.newInstance();
org.apache.commons.beanutils.BeanUtils.populate(object, map);
return object;
}
}

2.5、利用 cglib 中的 BeanMap 进行转换

在使用这个方法前，需要手动引入cglib 包，方法如下：

<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>

Spring 内置了 cglib，在项目中经常看到有同学用这个方法，操作如下：

publicclass BeanMapUtilByCglib { /**
* 对象转Map
* @param object
* @return
*/
public static Map beanToMap(Object object){
Map<String, Object> map = new HashMap<String, Object>();
if (object != null) {
BeanMap beanMap = BeanMap.create(object);
for (Object key : beanMap.keySet()) {
map.put(key+"", beanMap.get(key));
}
}
return map;
} /**
* map转对象
* @param map
* @param beanClass
* @param <T>
* @return
* @throws Exception
*/
publicstatic <T> T mapToBean(Map map, Class<T> beanClass) throws Exception {
T bean = beanClass.newInstance();
BeanMap beanMap = BeanMap.create(bean);
beanMap.putAll(map);
return bean;
}
}

2.6、测试

上面介绍完了操作，最后我们来测试一下，新建一个测试客户端TestClient，分别测试上面5个工具类

publicclass BeanMapClient { /**
* 测试
* @param args
*/
public static void main(String[] args) {
//为了更贴近实际场景，构造嵌套实体对象
User user = new User("1","张三");
List<Role> roleList = new ArrayList<Role>();
roleList.add(new Role("1","技术经理"));
roleList.add(new Role("1","信息主任"));
user.setRoleList(roleList);
//bean转map
Map userMap = BeanMapUtilByJson.beanToMap(user);
System.out.println("转换后的map:" + JSON.toJSONString(userMap));
//修改源对象中信息
user.getRoleList().get(0).setRoleName("项目经理");
user.getRoleList().add(new Role("1","项目经理"));
//map转bean
User newUser = BeanMapUtilByJson.mapToBean(userMap,User.class);
System.out.println("转换后的bean:" + JSON.toJSONString(newUser));
}
}