java修改对象属性值工具类，两个对象信息互换工具类

一、修改对象属性

效果：

/**
     * Description:
     * date: 2020/11/26
     * 修改对象的属性 更新信息工具类
     * @param : tClass 实体类class
     * @param : fieldName 实体类属性名
     * @param : values 修改的内容
     * @return : 失败返回hashMap格式;成功返回实体类
     * @author: qkj
     */

    public static Object modifyEntityInfo(Class<?> tClass, String fieldName, Object values) throws Exception {
        Method[] declaredMethods = tClass.getDeclaredMethods();
        int length = declaredMethods.length;
        Constructor<?> constructor = tClass.getConstructor();
        Object instance = constructor.newInstance();
        List<String> methodNameList = new ArrayList<String>();

        for (int i = 0; i < length; i++) {
            declaredMethods[i].setAccessible(true);
            methodNameList.add(declaredMethods[i].getName().toUpperCase());
        }
        boolean contains = methodNameList.contains("SET" + fieldName.toUpperCase());

        if (!contains) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("errorMsg", "字段名错误或者实体类不存在set方法");
            return map;
        } else {
            Method realMethod = null;
            for (int i = 0; i < length; i++) {
                declaredMethods[i].setAccessible(true);
                if (declaredMethods[i].getName().equalsIgnoreCase("SET" + fieldName)) {
                    realMethod = declaredMethods[i];
                    break;
                }
            }

            realMethod.invoke(instance, values);

            return instance;

        }

    }

二、对象互换属性值

实际应用场景：属性值互换 并忽略某几项（例如id不用互换）
将动态参数，反射，动态代理，反序列化，深拷贝结合在一起的一个方法

//注意需要jackson包  或者自己将实体类继承序列化、克隆等接口也行，深拷贝时用到,将深拷贝部分的代码重新写一下
import com.fasterxml.jackson.databind.ObjectMapper;
  /**
     * Description: 对象信息互换
     * date: 2020/11/26
     * @param : object1 object2互换对象
     * @param : ...param 需要忽略互换的字段
     * @return : 失败返回hashMap格式;成功返回实体类list
     * @author: qkj
     */

    public static Object exchangeEntityInfo(Object object1, Object object2, Object... param) throws Exception {
        Class aClass1 = object1.getClass();
        Class aClass2 = object2.getClass();

        if (aClass1 != aClass2) {
            Map<String,String> map = new HashMap<String, String>();
            map.put("error", "类型不一致");
            return map;
        }

        ObjectMapper objectMapper = new ObjectMapper();
        Object temp1 = objectMapper.readValue(objectMapper.writeValueAsString(object1), object1.getClass());
        Object temp2 = objectMapper.readValue(objectMapper.writeValueAsString(object2), object2.getClass());

        object1 = object2;
        object2 = temp1;

        // 所有属性
        Field[] declaredFields = object1.getClass().getDeclaredFields();
        // 所有方法
        Method[] declaredMethods = object1.getClass().getDeclaredMethods();

        ArrayList<Object> objects = new ArrayList<>();
        // 循环无需替换的参数
        for (int i = 0; i < param.length; i++) {
            // 循环交换后对象的方法
            for (Method method : declaredMethods) {
                method.setAccessible(true);
                // 如果方法名相等 则把旧数据set回去
                if (method.getName().equalsIgnoreCase("SET" + param[i])) {
                    for (Field field : declaredFields) {
                        if (field.getName().equals(param[i])) {
                            method.invoke(object1, field.get(temp1));
                        }
                    }

                    for (Field field : declaredFields) {
                        if (field.getName().equals(param[i])) {
                            method.invoke(object2, field.get(temp2));
                        }
                    }

                }
            }
        }

        objects.add(object1);
        objects.add(object2);

        return objects;
    }