Java Bean与Map转换的几种方式
作者：拂晓银砾
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转换内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！