通过反射实现对象之间字段转换，字典转换

加班不脱发

已于 2023-11-25 17:50:22 修改

阅读量429

点赞数 9

文章标签： java

于 2023-11-25 17:45:56 首次发布

本文链接：https://blog.csdn.net/w18395770369/article/details/134617636

版权

文章介绍了如何使用Java反射API，通过`ConvertColumn`接口实现源对象字段到目标对象的转换，包括处理字段名匹配、字典查找和值赋值的过程。

摘要由CSDN通过智能技术生成


@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ConvertColumn {
    
    String field() default "";
    
    String dictKey() default "";
   
}

@SneakyThrows
    public static <T> void convert(T source, T target) {
        Class<?> targerClass = target.getClass();
        Field[] targerfields = targerClass.getDeclaredFields();
        Class<?> sourceClass = source.getClass();
        Field[] sourceFields = sourceClass.getDeclaredFields();
        for (Field targerfield : targerfields) {
            //设置允许通过反射访问私有变量
            targerfield.setAccessible(true);
            ConvertColumn annotation = targerfield.getAnnotation(ConvertColumn .class);
            if (annotation != null) {
                //获取对应字段名称
                String value = annotation.field();
                String dictKey = annotation.dictKey();
                if(StringUtil.isNotBlank(value)) {
                    for (Field sourceField : sourceFields) {
                        sourceField.setAccessible(true);
                        if (sourceField.getName().equals(value)) {
                            //获取当前字段数据
                            Object data = sourceField.get(source);
                            if (StringUtil.isNotBlank(dictKey)) {
                                String dictValue = findDictConver(dictKey, String.valueOf(data));
                                setPropertyVal(targerfield.getName(), target, dictValue);
                            } else {
                                setPropertyVal(targerfield.getName(), target, data);
                            }
                            break;
                        }
                    }
                }else{
                    //如果不存在字段转换，获取对应字典
                    if(StringUtil.isNotBlank(dictKey)){
                        Object data = targerfield.get(target);
                        String dictValue = findDictConver(dictKey, String.valueOf(data));
                        setPropertyVal(targerfield.getName(), target, dictValue);
                    }
                }
            }
        }
    }
    
    
    
    /**
     * 赋值数据
     * @param propertyName
     * @param target
     * @param data
     * @throws IntrospectionException
     * @throws IllegalAccessException
     * @throws InvocationTargetException
     */
    private static void setPropertyVal(String propertyName, Object target, Object data)
            throws IntrospectionException, IllegalAccessException, InvocationTargetException {
        PropertyDescriptor pd = new PropertyDescriptor(propertyName, target.getClass());
        Method setMethod = pd.getWriteMethod();
        setMethod.invoke(target, data);
    }
    
    /**
     * 查询字典转换数据
     * @param dictKey
     * @param dictValue
     * @return
     */
    private static String findDictConver(String dictKey, String dictValue) {
        return "暂时不查询字典";
    }