我们有一个对象，且包含很多属性值和方法，但是我们想把它的内部属性复制给一个新的对象时，我们如何去做呢？
 
你可能会说直接 a = b就可以了。
 
no no no，这样两个对象其实指针指向的还是一个内存中的对象，当一个发生变化的时候，另一个也是变化的，这并不是我们想要的结果。
 
那么，以三种方法来看看具体实现过程吧。
 
如下，有一个circle对象，其中包括一个属性值，一个属性方法
 
const circle = {
    radius: 1,
    draw() {
        console.log('draw');
    }
};
 
方法一：for in枚举对象
 
通过循环初始对象，得到每一个key以及所对应的值，然后把它赋值给新的对象
 
const newObj = {};

for(let key in circle) {
    newObj[key] = circle[key];
}
 
方法二：对象合并方法：
 
通过一个空对象和初始对象进行合并，赋值给新的对象
 
const newObj = Object.assign({}, circle);
 
方法三：es6扩展操作符
 
通过扩展操作符，找到circle的每一个属性然后赋值给新的对象
 
const newObj = { ...circle };
 
结果：
 
console.log(newObj)
 
 
这样就完成了复制对象的值的操作。
 
如有问题，请指出，接受批评。
 
个人微信公众号：
 

假设现在有需求如下：比较2个相同类型的不同对象，找到这2个对象的不同的地方，并展示记录一下。当然说的是相互对应的属性啦。
 
带着这个需求，看下面的例子。（我写代码的都不嫌弃长，你看代码的就也别嫌弃咯。）
 
 
package com.lxk.test;

import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.Dog;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;

/**
 * Compare the difference between two objects
 * <p>
 * Created by lxk on 2017/3/12
 */
public class CompareObject {
    public static void main(String[] args) {
        Dog dog1 = new Dog("大师兄的dog", true, true);
        Dog dog2 = new Dog("大师兄的dog", false, false);
        List<Dog> dogs = Lists.newArrayList();
        List<Dog> myDogs = Lists.newArrayList();
        dogs.add(dog1);
        myDogs.add(dog2);
        List<String> boys = Lists.newArrayList("tom", "jerry", "jack");
        //List<String> myBoys = Lists.newArrayList("tom", "jerry", "jack");//这行注释打开，下行代码注释掉，则boys属性就相同了
        List<String> myBoys = Lists.newArrayList("tom hanks", "gery", "pul");
        Car car1 = new Car("q7", 182, dogs, boys);
        Car car2 = new Car("a6", 152, myDogs, myBoys);
        contrastObj(car1, car2);
    }

    private static void contrastObj(Object obj1, Object obj2) {
        if (obj1 instanceof Car && obj2 instanceof Car) {
            Car pojo1 = (Car) obj1;
            Car pojo2 = (Car) obj2;
            List<String> textList = Lists.newArrayList();
            try {
                Class clazz = pojo1.getClass();
                Field[] fields = pojo1.getClass().getDeclaredFields();
                for (Field field : fields) {
                    PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
                    Method getMethod = pd.getReadMethod();
                    Object o1 = getMethod.invoke(pojo1);
                    Object o2 = getMethod.invoke(pojo2);
                    String s1 = o1 == null ? "" : o1.toString();//避免空指针异常
                    String s2 = o2 == null ? "" : o2.toString();//避免空指针异常
                    //思考下面注释的这一行：会bug的，虽然被try catch了，程序没报错，但是结果不是我们想要的
                    //if (!o1.toString().equals(o2.toString())) {
                    if (!s1.equals(s2)) {
                        textList.add("不一样的属性：" + field.getName() + " 属性值：[" + s1 + "," + s2 + "]");
                    }
                }
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
            for (Object object : textList) {
                System.out.println(object);
            }
        }
    }
}
 
 

 
 
代码里面使用的两个model，也是极为重要的。
 
Car的bean如下：
 
 
package com.lxk.model;

import java.util.List;

public class Car implements Comparable<Car> {
    private String sign;
    private int price;
    private List<Dog> myDog;
    private List<String> boys;

    public Car(String sign, int price) {
        this.sign = sign;
        this.price = price;
    }

    public Car(String sign, int price, List<Dog> myDog) {
        this.sign = sign;
        this.price = price;
        this.myDog = myDog;
    }

    public Car(String sign, int price, List<Dog> myDog, List<String> boys) {
        this.sign = sign;
        this.price = price;
        this.myDog = myDog;
        this.boys = boys;
    }

 //getter and setter

}

 Dog的bean如下： 
 
 
package com.lxk.model;

/**
 * 测试boolean属性的getter和setter
 * <p>
 * Created by lxk on 2016/12/23
 */
public class Dog {
    private String name;
    private boolean isLoyal;//是忠诚的
    private boolean alive;//活蹦乱跳的


    public Dog(boolean isLoyal, boolean alive) {
        this.isLoyal = isLoyal;
        this.alive = alive;
    }

    public Dog(String name, boolean isLoyal, boolean alive) {
        this.name = name;
        this.isLoyal = isLoyal;
        this.alive = alive;
    }

    //getter and setter

    //@Override
    //public boolean equals(Object o) {
    //    if (this == o) return true;
    //    if (!(o instanceof Dog)) return false;
    //    Dog dog = (Dog) o;
    //    return Objects.equal(getName(), dog.getName());
    //}
    //
    //@Override
    //public int hashCode() {
    //    return Objects.hashCode(getName());
    //}
}


 先不要在意，我为什么把Dog bean的hashcode和equal方法给注释啦先。 
 
如上代码的执行结果 图，如下：
 

 
 
从代码的执行情况看，可以得到，我们要的不同的属性的名称，当然你是可以把这些sign price myDog  boys这些属性，再次转化成你要的文字。
 
注意后面的对应的属性值。类型是String 或者int 或者List<String>这些类型，直接使用toString（）方法就可以把他转化成字符串了，但是看到myDog属性，这个自定义对象的list的toString（）的时候，却是两个地址，对，这个就是他们的内存堆地址吧。可以看到，2个集合所指向的引用是不一样的。
 

 
 
现在，看第二种情况，就是把Dog bean里面的注释，打开。其他地方的代码不动。
 
然后指向结果如下图：
 

 
 

 
 
可以看到，现在 myDog属性的值，竟然一样啦。但是，我们可以清楚的看到，我们的两个Car对象里面包含的Dog对象是不一样的。只是，这2个Car对象的两个Dog对象的name属性是一样的，都是：大师兄的dog。
 
因为，你在Dog bean里面已经重写了hashcode和equal两个方法，那么在new对象的时候，他就会只根据这个name属性去生成hashcode，他决定放在堆内存的什么位置。
 
那么就算，在我们看起来，那两个Car对象里面的两个Dog对象是不同的，但是计算机内存却认为是相同的。而且，toString（）方法得到的结果也是跟他的内存地址有关系的。所以，比较结果，就是一样的。
 
这就是意外。
 
在实际开发中，我们也会有这种情况，可能因为某种需要，我们把某个bean的hashcode和equal方法给重写了。就像我这里 的这个Dog类，但是这个类又在其他地方被使用了。他的不同也决定另外一个对象是不是相同的，就比如我要判断两个Car对象是不是相同的。用如上方法的话，那么就判断失败啦。
 
怎么应对呢？一般，当你发现你判断失败了，多半是自己测试出来的，我表示我当时就是自己测试出来的，后来发现就是写入hashcode和equal方法的属性相同了，他才相同，就想到了这一点。那么就直接再重写下toString（）方法，把你要比较的属性，都写在toString方法里面，这么一来。那个list类型的属性在toString之后就会变得不是内存地址啦
 
下面是我重写了toString（）方法的代码，以及又一次的执行结果。
 
 
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", isLoyal=" + isLoyal +
                ", alive=" + alive +
                '}';
    }

 
 

 
 

 
 这样，刚刚判断失败的地方，现在就完美的错过啦。 

 
 
最后，总结一下。
 
要想搞明白这个，你得知道：
 
1，为什么要重写 hashcode和equal，以及这2个方法的作用到底 是什么。
 
2，正确重写hashcode和equal的姿势。上面的是可以预防空指针的哟。哦，虽然是还是这个guava的工具包里面的东西。
 
（这个guava包这个方法被jdk1.7借鉴了，在java.util包里面也有这个方法，可以试一下）
 
2，当然了，这个重点还是反射的简单应用，我上面的那个问题，只是自己试验出来的问题，算是扩展问题。
 
关于代码里面的Lists 就是一个guava，Google的一个工具包，感兴趣的，可以查查，也是很涨姿势的。哦，也行你已经知道啦。
 

 
 

 
 

 
 
get_class_vars
 
 
获取类的公有属性及默认值（包含公有的静态属性），用来列举类的公有属性字段。
 
 
get_object_vars
 
 
获取对象的公有属性及属性值（不包含公有的静态属性）。
 
 
ReflectionClass
 
 
如果想要获取对象的各类属性（public/protected/private | static），就需要借助强大的反射类来完成了。 PHP 提供了 \ReflectionClass::class 可以帮助我们解析类的实例对象，通过 \ReflectionClass::getProperties方法获取对象所有的属性值。
 
 
实例
 
 
<?php

class Foo
{
    // 类常量
    const CLASS_NAME = "Foo";

    // 成员属性
    public $name;

    protected $sex = "female";

    private $age;

    // 类静态属性
    // php 的对象是可以访问类的 static 属性的
    // 但应该使用类的方式访问更为规范
    // const 属性只能通过类的方式访问
    public static $bar = "bar";

    public function __construct($name, $sex, $age)
    {
        $this->name = $name;
        $this->sex  = $sex;
        $this->age  = $age;
    }

    /**
     * 获取对象的属性字段及属性值
     * @param  [type]  $property_scope  属性域
     * @param  boolean $static_excluded 是否包含静态属性
     * @return array
     * @throws \ReflectionException|\Exception
     */
    public function getProperties($property_scope = null, $static_excluded = false)
    {
        // 校验反射域是否合法
        if (isset($property_scope) && !in_array($property_scope, [
            \ReflectionProperty::IS_STATIC,
            \ReflectionProperty::IS_PUBLIC,
            \ReflectionProperty::IS_PROTECTED,
            \ReflectionProperty::IS_PRIVATE,
        ])) {
            throw new Exception("reflection class property scope illegal!");
        }

        $properties_mapping = [];

        // 谈判官
        $classRef           = new \ReflectionClass($this);
        $properties         = isset($property_scope) ? $classRef->getProperties($property_scope) : $classRef->getProperties();

        foreach ($properties as $property) {
            // 为了兼容反射私有属性
            $property->setAccessible(true);

            // 当不想获取静态属性时
            if ($property->isStatic() && $static_excluded) {
                continue;
            }

            // 将得到的类属性同具体的实例绑定解析，获得实例上的属性值
            $properties_mapping[$property->getName()] = $property->getValue($this);
        }

        return $properties_mapping;
    }
}

$foo = new Foo("big_cat", "male", 29);

// 获取类的公有属性及默认值（包含静态属性）
var_dump(get_class_vars(get_class($foo)));

// 获取对象的公有属性及值（不包含类静态属性）
var_dump(get_object_vars($foo));

// 获取对象的静态属性
var_dump($foo->getProperties(\ReflectionProperty::IS_STATIC));
// 获取对象的公有属性 并排除静态属性
var_dump($foo->getProperties(\ReflectionProperty::IS_PUBLIC, true));
// 获取对象的保护属性
var_dump($foo->getProperties(\ReflectionProperty::IS_PROTECTED));
// 获取对象的私有属性
var_dump($foo->getProperties(\ReflectionProperty::IS_PRIVATE));
 
 
其他参考
 
 
/**
 * 获取类的常量属性
 * @see https://www.php.net/manual/en/reflectionclass.getconstants.php
 */
\ReflectionClass::getConstants()

/**
 * 获取类的方法
 * @see https://www.php.net/manual/en/reflectionclass.getmethods.php
 */
\ReflectionClass::getMethods()
 
 
转载于:https://my.oschina.net/sallency/blog/3074736

mybatis在传入对象时查询得对象属性值为空
 
当我们将一个对象(在这里我使用的是User对象)，将对象成功的传入到xml映射文件中并成功的返回了一个User对象，但是我发现对象的成功返回并没有将对象的属性值成功的返回，值都是null,于是我查阅资料有说是resultType和resultMap出现问题的，但我尝试后发现没有效果，后来我将我的User对象的实体类全部进行了改造，将属性名和数据库的表的字段名保持一致，问题解决。
 
 
 
具体代码:
 
 
 
 
 
 
欢迎关注我的微信公众号,更多内容将在微信公众号中发布：