多层嵌套对象获取底层对象属性

浅浅的花香味﹌ 2022-06-02 07:11 130阅读 0赞

最近在做一个需求，对业务层的查询参数及返回值做校验，查看其是否是合法的值，使用AOP做。后来发现业务方法的返回值有多重嵌套，有Map，List，Set，Page，自定义包装类等等，且包装层还嵌套层，如Map< ?,List>,Page< List >，仅仅是通过反射获取这些包装之下实际Model就很花费精力，就想能不能将这些逻辑抽象出来，写个特定的工具类，能很方便的剥离这些外层，获取底层对象的指定属性。

每一个包装类其获取下一层包装的方法不尽相同，他们没有什么共同之处，因此提取各自的封装逻辑是必不可少，那么每一个包装类至少需要各自的提取方法，如果想抽成通用的形式，则基本是使用方法的重写来实现；但是如果用重写则意味着会有很多的子类，且每多一种包装就需要额外添加一个提取类，工具体系会很臃肿，不好。因此想到了使用枚举，借助枚举的实例能重写外部类的方法的特性，将每个包装类的下层提取逻辑定义在不同的枚举实例里。先看具体代码：

/** * 嵌套对象属性验证枚举 * * @create 2017-12-18 9:20 */
    public enum NestedObjectFieldCheckingProcessor {
    
        LIST_RESULT(ListResult.class) {
            @Override
            public void process(Object object, Object expectedFieldVal) {
                doProcessingInternal(((ListResult)object).getContent(), expectedFieldVal);
            }
        },
    
        PAGE_RESULT(PageResult.class) {
            @Override
            public void process(Object object, Object expectedFieldVal) {
                doProcessingInternal(((PageResult)object).getContent(), expectedFieldVal);
            }
        },
    
        RESULT_MODEL(ResultModel.class) {
            @Override
            public void process(Object object, Object expectedFieldVal) {
                doProcessingInternal(((ResultModel)object).getContent(), expectedFieldVal);
            }
        },
    
        POJO_RESULT(PojoResult.class) {
            @Override
            public void process(Object object, Object expectedFieldVal) {
                doProcessingInternal(((PojoResult)object).getContent(), expectedFieldVal);
            }
        },
    
        PAGE(Page.class) {
            @Override
            public void process(Object object, Object expectedFieldVal) {
                doProcessingInternal(((Page)object).getResult(), expectedFieldVal);
            }
        },
    
        MAP(Map.class) {
            @Override
            public void process(Object object, Object expectedFieldVal) {
                Map<?, ?> map = (Map)object;
                if (CollectionUtils.isEmpty(map)) {
                    return;
                }
                COLLECTION.process(map.keySet(), expectedFieldVal);
                COLLECTION.process(map.values(), expectedFieldVal);
            }
        },
    
        COLLECTION(Collection.class) {
            @Override
            public void process(Object object, Object expectedFieldVal) {
                if (CollectionUtils.isEmpty((Collection)object)) {
                    return;
                }
                for (Object element : (Collection)object) {
                    doProcessingInternal(element, expectedFieldVal);
                }
            }
        },
    
        PLAIN_OBJECT(Object.class) {
            @Override
            public void process(Object object, Object expectedFieldVal) {
                Class<?> clazz = object.getClass();
                Field field = FIELD_MAPPINGS.get(clazz);
                if (field == null) {
                    field = ReflectionUtils.findField(clazz, CAMPUS_ID);
                    field.setAccessible(true);
                    FIELD_MAPPINGS.put(clazz, field != null ? field : NON_CAMPUS_ID_FIELD);
                } else if (field == NON_CAMPUS_ID_FIELD) {
                    return;
                }
                Object actualFieldValue = ReflectionUtils.getField(field, object);
                Assert.isTrue(expectedFieldVal.equals(actualFieldValue), clazz.getSimpleName());
            }
        };
    
        private Class<?> clazz;
        private static final String CAMPUS_ID = "campusId";
        private static final Map<Class<?>, Field> FIELD_MAPPINGS = new ConcurrentHashMap<Class<?>, Field>();
        private static final Field NON_CAMPUS_ID_FIELD = ReflectionUtils.findField(NestedObjectFieldCheckingProcessor.class, CAMPUS_ID);
    
        NestedObjectFieldCheckingProcessor(Class<?> clazz) {
            this.clazz = clazz;
        }
    
        /** * @param clazz * @return */
        public static NestedObjectFieldCheckingProcessor valueOf(Class<?> clazz) {
            for (NestedObjectFieldCheckingProcessor processorEnum : NestedObjectFieldCheckingProcessor.values()) {
                if (processorEnum.clazz.isAssignableFrom(clazz)) {
                    return processorEnum;
                }
            }
            return null;
        }
    
        /** * @param value * @param expectedFieldVal */
        protected void doProcessingInternal(Object value, Object expectedFieldVal) {
            if (value != null) {
                valueOf(value.getClass()).process(value, expectedFieldVal);
            }
        }
    
        /** * @param object * @param expectedFieldVal */
        public abstract void process(Object object, Object expectedFieldVal);

使用方法：

ListResult<User> userlist = new ListResult<User>(new ArrayList<User>);
    NestedObjectFieldCheckingProcessor processor = NestedObjectFieldCheckingProcessor.valueOf(userlist.getClass());
    processor.process(userlist,10);

在枚举外壳类里定义了一个抽象方法process(…)，这个方法就是业务处理逻辑，可以定义不同的逻辑，没什么限制。

每一个包装类对应的枚举里重写了此抽象方法，在方法内先提取其下一层的包装对象(若是多层包装)，然后下层对象传递给doProcessingInternal(…)方法，在doProcessingInternal(…)方法内再次获取参数对象对应的枚举，再调用其process(…)方法。

每一个包装类的process(…)方法主要是提取其下层对象或包装对象，然后在用下层对象去寻找适配的枚举处理器，在调用其process(…)方法。

递归式的处理，每一个包装类对应的枚举实例仅仅负责提取下一层的包装对象，而不负责实际的业务处理。**借鉴职责链设计模式，每个元素仅对待处理对象做职责范围内的处理，然后将其传递给下一个元素**。

当然这个工具类有几点需要注意:

1.  Enum的values()方法返回的是枚举实例列表，**顺序由上而下**，所以我们定义包装处理枚举时，要考虑其处理范围，范围越小的位置越靠前，处理范围越大的越靠后，否则可能会出现意想不到的问题。
2.  **枚举实例的最后一个是Object对应的实例**，它拦截所有的实际Model，也就是说到了这步包装层应该都已经剥离了，它才是真正负责处理实际业务的，其他的实包装类的处理枚举，而它是实际Model的处理枚举。
3.  枚举里可以重写外部类的方法，和类方法重写机制一样。