JAVABean与Map转换工具类

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * JavaBean 转 Map 字段别名
 * Map 转 JavaBean字段别名
 *
 * @author: zhangqi
 * @create 2021/11/24 16:57
 */
@SuppressWarnings("unused")
@Documented
@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface BeanToMapAlias {
    /**
     * 别名
     *
     * @return 别名
     */
    String value() default "";
    /**
     * 默认值
     *
     * @return 默认值
     */
    String def() default "";
}

import com.weds.framework.core.exception.ErrorCodeException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.*;

/**
 * @description: <br/>
 * 实体相关工具类
 * <p>
 * <br/>
 * @author: Qz1997
 * @create 2021/6/22 9:53
 */
@Slf4j
@SuppressWarnings("unused")
public final class QzBeanUtils {
   /**
     * 寻找该类的父类和其祖宗十八代的属性
     *
     * @param clazz 类
     * @return 属性数组
     */
    public static Field[] getAllFields(Class<?> clazz) {
        List<Field> fieldList = new ArrayList<>();
        while (clazz != null) {
            fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
            clazz = clazz.getSuperclass();
        }
        Field[] fields = new Field[fieldList.size()];
        fieldList.toArray(fields);
        return fields;
    }

    /**
     * 将Java Bean 转成 Map
     *
     * @param obj Java Bean
     * @return Map
     */
    @SuppressWarnings({"unchecked", "DuplicatedCode"})
    public static Map<String, Object> javaBeanToMap(Object obj) {
        if (ObjectUtils.isEmpty(obj)) {
            return null;
        }
        if (obj instanceof Map) {
            return (Map<String, Object>) obj;
        }
        Class<?> clazz = obj.getClass();
        Field[] allFields = getAllFields(clazz);
        Map<String, Object> map = new HashMap<>(ArrayUtils.getLength(allFields) << 2);
        try {
            for (Field field : allFields) {
                if (Modifier.isFinal(field.getModifiers())) {
                    continue;
                }
                BeanToMapAlias annotation = field.getAnnotation(BeanToMapAlias.class);
                String def = Strings.EMPTY;
                String alias = field.getName();
                if (ObjectUtils.isNotEmpty(annotation)) {
                    alias = annotation.value();
                    alias = StringUtils.isBlank(alias) ? field.getName() : alias;
                    def = annotation.def();
                }
                Object fieldValue = BeanUtil.getFieldValue(obj, field.getName());
                if (ObjectUtils.isNotEmpty(fieldValue)) {
                    map.put(alias, fieldValue);
                } else if (StringUtils.isNotBlank(def)) {
                    map.put(alias, def);
                }
            }
        } catch (Exception e) {
            log.error("获取Bean字段值异常,{}", obj, e);
            return null;
        }
        return map;
    }


    /**
     * Map转化为JavaBean
     *
     * @param map   map
     * @param clazz JavaBean.class
     * @param <T>   JavaBean类型
     * @return JavaBean
     */
    public static <T> T mapToBean(Map<String, ?> map, Class<T> clazz) {
        try {
            Field[] allFields = getAllFields(clazz);
            Map<String, String> mapField = new HashMap<>(ArrayUtils.getLength(allFields) << 2);
            Map<String, String> defValueMap = new HashMap<>(ArrayUtils.getLength(allFields) << 2);
            Arrays.stream(allFields).forEach(item -> {
                String key = item.getName();
                BeanToMapAlias annotation = item.getAnnotation(BeanToMapAlias.class);
                if (ObjectUtils.isNotEmpty(annotation) && StringUtils.isNotBlank(annotation.value())) {
                    key = annotation.value();
                    String def = annotation.def();
                    if (StringUtils.isNotBlank(def)) {
                        defValueMap.put(key, def);
                    }
                }
                mapField.put(key, item.getName());
            });
            T t = clazz.newInstance();
            BeanDesc desc = BeanUtil.getBeanDesc(clazz);
            map.forEach((key, value) -> {
                String fieldName = mapField.get(key);
                if (StringUtils.isNotBlank(fieldName)) {
                    desc.getProp(fieldName).setValue(t, ObjectUtils.isEmpty(value) ? defValueMap.get(key) : value);
                }
            });
            defValueMap.forEach((key, value) -> {
                String fieldName = mapField.get(key);
                if (!map.containsKey(key)) {
                    desc.getProp(fieldName).setValue(t, defValueMap.get(key));
                }
            });
            return t;
        } catch (Exception e) {
            log.error("Map转换JavaBean异常", e);
            throw new RuntimeException("Map转换JavaBean异常");
        }
    }

    /**
     * Map转化为JavaBean
     *
     * @param map   map
     * @param clazz JavaBean.class
     * @param <T>   JavaBean类型
     * @return JavaBean
     */
    public static <T> T mapToBeanUnderscore(Map<String, Object> map, Class<T> clazz) {
        try {
            T t = clazz.newInstance();
            Field[] allFields = getAllFields(clazz);
            Map<String, Field> fieldMap = Arrays.stream(allFields).collect(Collectors.toMap(Field::getName, Function.identity()));
            BeanDesc desc = BeanUtil.getBeanDesc(clazz);
            map.forEach((key, value) -> {
                String fieldName = lowerFirst(replaceUnderLineAndUpperCase(key));
                Field field = fieldMap.get(fieldName);
                if (ObjectUtils.isNotEmpty(field)) {
                    desc.getProp(fieldName).setValue(t, value);
                }
            });
            return t;
        } catch (Exception e) {
            log.error("Map转换JavaBean异常", e);
            throw new RuntimeException("Map转换JavaBean异常");
        }
    }

    /**
     * 下划线转驼峰
     *
     * @param str 下划线字符串
     * @return 驼峰字符串
     */
    public static String replaceUnderLineAndUpperCase(String str) {
        StringBuilder sb = new StringBuilder();
        sb.append(str);
        int count = sb.indexOf("_");
        while (count != 0) {
            int num = sb.indexOf("_", count);
            count = num + 1;
            if (num != -1) {
                char ss = sb.charAt(count);
                char ia = (char) (ss - 32);
                sb.replace(count, count + 1, String.valueOf(ia));
            }
        }
        String result = sb.toString().replaceAll("_", "");
        return StringUtils.capitalize(result);
    }

    /**
     * 实现首字母小写
     *
     * @param name 首字母小写前字符串
     * @return 首字母小写后字符串
     */
    public static String lowerFirst(String name) {
        char[] chars = name.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }
  
}