Java Bean与Map转换的几种方式
更新时间：2025年10月09日 10:17:01 作者：拂晓银砾
Java Bean与Map转换的几种方式,包括反射,内省,cglib,huTool,cglib动态代理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
pom文件
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- <dependency>-->
<!-- <groupId>cglib</groupId>-->
<!-- <artifactId>cglib</artifactId>-->
<!-- <version>3.3.0</version>-->
<!-- </dependency>-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.15</version>
</dependency>
</dependencies>
java代码
package com.example.service;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import org.springframework.beans.BeanUtils;
import org.springframework.cglib.beans.BeanGenerator;
import org.springframework.cglib.beans.BeanMap;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
/**
* description:
* Bean 和 Map相互转换
*
* @author DawnStar
* date: 2023/5/31
*/
public class BeanMapTransform {
public static void main(String[] args) {
AnimeBean animeBean = new AnimeBean();
animeBean.setRoleName("加藤惠");
animeBean.setAge(18);
Map<String, Object> properties = new HashMap<>(2);
properties.put("roleName", "加藤惠");
properties.put("age", 18);
System.out.println("-----------------------反射----------------------------------");
reflectMapToBean(AnimeBean.class, properties);
System.out.println("-----------------------内省----------------------------------");
introspectToBean(AnimeBean.class, properties);
System.out.println("----------------------huTool----------------------------------");
huToolMapToBean(AnimeBean.class, properties);
System.out.println("----------------------BeanUtils----------------------------------");
beanUtilsMapToBean(AnimeBean.class, properties);
System.out.println("----------------------CGlib----------------------------------");
// 动态添加字段
properties.put("animeName", "路人女主的养成方法");
// 没有使用 BeanGenerator
cglibMapToBean(AnimeBean.class, properties);
System.out.println("----------------------动态添加字段属性----------------------------------");
Map<String, Object> properties1 = new HashMap<>(2);
// 动态添加字段
properties.put("animeName", "路人女主的养成方法");
cglibDynamicMapToBean(animeBean, properties1);
}
/**
* 通过反射生成一个map
*/
private static void reflectBeanToMap(Object sourceObject) {
Map<String, Object> map = new HashMap<>();
try {
for (Field declaredField : sourceObject.getClass().getDeclaredFields()) {
// 私有属性可访问
declaredField.setAccessible(true);
Object o = declaredField.get(sourceObject);
String name = declaredField.getName();
map.put(name, o);
}
printMap(map);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
/**
* 通过反射生成一个bean
*
* @param clazz 指定类
* @param propertiesMap 属性值
*/
private static void reflectMapToBean(Class<?> clazz, Map<String, Object> propertiesMap) {
try {
Object targetObject = clazz.newInstance();
for (Field declaredField : clazz.getDeclaredFields()) {
// 私有属性可访问
declaredField.setAccessible(true);
declaredField.set(targetObject, propertiesMap.get(declaredField.getName()));
}
reflectBeanToMap(targetObject);
} catch (InstantiationException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
/**
* 通过自省的方式 beanToMap
*
* @param sourceObject 源对象
*/
private static void introspectToMap(Object sourceObject) {
try {
// 减少一个class属性
BeanInfo beanInfo = Introspector.getBeanInfo(sourceObject.getClass(), Object.class);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
Map<String, Object> map = new HashMap<>(propertyDescriptors.length);
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
String name = propertyDescriptor.getName();
Method readMethod = propertyDescriptor.getReadMethod();
Object invoke = readMethod.invoke(sourceObject);
map.put(name, invoke);
}
printMap(map);
} catch (IntrospectionException | InvocationTargetException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
/**
* Map 转 bean
*
* @param clazz 传入的类型
* @param propertiesMap 属性map
*/
private static void introspectToBean(Class<?> clazz, Map<String, Object> propertiesMap) {
try {
BeanInfo beanInfo = Introspector.getBeanInfo(clazz, Object.class);
Object sourceObject = clazz.newInstance();
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
Method writeMethod = propertyDescriptor.getWriteMethod();
writeMethod.invoke(sourceObject, propertiesMap.get(propertyDescriptor.getName()));
}
introspectToMap(sourceObject);
} catch (IntrospectionException | InvocationTargetException | IllegalAccessException |
InstantiationException e) {
throw new RuntimeException(e);
}
}
private static void huToolBeanToMap(Object sourceObject) {
Map<String, Object> map = BeanUtil.beanToMap(sourceObject, false, false);
printMap(map);
}
private static void huToolMapToBean(Class<?> clazz, Map<String, Object> propertiesMap) {
Object bean = BeanUtil.mapToBean(propertiesMap, clazz, false, CopyOptions.create());
huToolBeanToMap(bean);
}
private static void beanUtilsBeanToMap(Object sourceObject) {
Map<String, Object> map = new HashMap<>();
try {
PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(sourceObject.getClass());
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
if ("class".equals(propertyDescriptor.getName())) {
continue;
}
String name = propertyDescriptor.getName();
Method readMethod = propertyDescriptor.getReadMethod();
Object invoke = readMethod.invoke(sourceObject);
map.put(name, invoke);
}
printMap(map);
} catch (InvocationTargetException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
private static void beanUtilsMapToBean(Class<?> clazz, Map<String, Object> propertiesMap) {
try {
Object newInstance = clazz.newInstance();
PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(clazz);
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
if ("class".equals(propertyDescriptor.getName())) {
continue;
}
Method writeMethod = propertyDescriptor.getWriteMethod();
writeMethod.invoke(newInstance, propertiesMap.get(propertyDescriptor.getName()));
}
cglibBeanToMap(newInstance);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static void cglibMapToBean(Class<?> clazz, Map<String, Object> propertiesMap) {
try {
Object instance = clazz.newInstance();
BeanMap beanMap = BeanMap.create(instance);
beanMap.putAll(propertiesMap);
Object bean = beanMap.getBean();
System.out.println(bean);
reflectBeanToMap(bean);
} catch (InstantiationException | IllegalAccessException e) {
throw new RuntimeException(e);
}
}
private static void cglibBeanToMap(Object sourceObject) {
BeanMap beanMap = BeanMap.create(sourceObject);
printMap(beanMap);
}
/**
* 动态给实体类添加字段
*
* @param sourceObject 类型
* @param propertiesMap 属性映射
*/
private static void cglibDynamicMapToBean(Object sourceObject, Map<String, Object> propertiesMap) {
Map<String, Class<?>> propertyMap = new HashMap<>();
PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(sourceObject.getClass());
try {
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
if (!"class".equalsIgnoreCase(propertyDescriptor.getName())) {
propertyMap.put(propertyDescriptor.getName(), propertyDescriptor.getPropertyType());
String name = propertyDescriptor.getName();
Method readMethod = propertyDescriptor.getReadMethod();
Object invoke = readMethod.invoke(sourceObject);
propertiesMap.put(name, invoke);
}
}
DynamicBean dynamicBean = new DynamicBean(sourceObject.getClass(), propertyMap);
dynamicBean.setProperties(propertiesMap);
Object targetObject = dynamicBean.getTargetObject();
Field[] declaredFields = targetObject.getClass().getDeclaredFields();
for (Field declaredField : declaredFields) {
declaredField.setAccessible(true);
System.out.println(declaredField.getName());
Object o1 = declaredField.get(targetObject);
System.out.println(o1);
}
System.out.println(targetObject);
} catch (Exception e) {
e.printStackTrace();
}
}
private static void printMap(Map<String, Object> map) {
map.forEach((k, v) -> System.out.println(k + ": " + v));
}
static class DynamicBean {
private Object targetObject;
private BeanMap beanMap;
public DynamicBean(Class<?> clazz, Map<String, Class<?>> propertyMap) {
this.targetObject = generateBean(clazz, propertyMap);
this.beanMap = BeanMap.create(targetObject);
}
public Object getTargetObject() {
return targetObject;
}
/**
* bean 添加属性和值
*
* @param key 属性
* @param value 对应键的值
*/
public void setValue(String key, Object value) {
beanMap.put(key, value);
}
/**
* 获取属性值
*
* @param property 属性
* @return 获取属性的值
*/
public Object getValue(String property) {
return beanMap.get(property);
}
public void setProperties(Map<String, Object> propertyMap) {
beanMap.putAll(propertyMap);
}
private Object generateBean(Class<?> superclass, Map<String, Class<?>> propertyMap) {
BeanGenerator generator = new BeanGenerator();
if (null != superclass) {
generator.setSuperclass(superclass);
}
BeanGenerator.addProperties(generator, propertyMap);
return generator.create();
}
}
static class AnimeBean {
private String roleName;
private Integer age;
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
}
到此这篇关于Java Bean与Map转换的几种方式的文章就介绍到这了,更多相关Java Bean与Map转换内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
我们发现springBoot程序开发比spring程序编写起来容易的多。配置简洁，依赖关系简单，启动运行容易。那么结下了我们我们就要思考一下入门程序中的这些功能是怎么实现的2022-09-09
这篇文章主要介绍了Java HashSet的Removals()方法注意事项，文章围绕制主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下2022-06-06
Spring Boot Thymeleaf实现国际化的方法详解
这篇文章主要给大家介绍了关于Spring Boot Thymeleaf实现国际化的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring Boot具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧2019-10-10
Spark是专为大规模数据处理而设计的，基于内存快速通用,可扩展的集群计算引擎，实现了高效的DAG执行引擎,可以通过基于内存来高效处理数据流，运算速度相比于MapReduce得到了显著的提高。2021-06-06
这篇文章主要为大家详细介绍了java获取本机IP地址的三种方法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2022-04-04
这篇文章主要介绍了Spring实战之调用实例工厂方法创建Bean操作,结合实例形式分析了实例工厂方法创建Bean相关配置、实现方法及操作注意事项,需要的朋友可以参考下2019-11-11
这篇文章主要介绍了基于jdk1.8的Java源码详解 Integer，Integer是int的Warpper类，是面向对象的即OOP的对象类型，,需要的朋友可以参考下2019-06-06
这篇文章主要介绍了springboot上传文件，url直接访问资源问题。具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2022-11-11
子类在调用父类的私有方法中不能直接调用，但是可以通过get方法进行调用，修改属性的值可以通过set方法进行修改。而子类想要修改父类中的方法可以使用方法重写进行操作。2021-08-08
JavaWeb开发入门第一篇主要内容介绍的是必备知识、基础知识、搭建JavaWeb应用开发环境，感兴趣的小伙伴们可以参考一下2016-04-04
最新评论