Java ClassUtil.findSuperTypes方法代码示例

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected final void _addMethodMixIns(Class<?> paramClass1, AnnotatedMethodMap paramAnnotatedMethodMap1, Class<?> paramClass2, AnnotatedMethodMap paramAnnotatedMethodMap2)
{
  ArrayList localArrayList = new ArrayList();
  localArrayList.add(paramClass2);
  ClassUtil.findSuperTypes(paramClass2, paramClass1, localArrayList);
  Iterator localIterator = localArrayList.iterator();
  while (localIterator.hasNext())
    for (Method localMethod : ((Class)localIterator.next()).getDeclaredMethods())
      if (_isIncludableMemberMethod(localMethod))
      {
        AnnotatedMethod localAnnotatedMethod = paramAnnotatedMethodMap1.find(localMethod);
        if (localAnnotatedMethod != null)
          _addMixUnders(localMethod, localAnnotatedMethod);
        else
          paramAnnotatedMethodMap2.add(_constructMethod(localMethod));
      }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected void _addClassMixIns(AnnotationMap annotations, Class<?> toMask,
                               Class<?> mixin)
{
    if (mixin == null) {
        return;
    }
    // Ok, first: annotations from mix-in class itself:
    _addAnnotationsIfNotPresent(annotations, mixin.getDeclaredAnnotations());

    /* And then from its supertypes, if any. But note that we will
     * only consider super-types up until reaching the masked
     * class (if found); this because often mix-in class
     * is a sub-class (for convenience reasons). And if so, we
     * absolutely must NOT include super types of masked class,
     * as that would inverse precedence of annotations.
     */
    for (Class<?> parent : ClassUtil.findSuperTypes(mixin, toMask)) {
        _addAnnotationsIfNotPresent(annotations, parent.getDeclaredAnnotations());
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
/**
 * Method called to add field mix-ins from given mix-in class (and its fields)
 * into already collected actual fields (from introspected classes and their
 * super-classes)
 */
protected void _addFieldMixIns(Class<?> targetClass, Class<?> mixInCls,
        Map<String,AnnotatedField> fields)
{
    List<Class<?>> parents = new ArrayList<Class<?>>();
    parents.add(mixInCls);
    ClassUtil.findSuperTypes(mixInCls, targetClass, parents);
    for (Class<?> mixin : parents) {
        for (Field mixinField : mixin.getDeclaredFields()) {
            // there are some dummy things (static, synthetic); better ignore
            if (!_isIncludableField(mixinField)) {
                continue;
            }
            String name = mixinField.getName();
            // anything to mask? (if not, quietly ignore)
            AnnotatedField maskedField = fields.get(name);
            if (maskedField != null) {
                _addOrOverrideAnnotations(maskedField, mixinField.getDeclaredAnnotations());
            }
        }
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private Optional<ClassMappingInternal<Object>> getClassMappingFromSuperTypes(Class<?> type, ClassesMapping serOrDeserClassesMapping, ClassesMapping mergedClassesMapping) {
    List<Class<?>> superTypes = ClassUtil.findSuperTypes(type, Object.class);
    Collections.reverse(superTypes);
    return Stream.concat(Stream.of(Object.class), superTypes.stream())
            .map(superType -> (Class<Object>) superType)
            .map(superType -> Optional.ofNullable(
                            mergedClassesMapping.getOpt(superType)
                                    .orElseGet(() -> mergeAndPutInMergedClassesMapping(mergedClassesMapping, superType,
                                            serOrDeserClassesMapping.getOpt(superType),
                                            classesMappingByOperation.get(ANY).getOpt(superType))))
            )
            .reduce(Optional.empty(), Mergeable::merge);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected final void _addFieldMixIns(Class<?> paramClass1, Class<?> paramClass2, Map<String, AnnotatedField> paramMap)
{
  ArrayList localArrayList = new ArrayList();
  localArrayList.add(paramClass2);
  ClassUtil.findSuperTypes(paramClass2, paramClass1, localArrayList);
  Iterator localIterator = localArrayList.iterator();
  while (localIterator.hasNext())
    for (Field localField : ((Class)localIterator.next()).getDeclaredFields())
      if (_isIncludableField(localField))
      {
        AnnotatedField localAnnotatedField = (AnnotatedField)paramMap.get(localField.getName());
        if (localAnnotatedField != null)
          _addOrOverrideAnnotations(localAnnotatedField, localField.getDeclaredAnnotations());
      }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
/**
 * Factory method that instantiates an instance. Returned instance
 * will only be initialized with class annotations, but not with
 * any method information.
 */
public static AnnotatedClass construct(Class<?> cls,
        AnnotationIntrospector aintr, MixInResolver mir)
{
    return new AnnotatedClass(cls,
            ClassUtil.findSuperTypes(cls, null), aintr, mir, null);
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
protected void _addMethodMixIns(Class<?> targetClass, AnnotatedMethodMap methods,
        Class<?> mixInCls, AnnotatedMethodMap mixIns)
{
    List<Class<?>> parents = new ArrayList<Class<?>>();
    parents.add(mixInCls);
    ClassUtil.findSuperTypes(mixInCls, targetClass, parents);
    for (Class<?> mixin : parents) {
        for (Method m : mixin.getDeclaredMethods()) {
            if (!_isIncludableMemberMethod(m)) {
                continue;
            }
            AnnotatedMethod am = methods.find(m);
            /* Do we already have a method to augment (from sub-class
             * that will mask this mixIn)? If so, add if visible
             * without masking (no such annotation)
             */
            if (am != null) {
                _addMixUnders(m, am);
                /* Otherwise will have precedence, but must wait
                 * until we find the real method (mixIn methods are
                 * just placeholder, can't be called)
                 */
            } else {
                mixIns.add(_constructMethod(m));
            }
        }
    }
}
 

import com.fasterxml.jackson.databind.util.ClassUtil; //导入方法依赖的package包/类
public static AnnotatedClass construct(Class<?> paramClass, AnnotationIntrospector paramAnnotationIntrospector, ClassIntrospector.MixInResolver paramMixInResolver)
{
  return new AnnotatedClass(paramClass, ClassUtil.findSuperTypes(paramClass, null), paramAnnotationIntrospector, paramMixInResolver, null);
}