Spring-框架-BeanUtils类使用与源码分析

末蓝、 2023-06-08 10:56 15阅读 0赞

### BeanUtils使用介绍： ###

BeanUtils是spring自带一个对象适配器，主要作用是在VO、DTO转换时候使用，比如如下代码：

/**
         * 将FincrmOrganizationMechanism适配成OrganizationSetDTO
         *
         * @param organizationMechanism
         * @return
         */
        private OrganizationSetDTO adapter(FincrmOrganizationMechanism organizationMechanism) {
            OrganizationSetDTO organizationSetDTO = new OrganizationSetDTO();
            BeanUtils.copyProperties(organizationMechanism, organizationSetDTO);
            return organizationSetDTO;
        }

主要作用是把organizationMechanism节点对象放入organizationSetDTO对象中，形成一棵树结构。

### 源码分析： ###

private static void copyProperties(Object source, Object target, Class<?> editable, String... ignoreProperties)
                throws BeansException {
            // 检查source和target对象是否为null，否则抛运行时异常
            Assert.notNull(source, "Source must not be null");
            Assert.notNull(target, "Target must not be null");
            // 获取target对象的类信息
            Class<?> actualEditable = target.getClass();
            // 若editable不为null，检查target对象是否是editable类的实例，若不是则抛出运行时异常
            // 这里的editable类是为了做属性拷贝时限制用的
            // 若actualEditable和editable相同，则拷贝actualEditable的所有属性
            // 若actualEditable是editable的子类，则只拷贝editable类中的属性
            if (editable != null) {
                if (!editable.isInstance(target)) {
                    throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
                            "] not assignable to Editable class [" + editable.getName() + "]");
                }
                actualEditable = editable;
            }
            // 获取目标类的所有PropertyDescriptor，getPropertyDescriptors这个方法请看下方
            PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
            List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);
    
            for (PropertyDescriptor targetPd : targetPds) {
                // 获取该属性对应的set方法
                Method writeMethod = targetPd.getWriteMethod();
                // 属性的set方法存在 且 该属性不包含在忽略属性列表中
                if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
                    // 获取source类相同名字的PropertyDescriptor, getPropertyDescriptor的具体实现看下方
                    PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
                    if (sourcePd != null) {
                        // 获取对应的get方法
                        Method readMethod = sourcePd.getReadMethod();
                        // set方法存在 且 target的set方法的入参是source的get方法返回值的父类或父接口或者类型相同
                        // 具体ClassUtils.isAssignable()的实现方式请看下面详解
                        if (readMethod != null &&
                                ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
                            try {
                                //get方法是否是public的
                                if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                    //暴力反射，取消权限控制检查
                                    readMethod.setAccessible(true);
                                }
                                //获取get方法的返回值
                                Object value = readMethod.invoke(source);
                                // 原理同上
                                if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                    writeMethod.setAccessible(true);
                                }
                                // 将get方法的返回值 赋值给set方法作为入参
                                writeMethod.invoke(target, value);
                            }
                            catch (Throwable ex) {
                                throw new FatalBeanException(
                                        "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
                            }
                        }
                    }
                }
            }
        }

`getPropertyDescriptors`源码：

public static PropertyDescriptor[] getPropertyDescriptors(Class<?> clazz) throws BeansException {
            // CachedIntrospectionResults类是对PropertyDescriptor的一个封装实现，看forClass方法的实现
            CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);
            return cr.getPropertyDescriptors();
        }
        
        @SuppressWarnings("unchecked")
        static CachedIntrospectionResults forClass(Class<?> beanClass) throws BeansException {
            // strongClassCache的声明如下：
            // strongClassCache = new ConcurrentHashMap<Class<?>, CachedIntrospectionResults>(64);
            // 即将Class作为key，CachedIntrospectionResults作为value的map，
            // 由于线程安全的需要，使用ConcurrentHashMap作为实现
            CachedIntrospectionResults results = strongClassCache.get(beanClass);
            if (results != null) {
                return results;
            }
            // 若strongClassCache中不存在，则去softClassCache去获取，softClassCache的声明如下
            // softClassCache = new ConcurrentReferenceHashMap<Class<?>, CachedIntrospectionResults>(64);
            // ConcurrentReferenceHashMap是Spring实现的可以指定entry引用级别的ConcurrentHashMap，默认的引用级别是soft，可以防止OOM
            results = softClassCache.get(beanClass);
            if (results != null) {
                return results;
            }
    
            results = new CachedIntrospectionResults(beanClass);
            ConcurrentMap<Class<?>, CachedIntrospectionResults> classCacheToUse;
            // isCacheSafe方法检查给定的beanClass是否由入参中的classloader或者此classloader的祖先加载的（双亲委派的原理）
            // isClassLoaderAccepted检查加载beanClass的classloader是否在可以接受的classloader的集合中 或者是集合中classloader的祖先
            if (ClassUtils.isCacheSafe(beanClass, CachedIntrospectionResults.class.getClassLoader()) ||
                    isClassLoaderAccepted(beanClass.getClassLoader())) {
                classCacheToUse = strongClassCache;
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Not strongly caching class [" + beanClass.getName() + "] because it is not cache-safe");
                }
                classCacheToUse = softClassCache;
            }
            // 根据classloader的结果，将类信息加载到对应的缓存中
            CachedIntrospectionResults existing = classCacheToUse.putIfAbsent(beanClass, results);
            return (existing != null ? existing : results);
        }

`isAssignable`源码：

public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) {
            Assert.notNull(lhsType, "Left-hand side type must not be null");
            Assert.notNull(rhsType, "Right-hand side type must not be null");
            // 若左边类型 是右边类型的父类、父接口，或者左边类型等于右边类型
            if (lhsType.isAssignableFrom(rhsType)) {
                return true;
            }
            // 左边入参是否是基本类型
            if (lhsType.isPrimitive()) {
                //primitiveWrapperTypeMap是从包装类型到基本类型的map，将右边入参转化为基本类型
                Class<?> resolvedPrimitive = primitiveWrapperTypeMap.get(rhsType);
                if (lhsType == resolvedPrimitive) {
                    return true;
                }
            }
            else {
                // 将右边入参转化为包装类型
                Class<?> resolvedWrapper = primitiveTypeToWrapperMap.get(rhsType);
                if (resolvedWrapper != null && lhsType.isAssignableFrom(resolvedWrapper)) {
                    return true;
                }
            }
            return false;
        }

`ClassUtils.isAssignable()`方法扩展了`Class的isAssignableFrom()`方法，即将`Java`的基本类型和包装类型做了兼容。

### 总结： ###

一个看似简单的`BeanUtils`工具类，其实里面包含的Java基础的知识点非常多，包括类型信息、反射、线程安全、引用类型、类加载器等。`Spring`的`BeanUtils`的实现里使用了`ConcurrentHashMap`作为缓存，每次去获取`PropertyDescriptor`时，可以直接去缓存里面获取，而不必每次都去调用`native`方法，所以`Spring`的`BeanUtils`的性能还是很不错的。