日志以及对象转换的JAVA对象的工具类

示例一下公司内部的项目是怎么样转换java对象的

操作的实现的类如下：

 

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

import com.common.lang.StringUtil;
import com.common.logging.Logger;
import com.common.logging.LoggerFactory;

import com.common.util.enums.ResultCodeEnum;
import com.common.util.exception.BioperationException;
import com.common.util.log.LoggerConstants;
import com.common.util.log.LoggerUtil;

/**
 * The type Reflection util.
 *

 * @version $Id : ReflectionUtil.java, v 0.1 2023年03月18日 上午11:51 
 */
public class ReflectionUtil {

    /**
     * 日志
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(ReflectionUtil.class);

    /**
     * map转为对象
     *
     * @param map
     * @return
     */
    public static Object mapToObject(Map map) {
        Object obj = new Object();

        try {
            org.apache.commons.beanutils.BeanUtils.populate(obj, map);
        } catch (Throwable e) {
            LoggerUtil.error(LOGGER, e, "Map转为对象失败");
            throw new BioperationException(e, ResultCodeEnum.BEAN_TO_MAP_ERROR, "Map转Bean失败");
        }
        return obj;
    }

    /**
     * 业务系统内模型转换器
     *
     * @param           T 新建对象并返回
     * @param sourceObject
     * @param targetClass
     * @return
     */
    public static  T convert2Object(Object sourceObject, Class targetClass) {
        if (null == sourceObject) {
            return null;
        }
        T targetObject = null;
        try {
            targetObject = targetClass.newInstance();
            convert(sourceObject, targetObject);
        } catch (Exception e) {
            LoggerUtil.error(LOGGER, e, "执行模型转换失败,源类名:" + sourceObject.getClass().getName() + ",目标类名:" + targetClass.getName());
            throw new BioperationException(e, "模型转换失败", targetClass.getName());
        }
        return targetObject;
    }

    /**
     * 对象之间的模型转换
     *
     * @param sourceObject
     * @param targetObject
     */
    public static void convert(Object sourceObject, Object targetObject) {
        if (null == sourceObject) {
            return;
        }
        try {
            List targetFieldList = new ArrayList();
            //得到目标类的所有属性 包括父类（排除基类Object）
            Class tempClass = targetObject.getClass();
            while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {
                targetFieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
                tempClass = tempClass.getSuperclass();
            }
            //遍历所有显式属性
            for (Field targetField : targetFieldList) {
                targetField.setAccessible(true);
                if (Modifier.isStatic(targetField.getModifiers()) || targetField.isSynthetic()) {
                    continue;
                }
                setFieldValue(sourceObject, targetField, targetObject);
            }
        } catch (Exception e) {
            //异常不在上抛
            LoggerUtil.error(LOGGER, e, "模型转换失败");
        }
    }

    /**
     * 判断是否存在空属性
     *
     * @param sourceObject
     * @return
     */
    public static Boolean hasNullProperty(Object sourceObject) {

        List targetFieldList = new ArrayList();

        //得到目标类的所有属性 包括父类（排除基类Object）
        Class tempClass = sourceObject.getClass();
        while (tempClass != null && !tempClass.getName().toLowerCase().equals("java.lang.object")) {
            targetFieldList.addAll(Arrays.asList(tempClass.getDeclaredFields()));
            tempClass = tempClass.getSuperclass();
        }

        //遍历所有显式属性
        for (Field targetField : targetFieldList) {
            targetField.setAccessible(true);
            if (Modifier.isStatic(targetField.getModifiers()) || targetField.isSynthetic()) {
                continue;
            }
            if (getFieldValue(sourceObject, targetField.getName()) == null) {
                return true;
            }
        }

        return false;
    }

    /**
     * 获取目标对象的属性值
     *
     * @param sourceObj
     * @param filedName
     * @return
     */
    public static Object getFieldValue(Object sourceObj, String filedName) {
        Method method = null;
        Object returnObj = null;
        String methodName = "get" + getMethodName(filedName);
        try {
            method = sourceObj.getClass().getMethod(methodName);
            returnObj = method.invoke(sourceObj);
        } catch (Exception e) {
            methodName = "is" + getMethodName(filedName);
            try {
                method = sourceObj.getClass().getMethod(methodName);
                returnObj = method.invoke(sourceObj);
            } catch (Exception e1) {
                LoggerUtil.warn(LOGGER, "属性", filedName, "不存在");
            }
        }
        return returnObj;
    }

    /**
     * 获取对象的属性值
     *
     * @param obj   value to be assigned to property obj
     * @param field value to be assigned to property field
     * @param a     value to be assigned to property a
     * @return 对象
     */
    private static void setFieldValue(Object obj, Field field, Object a) {
        Method m = null;
        try {
            // 如果类型是String
            String filedNameUpper = getMethodName(field.getName());
            if (field.getType().getName().equals("java.lang.String")) { // 如果type是类类型，则前面包含"class "，后面跟类名
                // 拿到该属性的gettet方法
                m = obj.getClass().getMethod("get" + filedNameUpper);
                field.set(a, m.invoke(obj));
            }

            // 如果类型是Boolean 是封装类
            if (field.getType().getName().equals("boolean")) {
                if (0 != StringUtil.indexOf(filedNameUpper, "Is")) {
                    filedNameUpper = "is" + filedNameUpper;
                } else {
                    filedNameUpper = field.getName();
                }
                m = obj.getClass().getMethod(filedNameUpper);
                field.setBoolean(a, (Boolean) m.invoke(obj));
            }

            // 如果类型是Date
            if (field.getType().getName().equals("java.util.Date")) {
                m = obj.getClass().getMethod("get" + filedNameUpper);
                Date val = (Date) m.invoke(obj);
                field.set(a, val);
            }

            // 如果类型是Map
            if (field.getType().getName().equals("java.util.Map")) {
                m = obj.getClass().getMethod("get" + filedNameUpper);
                Map val = (Map) m.invoke(obj);
                field.set(a, val);
            }

            // 如果类型是List
            if (field.getType().getName().equals("java.util.List")) {
                m = obj.getClass().getMethod("get" + filedNameUpper);
                List val = (List) m.invoke(obj);
                field.set(a, val);
            }

            // 如果类型是Float
            if (field.getType().getName().equals("java.lang.Float")) {
                m = obj.getClass().getMethod("get" + filedNameUpper);
                Float val = (Float) m.invoke(obj);
                field.set(a, val);
            }

            // 如果类型是Long
            if (field.getType().getName().equals("java.lang.Long")) {
                m = obj.getClass().getMethod("get" + filedNameUpper);
                Long val = (Long) m.invoke(obj);
                field.set(a, val);
            }

            // 如果类型是int
            if (field.getType().getName().equals("int")) {
                m = obj.getClass().getMethod("get" + filedNameUpper);
                int val = (Integer) m.invoke(obj);
                field.set(a, val);
            }

            // 如果类型是double
            if (field.getType().getName().equals("double")) {
                m = obj.getClass().getMethod("get" + filedNameUpper);
                double val = (Double) m.invoke(obj);
                field.set(a, val);
            }

            // 如果类型是long
            if (field.getType().getName().equals("long")) {
                m = obj.getClass().getMethod("get" + filedNameUpper);
                long val = (Long) m.invoke(obj);
                field.set(a, val);
            }

        } catch (NoSuchMethodException e) {
            LoggerUtil.debug(LOGGER, "没有找到method！", e);
        } catch (Exception e) {
            LoggerUtil.error(LoggerConstants.ERROR_LOGGER, "执行属性映射时发生异常！", e);
        }
    }

    /**
     * 设置对应目标对象的属性值
     *
     * @param sourceObj
     * @param filedName
     * @return
     */
    public static void setFieldValue(Object sourceObj, String filedName, String value) {
        Method method = null;
        String methodName = "set" + getMethodName(filedName);
        try {
            Field field =sourceObj.getClass().getDeclaredField(filedName);
            Class paramType = field.getType();
            method = sourceObj.getClass().getMethod(methodName,paramType);

            //日期需要格式化
            //if (StringUtil.equalsIgnoreCase("invokeTime",filedName)){
            //    DateFormat fmt =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            //    Date date = fmt.parse(value);
            //    method.invoke(sourceObj, date);
            //}else {
            //    method.invoke(sourceObj, value);
            //}
            method.invoke(sourceObj, value);
        } catch (Exception e) {
            LoggerUtil.warn(LOGGER, "属性", filedName, "设置失败");
        }
    }

    /**
     * Getter method for property methodName.
     *
     * @param fildeName the filde name
     * @return property value of method name
     * @throws Exception the exception
     */
    private static String getMethodName(String fildeName) {
        byte[] items = fildeName.getBytes();
        items[0] = (byte) ((char) items[0] - 'a' + 'A');
        return new String(items);
    }

}