js对象赋值，如何把原来的属性保留并修改，如果有新属性就追加新属性呢

在JS中，可以使用对象展开语法来实现将原有属性保留并修改，同时追加新属性的操作。具体实现方式如下：

const oldObj = {
  name: '张三',
  age: 20,
  gender: '男'
}

const newObj = {
  ...oldObj, // 使用展开语法展开原有属性
  age: 21, // 修改原有属性
  address: '北京市海淀区' // 追加新属性
}

console.log(newObj) // {name: "张三", age: 21, gender: "男", address: "北京市海淀区"}

在上面的代码中，我们首先定义了一个 `oldObj` 对象，它有三个属性：`name`、`age` 和 `gender`。接着，我们使用对象展开语法将 `oldObj` 对象展开，将其原有属性赋值给 `newObj` 对象，然后对 `age` 属性进行修改，最后追加了一个新的 `address` 属性。最终输出了 `newObj` 对象。

这样，我们就实现了将原有属性保留并修改，同时追加新属性的操作。

相关问题

java cglib 为原始对象添加新属性并赋值工具类

Java中的cglib库可以用于动态生成Java类，可以通过cglib为一个原始对象添加新属性并赋值。下面是一个简单的工具类，可以为一个对象添加新属性并赋值：

import net.sf.cglib.beans.BeanGenerator;
import net.sf.cglib.core.NamingPolicy;
import net.sf.cglib.core.Predicate;
import net.sf.cglib.core.Visibility;

import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

public class CglibUtils {

    /**
     * 为一个对象动态添加属性
     *
     * @param target    原始对象
     * @param fieldName 属性名
     * @param value     属性值
     * @return 新对象，新对象包含原始对象的所有属性和新添加的属性
     */
    public static Object addField(Object target, String fieldName, Object value) {
        // 创建一个BeanGenerator对象，用于动态生成Java类
        BeanGenerator generator = new BeanGenerator();
        // 设置要生成的Java类的父类，即原始对象的类
        generator.setSuperclass(target.getClass());
        // 添加新属性，属性名为fieldName，属性值类型为value的类型
        generator.addProperty(fieldName, value.getClass());
        // 使用默认的命名策略生成类名
        generator.setNamingPolicy(new NamingPolicy() {
            @Override
            public String getClassName(String s, String s1, Object o, Predicate predicate) {
                return target.getClass().getSimpleName() + "$$" + fieldName + "$$" + o.hashCode();
            }
        });
        // 创建新的Java类，并实例化对象
        Object newObject = generator.create();
        // 获取新对象的属性名和值，构造属性名和值的Map
        Map<String, Object> properties = new HashMap<String, Object>();
        properties.put(fieldName, value);
        for (java.beans.PropertyDescriptor property : java.beans.Introspector.getBeanInfo(newObject.getClass()).getPropertyDescriptors()) {
            String propertyName = property.getName();
            if (!"class".equals(propertyName)) {
                try {
                    Object propertyValue = property.getReadMethod().invoke(target);
                    properties.put(propertyName, propertyValue);
                } catch (Exception e) {
                    // ignore exception
                }
            }
        }
        // 使用BeanUtils的populate方法，将属性名和值的Map中的所有属性值赋值给新对象
        try {
            org.apache.commons.beanutils.BeanUtils.populate(newObject, properties);
        } catch (Exception e) {
            // ignore exception
        }
        return newObject;
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        // 创建一个Person对象
        Person person = new Person("张三", 18);
        System.out.println("原始对象：" + person);
        // 为Person对象添加新属性，并赋值
        Object newObject = CglibUtils.addField(person, "email", "zhangsan@qq.com");
        System.out.println("新对象：" + newObject);
    }
}

输出结果：

原始对象：Person{name='张三', age=18}
新对象：Person$$email$$-2086562992@6d5380c2{name='张三', age=18, email='zhangsan@qq.com'}

java cglib动态给原始对象添加新属性并赋值工具类

在Java中，使用CGLIB动态代理可以在运行时动态地创建类和对象。通过动态代理，可以为原始对象添加新属性并为其赋值。下面是一个使用CGLIB动态代理实现动态添加属性的工具类示例：

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import net.sf.cglib.beans.BeanGenerator;
import net.sf.cglib.beans.BeanMap;

public class DynamicBeanUtil {

    /**
     * 创建动态Bean
     * 
     * @param propertyMap
     *            属性集合
     * @return Object 动态生成的Bean
     * @throws Exception
     */
    public static Object createBean(Map<String, Class<?>> propertyMap) throws Exception {
        BeanGenerator generator = new BeanGenerator();
        for (String key : propertyMap.keySet()) {
            generator.addProperty(key, propertyMap.get(key));
        }
        return generator.create();
    }

    /**
     * 给动态Bean的属性赋值
     * 
     * @param bean
     *            动态Bean
     * @param propertyMap
     *            属性集合
     * @throws Exception
     */
    public static void setBeanValue(Object bean, Map<String, Object> propertyMap) throws Exception {
        BeanMap beanMap = BeanMap.create(bean);
        for (String key : propertyMap.keySet()) {
            beanMap.put(key, propertyMap.get(key));
        }
    }

    /**
     * 获取动态Bean的属性值
     * 
     * @param bean
     *            动态Bean
     * @param propertyName
     *            属性名
     * @return Object 属性值
     * @throws Exception
     */
    public static Object getBeanValue(Object bean, String propertyName) throws Exception {
        BeanMap beanMap = BeanMap.create(bean);
        PropertyDescriptor descriptor = beanMap.getPropertyDescriptor(propertyName);
        Method getter = descriptor.getReadMethod();
        return getter.invoke(bean);
    }

    /**
     * 获取动态Bean的所有属性值
     * 
     * @param bean
     *            动态Bean
     * @return Map<String, Object> 属性值集合
     */
    public static Map<String, Object> getBeanValues(Object bean) {
        Map<String, Object> values = new HashMap<String, Object>();
        BeanMap beanMap = BeanMap.create(bean);
        for (Object key : beanMap.keySet()) {
            values.put(key.toString(), beanMap.get(key));
        }
        return values;
    }

    /**
     * 给原始对象动态添加新属性并赋值
     * 
     * @param obj
     *            原始对象
     * @param propertyName
     *            新属性名
     * @param value
     *            新属性值
     * @throws Exception
     */
    public static void addProperty(Object obj, String propertyName, Object value) throws Exception {
        Class<?> clazz = obj.getClass();
        Field field = clazz.getDeclaredField(propertyName);
        field.setAccessible(true);

        // 获取原始对象的属性值集合
        Map<String, Object> values = getBeanValues(obj);

        // 创建新的属性值集合，并将新属性添加到集合中
        Map<String, Class<?>> propertyMap = new HashMap<String, Class<?>>(values.size() + 1);
        for (String key : values.keySet()) {
            propertyMap.put(key, values.get(key).getClass());
        }
        propertyMap.put(propertyName, value.getClass());

        // 创建新的动态Bean并赋值
        Object bean = createBean(propertyMap);
        setBeanValue(bean, values);
        setBeanValue(bean, new HashMap<String, Object>() {
            {
                put(propertyName, value);
            }
        });

        // 将动态Bean的属性值赋给原始对象
        field.set(obj, beanMap.get(propertyName));
    }
}

使用示例：

public class Person {
    private String name;
    private int age;
    // 省略getter和setter方法
}

// 创建原始对象
Person p = new Person();
p.setName("Tom");
p.setAge(20);

// 给原始对象动态添加新属性并赋值
DynamicBeanUtil.addProperty(p, "gender", "male");

// 获取新属性的值
System.out.println(p.getGender()); // 输出：male

在上面的示例中，我们使用了DynamicBeanUtil工具类给原始对象Person动态添加了新属性gender，并为其赋值为male。最后，我们通过调用Person的getter方法获取到了新属性的值。