java 对象转map

本文介绍了一种将JavaBean对象转换为Map的方法,并提供了一个示例类`BeanToMapUtil`,它能够递归地处理JavaBean及其包含的集合类型的属性。


import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class BeanToMapUtil {


/**
* @param args
* @throws InvocationTargetException 
* @throws IllegalAccessException 
* @throws IntrospectionException 
*/
public static void main(String[] args) throws IntrospectionException, IllegalAccessException, InvocationTargetException {
// TODO Auto-generated method stub


userd d=new userd(12,"ccc",88,"plt",new String[]{"panlitao","panwenxuan","dengxiaofen"});

Map mp=convertBean(d);

System.out.println(((List<Map>)mp.get("fjlist")).get(1).get("uname").toString()); 

System.out.println(((List<Map>)mp.get("fjlist")).get(1).get("uname").toString()); 
}





/**
* 将一个 JavaBean 对象转化为一个 Map

* @param bean
*            要转化的JavaBean 对象
* @return 转化出来的 Map 对象
* @throws IntrospectionException
*             如果分析类属性失败
* @throws IllegalAccessException
*             如果实例化 JavaBean 失败
* @throws InvocationTargetException
*             如果调用属性的 setter 方法失败
*/
public static Map convertBean(Object bean) throws IntrospectionException,
IllegalAccessException, InvocationTargetException {
Class type = bean.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(bean, new Object[0]);
if (result != null) {
if(readMethod.toString().indexOf("java.util.List")>-1&&result.toString().indexOf("@")>-1)
{
  List<Object> lmp=new ArrayList<Object>();
for(Object mobj:((List<Object>)result))
{lmp.add(convertBean(mobj));}
returnMap.put(propertyName, lmp);
}
else if(result.toString().indexOf("@")>-1&&result.toString().indexOf("[Ljava.lang.")==-1)
{returnMap.put(propertyName, convertBean(result));}
else
{returnMap.put(propertyName, result);}
}

else {
returnMap.put(propertyName, "");
}
}
}
return returnMap;
}
}


class userd  {

userd(int uid,String uname,int age,String up,String[] arg)
{
this.uid=uid;
this.uname=uname;
this.age=age;
this.up=up;
this.arg=arg;
}
public String[] getArg() {
return arg;
}
public void setArg(String[] arg) {
this.arg = arg;
}
public fjben getFn() {
return fn;
}
public void setFn(fjben fn) {
this.fn = fn;
}

private List<String> strlist;


public List<String> getStrlist() {

List<String> lst=new ArrayList<String>();
lst.add("aaa");
lst.add("bbb");
strlist=lst;
return strlist;
}
public void setStrlist(List<String> strlist) {
this.strlist = strlist;
}


private List<fjben> fjlist;
public List<fjben> getFjlist() {
List<fjben> fl=new ArrayList<fjben>();
fl.add(new fjben(99,"ccc99",9999,"plt99",new String[]{"99999","7777","55555"}));
fl.add(new fjben(991,"ccc991",99991,"plt991",new String[]{"999991","77771","555551"}));
fjlist=fl;
return fjlist;
}
public void setFjlist(List<fjben> fjlist) {
this.fjlist = fjlist;
}


private fjben fn=new fjben(88,"ccc88",8888,"plt88",new String[]{"panlitao88","panwenxuan88","dengxiaofen88"});
private String[] arg;
private int uid;
private String uname;
private int age;
private String up;
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getUp() {
return up;
}
public void setUp(String up) {
this.up = up;
}

}




class fjben  {

fjben(int uid,String uname,int age,String up,String[] arg)
{
this.uid=uid;
this.uname=uname;
this.age=age;
this.up=up;
this.arg=arg;
}
public String[] getArg() {
return arg;
}
public void setArg(String[] arg) {
this.arg = arg;
}
private String[] arg;
private int uid;
private String uname;
private int age;
private String up;
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getUp() {
return up;
}
public void setUp(String up) {
this.up = up;
}

}
<think>我们被要求提供Java对象Map的实现方法。根据引用内容,我们可以总结几种常见方法,包括使用反射、Jackson、Apache Commons BeanUtils、Spring Framework以及CGLIB等。此外,用户提供的引用[1]中有一个使用Introspector和PropertyDescriptor的例子。 我们将介绍以下几种方法: 1. 使用Java反射API(手动实现) 2. 使用Jackson库(推荐,功能强大) 3. 使用Apache Commons BeanUtils 4. 使用Spring Framework的BeanWrapper 5. 使用Java的内省机制(Introspector)如引用[1]所示 注意:每种方法都有其适用场景和特点。 下面分别给出实现代码示例:</think>### Java 对象 Map 的多种实现方法 在 Java 中将对象换为 Map 是常见需求,以下是几种高效可靠的实现方式(含代码示例): #### 1. 使用 Java 内省机制(标准库) ```java import java.beans.*; import java.util.LinkedHashMap; import java.util.Map; public class ObjectToMapUtil { public static Map<String, Object> convert(Object obj) throws IntrospectionException, ReflectiveOperationException { Map<String, Object> map = new LinkedHashMap<>(); BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass()); for (PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) { String key = pd.getName(); if ("class".equals(key)) continue; // 跳过class属性 Method getter = pd.getReadMethod(); if (getter != null) { Object value = getter.invoke(obj); map.put(key, value); } } return map; } } ``` **特点**: - 基于 Java 标准 API(`java.beans`包) - 使用 getter 方法获取属性值(符合 JavaBean 规范) - 自动忽略 `class` 属性 - 支持私有字段通过 getter 访问[^1] #### 2. 使用 Jackson 库(推荐) ```java import com.fasterxml.jackson.databind.ObjectMapper; import java.util.Map; public class JacksonConverter { private static final ObjectMapper mapper = new ObjectMapper(); public static Map<String, Object> convert(Object obj) { return mapper.convertValue(obj, new TypeReference<Map<String, Object>>() {}); } } ``` **特点**: - 支持复杂对象嵌套换 - 自动处理日期格式(通过 `@JsonFormat` 注解) - 支持字段忽略(`@JsonIgnore`) - 高性能序列化[^3] #### 3. 使用 Spring 框架(集成方案) ```java import org.springframework.beans.BeanWrapper; import org.springframework.beans.BeanWrapperImpl; import java.beans.PropertyDescriptor; import java.util.HashMap; import java.util.Map; public class SpringConverter { public static Map<String, Object> convert(Object obj) { BeanWrapper wrapper = new BeanWrapperImpl(obj); Map<String, Object> map = new HashMap<>(); for (PropertyDescriptor pd : wrapper.getPropertyDescriptors()) { String name = pd.getName(); if (!"class".equals(name)) { map.put(name, wrapper.getPropertyValue(name)); } } return map; } } ``` **特点**: - 支持嵌套属性(如 `address.city`) - 自动换 - 与 Spring 生态无缝集成[^2] #### 4. 手动反射实现(轻量级) ```java import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; public class ReflectionConverter { public static Map<String, Object> convert(Object obj) throws IllegalAccessException { Map<String, Object> map = new HashMap<>(); Class<?> clazz = obj.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); map.put(field.getName(), field.get(obj)); } return map; } } ``` **特点**: - 零依赖实现 - 直接访问私有字段 - 简单对象场景性能最佳 ### 使用示例 ```java // 定义示例对象 public class User { private String name = "Alice"; private int age = 30; @JsonIgnore private String password; // 忽略字段 // getters/setters省略 } // 换操作 User user = new User(); Map<String, Object> map = JacksonConverter.convert(user); // 输出: {name=Alice, age=30} ``` ### 关键特性对比 | 方法 | 依赖项 | 私有字段访问 | 嵌套对象支持 | 性能 | |--------------|-------------|-------------|-------------|------| | Java内省 | JDK标准库 | 通过getter | ❌ | ★★★ | | Jackson | Jackson库 | ✔️ | ✔️ | ★★★★ | | Spring | Spring框架 | ✔️ | ✔️ | ★★★ | | 手动反射 | 无 | ✔️ | ❌ | ★★★★ | ### 最佳实践建议 1. **排除敏感字段**:使用 `@JsonIgnore` 注解忽略密码等敏感信息 ```java public class User { @JsonIgnore private String password; } ``` 2. **处理日期格式**(Jackson): ```java public class Event { @JsonFormat(pattern = "yyyy-MM-dd") private Date eventDate; } ``` 3. **深度换嵌套对象**:Jackson 和 Spring 默认支持嵌套对象换 4. **性能优化**:简单对象用反射,复杂对象用 Jackson > 提示:生产环境推荐使用 Jackson 方案,兼顾功能完整性和性能表现[^3]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值