源码解读之（七）BeanUtils.copyProperties

Love The Way You Lie 2023-05-28 11:11 46阅读 0赞

## 一、前言 ##

关于对象的复制我们有好几种方式，最近在做推荐系统，有这样的一个功能点，根据手机的唯一标识`imei`，`copy` 目标手机的 `imei`，置换`imei` 画像。这种复制、克隆另一个对象的属性在我们后台开发经常遇得到。我这里提供两种方式：

**1、实现Cloneable接口重写clone()方法**

public class Image implements Cloneable { 
        private String newsId;
        private String title;
        private boolean isVideo;
        private Double showTime;
        private String tag;
        private String topicVex;
        private String classification;
        private String subClassification;
    
        public Image() { 
        }
    
        // Get、Set方法省略
    
        @Override
        public Object clone() { 
            Image image = null;
            try{ 
                image = (Image) super.clone();
            }catch(CloneNotSupportedException e) { 
                e.printStackTrace();
            }
            return image;
        }
    
    }

public class CopyTest { 
        public static void main(String[] args) { 
            Image image = new Image();
            image.setNewsId("1001");
            image.setTitle("全明星正赛 勒布朗队-字母哥队");
            image.setVideo(true);
            image.setShowTime(109.48);
            image.setTag("NBA");
            image.setTopicVex("东西部对决");
            image.setClassification("NBA");
            image.setSubClassification("全明星赛");
    
            Image imageClone = (Image) image.clone();
            System.out.println(imageClone.toString());
        }
    }

输出结果：

Image{ newsId='1001', title='全明星正赛 勒布朗队-字母哥队', isVideo=true, showTime=109.48, tag='NBA', topicVex='东西部对决', classification='NBA', subClassification='全明星赛'}

**2、org.springframework.beans.BeanUtils 包里的 BeanUtils.copyProperties**

public class Image2 { 
        private String newsId;
        private String title;
        private boolean isVideo;
        private Double showTime;
        private String tag;
    
        public Image2() { 
        }
    	
    	// Get、Set方法省略
    }

public class CopyTest { 
        public static void main(String[] args) { 
            Image image = new Image();
            image.setNewsId("1001");
            image.setTitle("全明星正赛 勒布朗队-字母哥队");
            image.setVideo(true);
            image.setShowTime(109.48);
            image.setTag("NBA");
            image.setTopicVex("东西部对决");
            image.setClassification("NBA");
            image.setSubClassification("全明星赛");
    
            Image2 targetImage = new Image2();
            BeanUtils.copyProperties(image, targetImage);
            System.out.println(targetImage.toString());
        }
    }

输出结果：

Image2{ newsId='1001', title='全明星正赛 勒布朗队-字母哥队', isVideo=true, showTime=109.48, tag='NBA'}

这两种方式的输出结果，小伙伴们应该也发现了。第二种方式输出的字段少了一些，这是因为 Image2 里的字段属性比 Image 少几个。

**3、小结**

如果你的目标对象不需要复制源对象中的所有属性的话，你就用 `BeanUtils.copyProperties`，否则用`clone()`方法就能满足。

## 二、源码解析 ##

本篇的重点是第二种方式，下面我们就来从源码层面来分析，博主用的是 `JDK 1.8`。

// 将给定源bean的属性值赋值到目标bean中
    public static void copyProperties(Object source, Object target, String... ignoreProperties) throws BeansException { 
       copyProperties(source, target, (Class)null, ignoreProperties);
    }
    
    private static void copyProperties(Object source, Object target, @Nullable Class<?> editable, @Nullable String... ignoreProperties) throws BeansException { 
        Assert.notNull(source, "Source must not be null");
        Assert.notNull(target, "Target must not be null");
        Class<?> actualEditable = target.getClass();
        if (editable != null) { 
            if (!editable.isInstance(target)) { 
                throw new IllegalArgumentException("Target class [" + target.getClass().getName() + "] not assignable to Editable class [" + editable.getName() + "]");
            }
    
            actualEditable = editable;
        }
    	
    	// 1、调用Java内省API，获取PropertyDescriptor。
        PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
        List<String> ignoreList = ignoreProperties != null ? Arrays.asList(ignoreProperties) : null;
        PropertyDescriptor[] var7 = targetPds;
        int var8 = targetPds.length;
    	
    	// 2、轮询目标bean的PropertyDescriptor
        for(int var9 = 0; var9 < var8; ++var9) { 
            PropertyDescriptor targetPd = var7[var9];
            Method writeMethod = targetPd.getWriteMethod();
            // 判断是否存在setter方法以及属性是否在需要忽略的属性列表中
            if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) { 
                // 获取源bean的PropertyDescriptor
                PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
                if (sourcePd != null) { 
                    // 获取源bean的PropertyDescriptor
                    Method readMethod = sourcePd.getReadMethod();
                    // 判断是否可赋值
                    if (readMethod != null && ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) { 
                        try { 
                            // 如果getter方法不是public,则需要设置其accessible
                            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) { 
                                readMethod.setAccessible(true);
                            }
                            // 通过反射获取source对象属性的值
                            Object value = readMethod.invoke(source);
                            // 如果setter方法不是public则需要设置其accessible
                            if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) { 
                                writeMethod.setAccessible(true);
                            }
    						// 通过反射给target对象属性赋值
                            writeMethod.invoke(target, value);
                        } catch (Throwable var15) { 
                            throw new FatalBeanException("Could not copy property '" + targetPd.getName() + "' from source to target", var15);
                        }
                    }
                }
            }
        }
    
    }

**1、断言判空**

Assert.notNull(source, "Source must not be null");
    Assert.notNull(target, "Target must not be null");

public static void notNull(@Nullable Object object, String message) { 
        if (object == null) { 
            throw new IllegalArgumentException(message);
        }
    }

断言判空就没什么好说的，值为`null`的话，直接把`message`作为异常抛出去。

**2、PropertyDescriptor\[\] targetPds = getPropertyDescriptors(actualEditable);**

`java`内省优化工具类`BeanUtils`（优化内省并防止内存泄漏）

`Spring`中专门提供了用于缓存`JavaBean`的`PropertyDescriptor`描述信息的类——`CachedIntrospectionResults`。但它的`forClass()`（获取对象）访问权限时`default`，不能被应用代码直接使用。但是可以通过`org.springframework.beans.BeanUtils`工具类来使用。

public static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz) throws BeansException { 
        // 工厂模式，获取到对应的CachedIntrospectionResults对象
        CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);
        return cr.getPropertyDescriptors();
    }

`CachedIntrospectionResults`这个类使用的是工厂模式，通过`forClass()`方法暴露缓存，获取到不同的`CachedIntrospectionResults`对象。

实际上使用的是`ConcurrentHashMap`进行存储，`key`就是`Class`对象，而`value`是`CachedIntrospectionResults`对象。

static CachedIntrospectionResults forClass(Class<?> beanClass) throws BeansException { 
        // 从缓存中获取CachedIntrospectionResults(强引用)
        CachedIntrospectionResults results = (CachedIntrospectionResults)strongClassCache.get(beanClass);
        if (results != null) { 
            return results;
        } else { 
            // 从缓存中获取CachedIntrospectionResults(软引用)
            results = (CachedIntrospectionResults)softClassCache.get(beanClass);
            if (results != null) { 
                return results;
            } else { 
            	// 构造CachedIntrospectionResults
                results = new CachedIntrospectionResults(beanClass);
                ConcurrentMap classCacheToUse;
                // 确保Spring框架的jar包和应用类的jar包使用的是同一个ClassLoader加载的。
                // 若是多类加载器的应用，判断应用类使用的类加载器是否是安全的。
                if (!ClassUtils.isCacheSafe(beanClass, CachedIntrospectionResults.class.getClassLoader()) && !isClassLoaderAccepted(beanClass.getClassLoader())) { 
                    if (logger.isDebugEnabled()) { 
                        logger.debug("Not strongly caching class [" + beanClass.getName() + "] because it is not cache-safe");
                    }
    
                    classCacheToUse = softClassCache;
                } else { 
                    classCacheToUse = strongClassCache;
                }
    
                CachedIntrospectionResults existing = (CachedIntrospectionResults)classCacheToUse.putIfAbsent(beanClass, results);
                return existing != null ? existing : results;
            }
        }
    }

**3、strongClassCache与softClassCache**

我们可以看到此处具有两个缓存：`strongClassCache`与`softClassCache`，那它俩什么区别呢？

首先我们看下它们的定义：

static final ConcurrentMap<Class<?>, CachedIntrospectionResults> strongClassCache = new ConcurrentHashMap(64);
    static final ConcurrentMap<Class<?>, CachedIntrospectionResults> softClassCache = new ConcurrentReferenceHashMap(64);

> ConcurrentReferenceHashMap可以指定对应的引用级别，其内部采用分段锁实现，与jdk1.7的ConcurrentMap的实现原理类似。

`strongClassCache`中持有的缓存是强引用，而`softClassCache`持有的缓存是软引用 (`JDK`有4中引用级别，分别是强引用，软引用,弱引用以及虚引用，引用级别体现在决定`GC`的时候持有的实例被回收的时机)。

`strongClassCache`用于缓存`cache-safe`的`bean class`数据，而`softClassCache`用于缓存`none-cache-safe`的`bean class`数据；

`strongClassCache`中的数据与`spring application`的生命周期一致，而`softClassCache`的生命周期则`不由spring进行管理`，因此为了防止因`classloader`提前关闭导致`内存泄漏`，此处采用软引用进行缓存。

那什么样的数据会被`cache`在`strongClassCache`中呢？`beanClass`的`ClassLoader`与当前相同时或者与程序指定的`ClassLoader`相同时会被存储于`strongClassCache`，其余均为存储于`softClassCache`中。

如果从以上`cache`中没有拿到数据，那么会`new CachedIntrospectionResults(Class)`，相应的调用`Java Introspector`的相关`API`均在此构造函数中：

private CachedIntrospectionResults(Class<?> beanClass) throws BeansException { 
        try { 
            if (logger.isTraceEnabled()) { 
                logger.trace("Getting BeanInfo for class [" + beanClass.getName() + "]");
            }
    		
            this.beanInfo = getBeanInfo(beanClass);
            if (logger.isTraceEnabled()) { 
                logger.trace("Caching PropertyDescriptors for class [" + beanClass.getName() + "]");
            }
    
            this.propertyDescriptorCache = new LinkedHashMap();
            // 考虑到性能原因，对于每个PropertyDescriptor只处理一次
            PropertyDescriptor[] pds = this.beanInfo.getPropertyDescriptors();
            PropertyDescriptor[] var3 = pds;
            int var4 = pds.length;
    
            for(int var5 = 0; var5 < var4; ++var5) { 
                PropertyDescriptor pd = var3[var5];
                if (Class.class != beanClass || !"classLoader".equals(pd.getName()) && !"protectionDomain".equals(pd.getName())) { 
                    if (logger.isTraceEnabled()) { 
                        logger.trace("Found bean property '" + pd.getName() + "'" + (pd.getPropertyType() != null ? " of type [" + pd.getPropertyType().getName() + "]" : "") + (pd.getPropertyEditorClass() != null ? "; editor [" + pd.getPropertyEditorClass().getName() + "]" : ""));
                    }
    				// 重新包装为GenericTypeAwarePropertyDescriptor
                    pd = this.buildGenericTypeAwarePropertyDescriptor(beanClass, pd);
                    this.propertyDescriptorCache.put(pd.getName(), pd);
                }
            }
    
            for(Class currClass = beanClass; currClass != null && currClass != Object.class; currClass = currClass.getSuperclass()) { 
                this.introspectInterfaces(beanClass, currClass);
            }
    
            this.typeDescriptorCache = new ConcurrentReferenceHashMap();
        } catch (IntrospectionException var7) { 
            throw new FatalBeanException("Failed to obtain BeanInfo for class [" + beanClass.getName() + "]", var7);
        }
    }

这段代码主要的作用就是通过内省接口得到`BeanInfo`，然后将`PropertyDescriptor`缓存起来。具体流程如下：

**4、首先通过`BeanInfoFactory`获取`BeanInfo`; 这里默认注册时`BeanInfoFactory`是`ExtendedBeanInfoFactory`, 此类主要处理包含一些特殊`set`方法的`bean`**

private static BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException { 
        Iterator var1 = beanInfoFactories.iterator();
    
        BeanInfo beanInfo;
        // 对一些特殊的set方法(setA(int index, Object a))或者list的set方法进行处理
        do { 
            if (!var1.hasNext()) { 
                // fallback到默认获取BeanInfo的方式
                return shouldIntrospectorIgnoreBeaninfoClasses ? Introspector.getBeanInfo(beanClass, 3) : Introspector.getBeanInfo(beanClass);
            }
    
            BeanInfoFactory beanInfoFactory = (BeanInfoFactory)var1.next();
            beanInfo = beanInfoFactory.getBeanInfo(beanClass);
        } while(beanInfo == null);
    
        return beanInfo;
    }

@Nullable
    public BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException { 
        return this.supports(beanClass) ? new ExtendedBeanInfo(Introspector.getBeanInfo(beanClass)) : null;
    }

private boolean supports(Class<?> beanClass) { 
        Method[] var2 = beanClass.getMethods();
        int var3 = var2.length;
    
        for(int var4 = 0; var4 < var3; ++var4) { 
            Method method = var2[var4];
            if (ExtendedBeanInfo.isCandidateWriteMethod(method)) { 
                return true;
            }
        }
    
        return false;
    }

public static boolean isCandidateWriteMethod(Method method) { 
        String methodName = method.getName();
        Class<?>[] parameterTypes = method.getParameterTypes();
        int nParams = parameterTypes.length;
        return methodName.length() > 3 && methodName.startsWith("set") && Modifier.isPublic(method.getModifiers()) && (!Void.TYPE.isAssignableFrom(method.getReturnType()) || Modifier.isStatic(method.getModifiers())) && (nParams == 1 || nParams == 2 && Integer.TYPE == parameterTypes[0]);
    }

如果一个bean中包含这么一个方法：以set开头 &&（返回值不为void || 是静态方法) && (具有一个参数 || 有两个参数其中第一个参数是int), 形如：

// void.class.isAssignableFrom(method.getReturnType()) 方法返回值不为void
    public Bean setFoo(Foo foo) { 
        this.foo = foo;
        return this;
    }
    public static void setFoos(Foo foo) { 
        Bean.foo = foo;
    }
    public Bean setFoos(int index, Foo foo) { 
        this.foos.set(index, foo);
        return this;
    }

**5、如果该`bean`不包含以上的方法，则直接采用`Java`的`内省API`获取`BeanInfo`**

当获取到`BeanInfo`之后就可以对`PropertyDescriptor`进行缓存了；这里会将`PropertyDescriptor`重新包装为`GenericTypeAwarePropertyDescriptor`, 进行这样封装的原因是为了重新处理`BridgeMethod`, 通俗点讲，就是处理当前类继承了泛型类或者实现泛型接口，那怎么识别这些方法呢？

private PropertyDescriptor buildGenericTypeAwarePropertyDescriptor(Class<?> beanClass, PropertyDescriptor pd) { 
        try { 
            return new GenericTypeAwarePropertyDescriptor(beanClass, pd.getName(), pd.getReadMethod(), pd.getWriteMethod(), pd.getPropertyEditorClass());
        } catch (IntrospectionException var4) { 
            throw new FatalBeanException("Failed to re-introspect class [" + beanClass.getName() + "]", var4);
        }
    }

public GenericTypeAwarePropertyDescriptor(Class<?> beanClass, String propertyName, @Nullable Method readMethod, @Nullable Method writeMethod, Class<?> propertyEditorClass) throws IntrospectionException { 
        super(propertyName, (Method)null, (Method)null);
        this.beanClass = beanClass;
        Method readMethodToUse = readMethod != null ? BridgeMethodResolver.findBridgedMethod(readMethod) : null;
        Method writeMethodToUse = writeMethod != null ? BridgeMethodResolver.findBridgedMethod(writeMethod) : null;
        if (writeMethodToUse == null && readMethodToUse != null) { 
            Method candidate = ClassUtils.getMethodIfAvailable(this.beanClass, "set" + StringUtils.capitalize(this.getName()), (Class[])null);
            if (candidate != null && candidate.getParameterCount() == 1) { 
                writeMethodToUse = candidate;
            }
        }
    
        this.readMethod = readMethodToUse;
        this.writeMethod = writeMethodToUse;
        if (this.writeMethod != null) { 
            if (this.readMethod == null) { 
                Set<Method> ambiguousCandidates = new HashSet();
                Method[] var9 = beanClass.getMethods();
                int var10 = var9.length;
    
                for(int var11 = 0; var11 < var10; ++var11) { 
                    Method method = var9[var11];
                    if (method.getName().equals(writeMethodToUse.getName()) && !method.equals(writeMethodToUse) && !method.isBridge() && method.getParameterCount() == writeMethodToUse.getParameterCount()) { 
                        ambiguousCandidates.add(method);
                    }
                }
    
                if (!ambiguousCandidates.isEmpty()) { 
                    this.ambiguousWriteMethods = ambiguousCandidates;
                }
            }
    
            this.writeMethodParameter = new MethodParameter(this.writeMethod, 0);
            GenericTypeResolver.resolveParameterType(this.writeMethodParameter, this.beanClass);
        }
    
        if (this.readMethod != null) { 
            this.propertyType = GenericTypeResolver.resolveReturnType(this.readMethod, this.beanClass);
        } else if (this.writeMethodParameter != null) { 
            this.propertyType = this.writeMethodParameter.getParameterType();
        }
    
        this.propertyEditorClass = propertyEditorClass;
    }

`Bridge Method`: 桥接方法是`JDK`引入泛型后为了与之前的`JDK`版本兼容，在编译时自动生成的方法。桥接方法的字节码`Flag`会被标记为`ACC_BRIDGE` (桥接方法) 和`ACC_SYNTHETIC` (由编译器生成)。通过`Method.isBridge()`来判断一个方法是否为`BridgeMethod`。如果一个方法覆写了泛型父类或者实现了泛型接口则会生成`bridge method`。

public static Method findBridgedMethod(Method bridgeMethod) { 
        if (!bridgeMethod.isBridge()) { 
            return bridgeMethod;
        } else { 
            // 获取所有与bridgeMethod名称、参数数量相匹配的方法(包括父类)
            List<Method> candidateMethods = new ArrayList();
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(bridgeMethod.getDeclaringClass());
            Method[] var3 = methods;
            int var4 = methods.length;
    
            for(int var5 = 0; var5 < var4; ++var5) { 
                Method candidateMethod = var3[var5];
                // candidateMethod是`Bridge Method`时将其加入候选方法列表
                if (isBridgedCandidateFor(candidateMethod, bridgeMethod)) { 
                    candidateMethods.add(candidateMethod);
                }
            }
    
            if (candidateMethods.size() == 1) { 
                return (Method)candidateMethods.get(0);
            } else { 
                // 在众候选方法中找到其BridgeMethod，如果找不到返回原方法
                Method bridgedMethod = searchCandidates(candidateMethods, bridgeMethod);
                if (bridgedMethod != null) { 
                    return bridgedMethod;
                } else { 
                    return bridgeMethod;
                }
            }
        }
    }

当进行完以上步骤后，我们就拿到了缓存有内省结果的`CachedIntrospectionResults`实例，然后选取对应的`cahche`，将结果缓存起来。(选取`cahce`的过程与前文读取`cache`的过程一致)；

**6、属性值copy**

从缓存中获取到了目标类的`PropertyDescriptor`后，就要轮询其每一个`PropertyDescriptor`赋值了。

赋值的过程相对比较简单一点：

*  获取目标类的写方法(`setter`)。
 *  如果目标类的写方法不为空且此方法对应的属性并不在配置的`igonreList`(忽略属性列表)中，则获取源类对应属性的读方法(`getter`)。
 *  获取到读方法之后，需要判断读方法的返回值是否与写方法的参数是同一个类型，不同类型当然无法`copy`了。
 *  判断读方法是否`public`,如果不是，则需要设置访问权限`method.setAccessible(true)`;（`非public`方法在反射访问时需要设置`setAccessible(true)`获取访问权限），然后调用反射执行此方法,`invoke(source)`。
 *  判断写方法是否`public`，如果不是则设置访问权限，然后将读到的值，通过放射赋给目标类`invoke(taget, value)`。

至此，类的属性copy完成。

## 三、总结 ##

1、 `CachedIntrospectionResults`防止内存泄漏这一块源码还未详细分析，后续有空继续跟进。

2、`Java Introspect`, 在之前用到反射的时候，都是采用比较原始的方法去获取信息然后缓存再Map中；这样的弊端就是在不同的模块都需要反射的时候，如果因沟通不畅导致另一个人也通过原始的反射接口获取类信息时，是无法利用的缓存的；采用内省的话，`JDK`默认会进行缓存。

3、`Bridge Method`, 之前对泛型擦除的理解只停留在编译期会进行泛型擦除，了解了`bridge method`后，对于泛型的机制也有了更多的理解。