Java Bean与Map转换的几种方式

<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>

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;
        }
    }
}