springboot 标签体系实现

关于Spring中的BeanUtils的使用的细节和由此导致的巨坑

前言

本文研究关于spring带的BeanUtils的坑。

即 BeanUtils.copyProperties 的使用注意点

结论：

1. 字段名字要相同（完全相同包括大小写，其实应该是set-get方法名）
2. 类型要相同（primitive type和对应包装类同）
3. Source必须有getter，且必须public
4. Target必须有setter，且必须public
5. Source中的static字段则不行（例如static和static final的都不行）
6. Target中final的字段不会被赋值（例如Target中的final和static final字段）
7. Source或Target中，若有父类，父类中的字段是可以复制的
8. Source中内嵌的非普通类型的字段需要注意 （避免大坑）
   1）只是把Source中的引用给到Target，Target中改变会导致两边都变化
   2）List<A> 和 List<B> 转换是OK的，只是把引用交给了后者，要注意遍历的时候会发生类型转换异常

这里说的 “非普通类型” 可以理解为除了 8种原始类型（primitive type）+8中原始类型对应的包装类+String类之外的的引用类型

9. 其实还要注意下，如果有继承的情况下会发生什么事情（其实不会有大的问题，见后面，继承的字段也把它当做当前类的字段即可得到结论）

使用注意点

假设有个Source类，和一个Target类

Source转换到Target，一般除了基础类型的字段（这里说的 “基础类型” 是指8种原始类型、对应的包装类、String类型），如果包含有其他类型的，使用要十分谨慎!!!

• Source里的字段名和Target里的字段名，必须完全一样，这个能够转换的第一个条件
• Source里的字段类型和Target里的要严格相同，这是第二个条件

• Integer 类型转 Integer 是ok的
• int -> Integer (ok，原始类型和包装类是互通的)
• Integer -> int (ok)
• int -> long (not ok，同是整数仅范围不同，不行，必须严格相同类型)
• int -> Long (not ok)
• long -> int (not ok)
• long -> Integer (not ok)
• Dog -> Dog (ok)
• Animal -> Animal (ok)
• Dog -> Animal (not ok，即使是Dog继承Animal，不行，必须严格相同的类型)
• Animal -> Dog (not ok)
• List<A> -> List<B> (ok，非常大的坑，极其容易在后续使用时发生ClassCastException，参考后续的附录中的代码)

• Source里需要被拷贝的字段需要有getter，Target的字段，需要有setter，第三个条件
• Source里需要被拷贝的字段的getter，和Target里的setter，都只能是public的（protected/private/不写即default通通不行），第四个条件
• Source里的字段，不能是static的（含static final），第五条件
• Target里的字段，不能是final的（含static final），第六条件

注意：

1. BeanUtils是浅拷贝，不是深拷贝，只是把引用弄过去

例如：Source中有A类的字段field，Target中也有A类的字段field，则Source中的field和Target中的field将会是相同的对象（哈希码相同）

如果Source中有非普通字段，谨慎用BeanUtils，最好将内嵌的转换后再set到外层，不然很多坑!!!

2. Source里的父类的字段，也能被拷贝

举例

注意，无特别表示都表示Source有getter，Target有getter，且都是public的

Source	Target	是否可以拷贝
字段名：age	字段名：age2	否
字段类型：int	字段类型：int	是
字段类型：int	字段类型：Integer	是
字段类型：Integer	字段类型：int	是
字段类型：int	字段类型：Long	否
字段类型：int	字段类型：long	否
字段类型：Long	字段类型：int	否
字段类型：boolean	字段类型：boolean	是
字段类型：boolean	字段类型：Boolean	是
字段类型：Boolean	字段类型：boolean	是
字段类型：Dog（继承Animal）	字段类型：Animal	否
字段类型：List<A>	字段类型：List<B>	是。虽然有泛型，但能赋值过去，但存在严重隐患，见附录
字段类型：Boolean	字段类型：Boolean	是
Source继承Super1，Super1里有name字段	Target继承Super2，Super2里也有name字段	是
Source继承Super1，Super1里有name字段	Target里有name字段（不继承）	是
Source有name字段（不继承）	Target继承Super2，Super2里有name字段	是
字段修饰：static，如static Integer age	任意修饰符：如static/static final/普通类型/final	否。（不抛异常，但读取不了Source的static字段）
字段修饰：普通字段	任意修饰符：如static/普通类型(除final/static final)	是（但不能set到Target是final的）
字段修饰：final	任意修饰符：如static/普通类型(除final/static final)	是（但不能set到Target是final的）

3. Source中的serialVersionUID（就是Serializable要求的那个字段），会出现什么情况? 会覆盖Target中的吗? （好像不会吧，这个final的）（不会转过去，因为是static的）

附录

下面演示了一个巨大的坑

public class Test_A_Fucking_Problem {
    public static void main(String[] args) {
        Source source = new Source();
        Pet p1 = new Pet();
        p1.setName("dog");

        Pet p2 = new Pet();
        p2.setName("cat");

        List<Pet> petList = new ArrayList<>();
        petList.add(p1);
        petList.add(p2);
        source.setPetList(petList);

        Target target = new Target();
        BeanUtils.copyProperties(source, target);
        System.out.println("target:" + target + ",target.petList.hashCode:"
                + (target.getPetList() == null ? "未被赋值": target.getPetList().hashCode()) + ",petList.hashCode:" + petList.hashCode());

        // ★★需要非常注意的点，Source是List<A> 但是Target是List<B>，BeanUtils是可以把值赋值到target的，因为都是List类型，它不会管泛型不同的
        // 但是，赋值过去，实际上是把对象的引用引过去，也就是 `List<B> petList` 字段其实是被赋值了 `List<A> petList` 的实例，在下面运行的过程就出现类转换异常
        // get(0) 还不会出现异常，但是get(0)后再getName，则JVM需要弄清楚这个get(0)得到是什么类型，当发现类型跟声明的泛型类型不一样的时候，就抛出了运行时异常（ClassCast...)
        System.out.println(target.getPetList().get(0));
        System.out.println(target.getPetList().get(0).getName());

    }
}

public class Source {
    private List<Pet> petList;

    public List<Pet> getPetList() {
        return petList;
    }

    public void setPetList(List<Pet> petList) {
        this.petList = petList;
    }
}

public class Target {
    private List<Pet2> petList;

    public List<Pet2> getPetList() {
        return petList;
    }

    public void setPetList(List<Pet2> petList) {
        this.petList = petList;
    }
}

public class Pet {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Pet2 {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}