去掉封装类型对象字段值首位空格

前言

有些时候，比如上游传参给了我们一个类型 Order, 里面有很多字段，但可能一些因数，导致这个入参里面参数的值都有很多不规则的 空格。

这些多于出来的空格导致我们一些错误，比如订单里面的 orderNo:"YT001 "
多余出来的空格会导致我们用订单号去查询订单时没法儿找到这笔订单：

所以我们需要封装一个工具类处理我们的入参： Body.

处理所有类型参数，包括基本数据类型、Collection、自定义类型。去除首尾空格

封装工具类：

    /**
     * 处理所有类型参数，包括基本数据类型与vo等对象，去除首尾空格
     *
     * @param object 对象
     * @return 结果
     * @throws IllegalAccessException 异常
     */
    public static Object trimExe(Object object) throws Exception {

        if (object instanceof Collection) {
            Collection objects = (Collection) object;
            List obj = Lists.newArrayList();
            objects.forEach(o -> {
                try {
                    obj.add(getObject(o));
                } catch (Exception e) {
                    logger.error("trimExe error ", e);
                }
            });
            return obj;
        } else {
            return getObject(object);
        }
    }

    private static Object getObject(Object object) throws IllegalAccessException {
        // 对象为空，不做处理
        if (Objects.isNull(object)) {
            return object;
        }

        Class<? extends Object> clazz = object.getClass();
        // 为非String包装类型，不做处理
        if (Boolean.class.equals(clazz) || Short.class.equals(clazz) || Integer.class.equals(clazz) || Long.class.equals(clazz) || Float.class.equals(clazz) || Double.class.equals(clazz)) {
            return object;
        }
        if (String.class.equals(clazz)) {
            return object.toString().trim();
        }

        // 字段为private时，无法修改字段值，需要反射
        PropertyDescriptor[] fields = BeanUtils.getPropertyDescriptors(clazz);
        // 没有字段
        if (Objects.isNull(fields) || fields.length == 0) {
            return object;
        }

        for (PropertyDescriptor field : fields) {
            Class<?> filedType = field.getPropertyType();
            //去除private权限，变为可更改
            //field.get(object) 返回参数对于的值
            Method readMethod = field.getReadMethod();
            try {
                if (readMethod != null) {
                    Object value = readMethod.invoke(object);
                    if (Objects.nonNull(value)) {
                        if (value instanceof Collection) {
                            Collection objects = (Collection) value;
                            List obj = Lists.newArrayList();
                            objects.forEach(o -> {
                                try {
                                    obj.add(getObject(o));
                                } catch (IllegalAccessException e) {
                                    logger.error("getObject1 error ", e);
                                }
                            });
                            value = obj;
                            // 只处理字符串类型
                        }
                        if (!String.class.equals(filedType)) {
                            continue;
                        }

                        // 在原有的对象上设置去除首尾空格的新值
                        Method writeMethod = field.getWriteMethod();
                        if (writeMethod != null) {
                            if (!Modifier.isPublic(writeMethod
                                    .getDeclaringClass().getModifiers())) {
                                writeMethod.setAccessible(true);
                            }
                            if (String.class.equals(filedType)) {
                                writeMethod.invoke(object, String.valueOf(value).trim());
                            } else {
                                writeMethod.invoke(object, value);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                logger.error("getObject2 Exception error ", e);
            }

        }
        return object;
    }

建议以上这个工具类放在 AOP 去做。