1. Object.defineProperty() 

Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象。

备注：应当直接在 Object 构造器对象上调用此方法，而不是在任意一个 Object 类型的实例上调用。

语法：

Object.defineProperty(obj, prop, descriptor)

obj

要定义属性的对象。

prop

要定义或修改的属性的名称或 Symbol 。

descriptor

要定义或修改的属性描述符。

例子

在我们平常的使用中，给对象添加一个属性时，直接使用object.param的方式就可以了，或者直接在对象中挂载。

const person = {
    name: 'hj'
}

在ECMAScript5中，对每个属性都添加了几个属性类型，来描述这些属性的特点。他们分别是

• configurable:   默认false

configurable 特性表示对象的属性是否可以被删除，以及除 value 和 writable 特性外的其他特性是否可以被修改。

当第一次设置为false后，再改写是不可以的。属性值也是不能被删除的。

var o = {};
Object.defineProperty(o, 'a', {
  get() { return 1; },
  configurable: false
});
// 定义为false 后  enumerable set get configurable value 都是不能再设置了。 delete o.a 也是删不了的
Object.defineProperty(o, 'a', {
  configurable: true
}); // throws a TypeError  抛出错误
Object.defineProperty(o, 'a', {
  enumerable: true
}); // 抛出错误
Object.defineProperty(o, 'a', {
  set() {}
}); // 报错
Object.defineProperty(o, 'a', {
  get() { return 1; }
}); // throws a TypeError
// (even though the new get does exactly the same thing)
Object.defineProperty(o, 'a', {
  value: 12
}); // throws a TypeError // ('value' can be changed when 'configurable' is false but not in this case due to 'get' accessor)

console.log(o.a); // logs 1
delete o.a; // Nothing happens
console.log(o.a); // logs 1  还存在说明没删掉

• enumerable:  默认false

enumerable 定义了对象的属性是否可以在 for...in 循环和 Object.keys() 中被枚举。

for...in 循环和 Object.keys()  定义： 任意顺序遍历一个对象的除Symbol以外的可枚举属性。

var o = {};
Object.defineProperty(o, "a", { value : 1, enumerable: true });
Object.defineProperty(o, "b", { value : 2, enumerable: false });
Object.defineProperty(o, "c", { value : 3 }); // enumerable 默认为 false
o.d = 4; // 如果使用直接赋值的方式创建对象的属性，则 enumerable 为 true
Object.defineProperty(o, Symbol.for('e'), {
  value: 5,
  enumerable: true
});
Object.defineProperty(o, Symbol.for('f'), {
  value: 6,
  enumerable: false
});

for (var i in o) {
  console.log(i);
}
// 只会打印a 和 d 

Object.keys(o); // ['a', 'd']

打印 对象 o 在谷歌浏览器中查看 

o.propertyIsEnumerable('a'); // true
o.propertyIsEnumerable('b'); // false
o.propertyIsEnumerable('c'); // false
o.propertyIsEnumerable('d'); // true
o.propertyIsEnumerable(Symbol.for('e')); // true
o.propertyIsEnumerable(Symbol.for('f')); // false

var p = { ...o }
p.a // 1
p.b // undefined
p.c // undefined
p.d // 4
p[Symbol.for('e')] // 5
p[Symbol.for('f')] // undefined

• writable:  默认false

当 writable 属性设置为 false 时，该属性被称为“不可写的”。它不能被重新赋值。

var o = {}; // 创建一个新对象

Object.defineProperty(o, 'a', {
  value: 37,
  writable: false
});

console.log(o.a); //  37
o.a = 25; // No error thrown  不会抛出错误，但是也更改不了这个值，因为这个不是在严格模式下
// (it would throw in strict mode,
// even if the value had been the same)
console.log(o.a); // 还是37 

// strict mode
(function() {
  'use strict';
  var o = {};
  Object.defineProperty(o, 'b', {
    value: 2,
    writable: false
  });
  o.b = 3; // throws TypeError: "b" is read-only
  return o.b; // returns 2 without the line above
}());

•  value :  默认undefined

如果对象中不存在指定的属性，Object.defineProperty() 会创建这个属性。当描述符中省略某些字段时，这些字段将使用它们的默认值。

var o = {}; // 创建一个新对象

// 在对象中添加一个属性与数据描述符的示例
Object.defineProperty(o, "a", {
  value : 37,
  writable : true,
  enumerable : true,
  configurable : true
});

// 对象 o 拥有了属性 a，值为 37

// 在对象中添加一个设置了存取描述符属性的示例
var bValue;
Object.defineProperty(o, "b", {
  // 使用了方法名称缩写（ES2015 特性）
  // 下面两个缩写等价于：
  // get : function() { return bValue; },
  // set : function(newValue) { bValue = newValue; },
  get() { return bValue; },
  set(newValue) { bValue = newValue; },
  enumerable : true,
  configurable : true
});

o.b; // 38
// 对象 o 拥有了属性 b，值为 38
// 现在，除非重新定义 o.b，o.b 的值总是与 bValue 相同

// 数据描述符和存取描述符不能混合使用
Object.defineProperty(o, "conflict", {
  value: 0x9f91102,
  get() { return 0xdeadbeef; } 
});
// 抛出错误 TypeError: value appears only in data descriptors, get appears only in accessor descriptors

• get: 当我们通过person.name访问name的值时，get将被调用。该方法可以自定义返回的具体值是多少。get默认值为undefined
• set: 当我们通过person.name = 'Jake'设置name的值时，set方法将被调用。该方法可以自定义设置值的具体方式。set默认值为undefined

考虑特性被赋予的默认特性值非常重要，通常，使用点运算符和 Object.defineProperty() 为对象的属性赋值时，数据描述符中的属性默认值是不同的

var o = {};

o.a = 1;
// 默认做了下边这件事，等同于：
Object.defineProperty(o, "a", {
  value: 1,
  writable: true,
  configurable: true,
  enumerable: true
});


// 如果这样定义，
Object.defineProperty(o, "a", { value : 1 });
// 默认做了下边这件事，等同于：
Object.defineProperty(o, "a", {
  value: 1,
  writable: false,
  configurable: false,
  enumerable: false
});

需要注意的是，不能同时设置value、writable 与 get、set的值。

var person = {}

// 通过get与set自定义访问与设置name属性的方式
Object.defineProperty(person, 'name', {
    get: function() {
        // 一直返回TOM
        return 'TOM'
    },
    set: function(value) {
        // 设置name属性时，返回该字符串，value为新值
        console.log(value + ' in set');
    }
})

// 第一次访问name，调用get
console.log(person.name)   // TOM

// 尝试修改name值，此时set方法被调用
person.name = 'alex'   // alex in set

// 第二次访问name，还是调用get
console.log(person.name) // TOM

请尽量同时设置get、set。如果仅仅只设置了get，那么我们将无法设置该属性值。如果仅仅只设置了set，我们也无法读取该属性的值。

2.Object.defineProperties

当我们想要同时设置多个属性的特性时，需要使用Object.defineProperties

语法：  Object.defineProperties(obj, props)

参数说明

obj

在其上定义或修改属性的对象。

props

要定义其可枚举属性或修改的属性描述符的对象。对象中存在的属性描述符主要有两种：数据描述符和访问器描述符（更多详情，请参阅Object.defineProperty()）。描述符具有以下键：

configurable

true 当且仅当该属性描述符的类型可以被改变并且该属性可以从对应对象中删除。
默认为 false

enumerable

true 当且仅当在枚举相应对象上的属性时该属性显现。
默认为 false

value

与属性关联的值。可以是任何有效的JavaScript值（数字，对象，函数等）。
默认为 undefined.

writable

true当且仅当与该属性相关联的值可以用assignment operator改变时。
默认为 false

get

作为该属性的 getter 函数，如果没有 getter 则为undefined。函数返回值将被用作属性的值。
默认为 undefined

set

作为属性的 setter 函数，如果没有 setter 则为undefined。函数将仅接受参数赋值给该属性的新值。
默认为 undefined

用法除了格式基本与Object.defineProperty相同

var person = {}

Object.defineProperties(person, {
    name: {
        value: 'Jake',
        configurable: true
    },
    age: {
        get: function() {
            return this.value || 22
        },
        set: function(value) {
            this.value = value
        }
    }
})

person.name   // Jake
person.age    // 22

读取属性的特性值

我们可以使用Object.getOwnPropertyDescriptor方法读取某一个属性的特性值。

var person = {}

Object.defineProperty(person, 'name', {
    value: 'alex',
    writable: false,
    configurable: false
})

var descripter = Object.getOwnPropertyDescriptor(person, 'name');

console.log(descripter);  // 返回结果如下

descripter = {
    configurable: false,
    enumerable: false,
    value: 'alex',
    writable: false
}

商品业务对象定义：Product

Product product = new Product();
product.setId(1L);
product.setName("爱他美")
product.setProductDt("2022-03-16")

第一种：通过Alibaba Fastjson实现：

pom.xml 文件依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.66</version>
</dependency>

//Object转Map
Map map = JSONObject.parseObject(JSONObject.toJSONString(product), Map.class);
Map<String,Object> map = JSONObject.parseObject(JSON.toJSONString(product));
//Map转Object
Product productDto1 = JSON.parseObject(JSON.toJSONString(map), Product.class);
Product productDto2 = JSONObject.toJavaObject(JSON.toJSONString(map), Product.class);

第二种：通过SpringBoot自带 Jackso实现

一般情况下我们引入MVC，MVC里面帮我们引入了Jackso依赖

 <!-- springboot web(MVC)-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

最终的依赖：

ObjectMapper mapper = new ObjectMapper();
//对象转map
Map m = mapper.readValue(mapper.writeValueAsString(product), Map.class);
//map转对象
Product dto = mapper.readValue(mapper.writeValueAsString(m), Product.class);

 第三种：通过Apache common Bean工具类实现

Pom.xml文件依赖

<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.3</version>
</dependency>

#使用org.apache.commons.beanutils.BeanMap进行转换，实现Bean转Map
Map<String, Object> map = new org.apache.commons.beanutils.BeanMap(product);

#使用org.apache.commons.beanutils.BeanUtils将map转为对象
BeanUtils.populate(product, map);

 第四种： 通过反射实现

通过反射实现Bean 转Map

//Object转Map
public static Map<String, Object> getObjectToMap(Object obj) throws IllegalAccessException {
    Map<String, Object> map = new LinkedHashMap<String, Object>();
    Class<?> clazz = obj.getClass();
    System.out.println(clazz);
    for (Field field : clazz.getDeclaredFields()) {
        field.setAccessible(true);
        String fieldName = field.getName();
        Object value = field.get(obj);
        if (value == null){
            value = "";
        }
        map.put(fieldName, value);
    }
    return map;
}

通过反射实现Map转Bean

//Map转Object
public static Object mapToObject(Map<Object, Object> map, Class<?> beanClass) throws Exception {
    if (map == null)
        return null;
    Object obj = beanClass.newInstance();
    Field[] fields = obj.getClass().getDeclaredFields();
    for (Field field : fields) {
        int mod = field.getModifiers();
        if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
            continue;
        }
        field.setAccessible(true);
        if (map.containsKey(field.getName())) {
            field.set(obj, map.get(field.getName()));
        }
    }
    return obj;
}

一、Object.assign是什么？

首先了解下Object.assign()是什么。我们先看看ES6官方文档是怎么介绍的？

  Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。
  
  简单来说，就是Object.assign()是对象的静态方法，可以用来复制对象的可枚举属性到目标对象，利用这个特性可以实现对象属性的合并。

二、用法：

 Object.assign(target, ...sources)
 参数： target--->目标对象
       source--->源对象
       返回值：target，即目标对象

三、使用示例：

1、目标对象和源对象无重名属性

var target={name:'guxin',age:18};
var source={state:'single'}
var result=Object.assign(target,source);
console.log(target,target==result);

结果如图：

我们可以看到source上的state属性合并到了target对象上。如果只是想将两个或多个对象的属性合并到一起，不改变原有对象的属性，可以用一个空的对象作为target对象。像下面这样：

var result=Object.assign({},target,source);

2、目标对象和源对象有重名属性

上面的示例目标对象和源对象是没有重名属性的，那么如果他们有重名属性又会怎样呢？是后面的属性覆盖前面的还是前面的属性覆盖后面的呢？我们接下来看下一个例子：

var target={name:'guxin',age:18}
var source={state:'signle',age:22}
var result=Object.assign(target,source)
console.log(target)

我们来看下运行结果：

可以看到如果有同名属性的话，后面的属性值会覆盖前面的属性值。

3、有多个源对象

前面的示例都是只有一个源对象，那么如果有多个源对象情况会不会不同呢？我们继续看下面的例子：

        var target={name:'guxin',age:18}
        var source1={state:'signle',age:22}
        var source2={mood:'happy',age:25}
        var result=Object.assign(target,source1,source2)
        console.log(target)

我们来看下运行结果：

可以看到有多个源对象情况也是和一个源对象一样的。没有同名的属性会直接复制到目标对象上，同名的属性后面的属性值会覆盖前面的同名属性值。

四、注意事项：

1、Object.assign 方法只会拷贝源对象自身的并且可枚举的属性到目标对象，继承属性和不可枚举属性是不能拷贝的。

2、针对深拷贝，需要使用其他办法，因为 Object.assign()拷贝的是属性值。假如源对象的属性值是一个对象的引用，那么它也只指向那个引用。

3、目标对象自身也会改变

4、异常会打断后续拷贝任务

五、兼容性

目前IE浏览器不兼容Object.assign()，如果需要兼容IE的话最好不要直接使用这个方法。

六、与$.extend()的比较

我们通过一个简单的示例来比较两者有什么不同，

        var target={name:'guxin',age:18}
        var source1={state:'signle',age:22}
        var source2={mood:'happy',age:25}
        var result=Object.assign(target,source1,source2)
        console.log(target,'assign')
        var targetObj={name:'guxin',age:18}
        var sourceObj1={state:'signle',age:22}
        var sourceObj2={mood:'happy',age:25}
        var result=$.extend(targetObj,sourceObj1,sourceObj2)
        console.log(targetObj,'extend')

可以看到两者得到的结果是一样的。所以，我认为这两个方法，除了兼容性应该是一样的。

以上内容纯属个人理解，如有小伙伴发现错误之处欢迎指正！