org.springframework.core.ResolvableType.getSuperType()方法的使用及代码示例

x33g5p2x  于2022-01-28 转载在 其他  
字(13.8k)|赞(0)|评价(0)|浏览(69)

本文整理了Java中org.springframework.core.ResolvableType.getSuperType方法的一些代码示例，展示了ResolvableType.getSuperType的具体用法。这些代码示例主要来源于Github/Stackoverflow/Maven等平台，是从一些精选项目中提取出来的代码，具有较强的参考意义，能在一定程度帮忙到你。ResolvableType.getSuperType方法的具体详情如下：
包路径：org.springframework.core.ResolvableType
类名称：ResolvableType
方法名：getSuperType

ResolvableType.getSuperType介绍

[英]Return a ResolvableType representing the direct supertype of this type. If no supertype is available this method returns #NONE.

Note: The resulting ResolvableType instance may not be Serializable.
[中]返回表示此类型的直接超类型的ResolvableType。如果没有可用的超类型，此方法将返回#NONE。
注意：生成的ResolvableType实例可能无法序列化。

代码示例

代码示例来源：origin: spring-projects/spring-framework

@Test
public void getSuperType() throws Exception {
  ResolvableType type = ResolvableType.forClass(ExtendsList.class).getSuperType();
  assertThat(type.resolve(), equalTo((Class) ArrayList.class));
  type = type.getSuperType();
  assertThat(type.resolve(), equalTo((Class) AbstractList.class));
  type = type.getSuperType();
  assertThat(type.resolve(), equalTo((Class) AbstractCollection.class));
  type = type.getSuperType();
  assertThat(type.resolve(), equalTo((Class) Object.class));
}

代码示例来源：origin: spring-projects/spring-framework

result = result.getSuperType();

代码示例来源：origin: spring-projects/spring-framework

@Test
public void noSuperType() throws Exception {
  assertThat(ResolvableType.forClass(Object.class).getSuperType(),
      equalTo(ResolvableType.NONE));
}

代码示例来源：origin: spring-projects/spring-framework

/**
 * Return this type as a {@link ResolvableType} of the specified class. Searches
 * {@link #getSuperType() supertype} and {@link #getInterfaces() interface}
 * hierarchies to find a match, returning {@link #NONE} if this type does not
 * implement or extend the specified class.
 * @param type the required type (typically narrowed)
 * @return a {@link ResolvableType} representing this object as the specified
 * type, or {@link #NONE} if not resolvable as that type
 * @see #asCollection()
 * @see #asMap()
 * @see #getSuperType()
 * @see #getInterfaces()
 */
public ResolvableType as(Class<?> type) {
  if (this == NONE) {
    return NONE;
  }
  Class<?> resolved = resolve();
  if (resolved == null || resolved == type) {
    return this;
  }
  for (ResolvableType interfaceType : getInterfaces()) {
    ResolvableType interfaceAsType = interfaceType.as(type);
    if (interfaceAsType != NONE) {
      return interfaceAsType;
    }
  }
  return getSuperType().as(type);
}

代码示例来源：origin: spring-projects/spring-framework

@SuppressWarnings("rawtypes")
private static void buildTypeVariableMap(ResolvableType type, Map<TypeVariable, Type> typeVariableMap) {
  if (type != ResolvableType.NONE) {
    Class<?> resolved = type.resolve();
    if (resolved != null && type.getType() instanceof ParameterizedType) {
      TypeVariable<?>[] variables = resolved.getTypeParameters();
      for (int i = 0; i < variables.length; i++) {
        ResolvableType generic = type.getGeneric(i);
        while (generic.getType() instanceof TypeVariable<?>) {
          generic = generic.resolveType();
        }
        if (generic != ResolvableType.NONE) {
          typeVariableMap.put(variables[i], generic.getType());
        }
      }
    }
    buildTypeVariableMap(type.getSuperType(), typeVariableMap);
    for (ResolvableType interfaceType : type.getInterfaces()) {
      buildTypeVariableMap(interfaceType, typeVariableMap);
    }
    if (resolved != null && resolved.isMemberClass()) {
      buildTypeVariableMap(ResolvableType.forClass(resolved.getEnclosingClass()), typeVariableMap);
    }
  }
}

代码示例来源：origin: spring-projects/spring-framework

@Test
public void getInterfaces() throws Exception {
  ResolvableType type = ResolvableType.forClass(ExtendsList.class);
  assertThat(type.getInterfaces().length, equalTo(0));
  SortedSet<String> interfaces = new TreeSet<>();
  for (ResolvableType interfaceType : type.getSuperType().getInterfaces()) {
    interfaces.add(interfaceType.toString());
  }
  assertThat(interfaces.toString(), equalTo(
      "["
      + "java.io.Serializable, "
      + "java.lang.Cloneable, "
      + "java.util.List<java.lang.CharSequence>, "
      + "java.util.RandomAccess"
      + "]"));
}

代码示例来源：origin: spring-projects/spring-framework

/**
 * Determine whether the underlying type has any unresolvable generics:
 * either through an unresolvable type variable on the type itself
 * or through implementing a generic interface in a raw fashion,
 * i.e. without substituting that interface's type variables.
 * The result will be {@code true} only in those two scenarios.
 */
public boolean hasUnresolvableGenerics() {
  if (this == NONE) {
    return false;
  }
  ResolvableType[] generics = getGenerics();
  for (ResolvableType generic : generics) {
    if (generic.isUnresolvableTypeVariable() || generic.isWildcardWithoutBounds()) {
      return true;
    }
  }
  Class<?> resolved = resolve();
  if (resolved != null) {
    for (Type genericInterface : resolved.getGenericInterfaces()) {
      if (genericInterface instanceof Class) {
        if (forClass((Class<?>) genericInterface).hasGenerics()) {
          return true;
        }
      }
    }
    return getSuperType().hasUnresolvableGenerics();
  }
  return false;
}

代码示例来源：origin: org.springframework/spring-core

result = result.getSuperType();

代码示例来源：origin: org.springframework/spring-core

/**
 * Return this type as a {@link ResolvableType} of the specified class. Searches
 * {@link #getSuperType() supertype} and {@link #getInterfaces() interface}
 * hierarchies to find a match, returning {@link #NONE} if this type does not
 * implement or extend the specified class.
 * @param type the required type (typically narrowed)
 * @return a {@link ResolvableType} representing this object as the specified
 * type, or {@link #NONE} if not resolvable as that type
 * @see #asCollection()
 * @see #asMap()
 * @see #getSuperType()
 * @see #getInterfaces()
 */
public ResolvableType as(Class<?> type) {
  if (this == NONE) {
    return NONE;
  }
  Class<?> resolved = resolve();
  if (resolved == null || resolved == type) {
    return this;
  }
  for (ResolvableType interfaceType : getInterfaces()) {
    ResolvableType interfaceAsType = interfaceType.as(type);
    if (interfaceAsType != NONE) {
      return interfaceAsType;
    }
  }
  return getSuperType().as(type);
}

代码示例来源：origin: org.springframework/spring-core

@SuppressWarnings("rawtypes")
private static void buildTypeVariableMap(ResolvableType type, Map<TypeVariable, Type> typeVariableMap) {
  if (type != ResolvableType.NONE) {
    Class<?> resolved = type.resolve();
    if (resolved != null && type.getType() instanceof ParameterizedType) {
      TypeVariable<?>[] variables = resolved.getTypeParameters();
      for (int i = 0; i < variables.length; i++) {
        ResolvableType generic = type.getGeneric(i);
        while (generic.getType() instanceof TypeVariable<?>) {
          generic = generic.resolveType();
        }
        if (generic != ResolvableType.NONE) {
          typeVariableMap.put(variables[i], generic.getType());
        }
      }
    }
    buildTypeVariableMap(type.getSuperType(), typeVariableMap);
    for (ResolvableType interfaceType : type.getInterfaces()) {
      buildTypeVariableMap(interfaceType, typeVariableMap);
    }
    if (resolved != null && resolved.isMemberClass()) {
      buildTypeVariableMap(ResolvableType.forClass(resolved.getEnclosingClass()), typeVariableMap);
    }
  }
}

代码示例来源：origin: spring-projects/spring-framework

@Test
public void javaDocSample() throws Exception {
  ResolvableType t = ResolvableType.forField(getClass().getDeclaredField("myMap"));
  assertThat(t.toString(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>"));
  assertThat(t.getType().getTypeName(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>"));
  assertThat(t.getType().toString(), equalTo("java.util.HashMap<java.lang.Integer, java.util.List<java.lang.String>>"));
  assertThat(t.getSuperType().toString(), equalTo("java.util.AbstractMap<java.lang.Integer, java.util.List<java.lang.String>>"));
  assertThat(t.asMap().toString(), equalTo("java.util.Map<java.lang.Integer, java.util.List<java.lang.String>>"));
  assertThat(t.getGeneric(0).resolve(), equalTo(Integer.class));
  assertThat(t.getGeneric(1).resolve(), equalTo(List.class));
  assertThat(t.getGeneric(1).toString(), equalTo("java.util.List<java.lang.String>"));
  assertThat(t.resolveGeneric(1, 0), equalTo(String.class));
}

代码示例来源：origin: spring-projects/spring-framework

@Test
public void getSource() throws Exception {
  Class<?> classType = MySimpleInterfaceType.class;
  Field basicField = Fields.class.getField("classType");
  Field field = Fields.class.getField("charSequenceList");
  Method method = Methods.class.getMethod("charSequenceParameter", List.class);
  MethodParameter methodParameter = MethodParameter.forExecutable(method, 0);
  assertThat(ResolvableType.forField(basicField).getSource(), equalTo((Object) basicField));
  assertThat(ResolvableType.forField(field).getSource(), equalTo((Object) field));
  assertThat(ResolvableType.forMethodParameter(methodParameter).getSource(), equalTo((Object) methodParameter));
  assertThat(ResolvableType.forMethodParameter(method, 0).getSource(), equalTo((Object) methodParameter));
  assertThat(ResolvableType.forClass(classType).getSource(), equalTo((Object) classType));
  assertThat(ResolvableType.forClass(classType).getSuperType().getSource(), equalTo((Object) classType.getGenericSuperclass()));
}

代码示例来源：origin: spring-projects/spring-framework

private static ResolvableType resolveVariable(TypeVariable<?> typeVariable, ResolvableType contextType) {
  ResolvableType resolvedType;
  if (contextType.hasGenerics()) {
    resolvedType = ResolvableType.forType(typeVariable, contextType);
    if (resolvedType.resolve() != null) {
      return resolvedType;
    }
  }
  ResolvableType superType = contextType.getSuperType();
  if (superType != ResolvableType.NONE) {
    resolvedType = resolveVariable(typeVariable, superType);
    if (resolvedType.resolve() != null) {
      return resolvedType;
    }
  }
  for (ResolvableType ifc : contextType.getInterfaces()) {
    resolvedType = resolveVariable(typeVariable, ifc);
    if (resolvedType.resolve() != null) {
      return resolvedType;
    }
  }
  return ResolvableType.NONE;
}

代码示例来源：origin: org.springframework/spring-core

/**
 * Determine whether the underlying type has any unresolvable generics:
 * either through an unresolvable type variable on the type itself
 * or through implementing a generic interface in a raw fashion,
 * i.e. without substituting that interface's type variables.
 * The result will be {@code true} only in those two scenarios.
 */
public boolean hasUnresolvableGenerics() {
  if (this == NONE) {
    return false;
  }
  ResolvableType[] generics = getGenerics();
  for (ResolvableType generic : generics) {
    if (generic.isUnresolvableTypeVariable() || generic.isWildcardWithoutBounds()) {
      return true;
    }
  }
  Class<?> resolved = resolve();
  if (resolved != null) {
    for (Type genericInterface : resolved.getGenericInterfaces()) {
      if (genericInterface instanceof Class) {
        if (forClass((Class<?>) genericInterface).hasGenerics()) {
          return true;
        }
      }
    }
    return getSuperType().hasUnresolvableGenerics();
  }
  return false;
}

代码示例来源：origin: spring-projects/spring-framework

@Test
public void noneReturnValues() throws Exception {
  ResolvableType none = ResolvableType.NONE;
  assertThat(none.as(Object.class), equalTo(ResolvableType.NONE));
  assertThat(none.asCollection(), equalTo(ResolvableType.NONE));
  assertThat(none.asMap(), equalTo(ResolvableType.NONE));
  assertThat(none.getComponentType(), equalTo(ResolvableType.NONE));
  assertThat(none.getGeneric(0), equalTo(ResolvableType.NONE));
  assertThat(none.getGenerics().length, equalTo(0));
  assertThat(none.getInterfaces().length, equalTo(0));
  assertThat(none.getSuperType(), equalTo(ResolvableType.NONE));
  assertThat(none.getType(), equalTo(ResolvableType.EmptyType.INSTANCE));
  assertThat(none.hasGenerics(), equalTo(false));
  assertThat(none.isArray(), equalTo(false));
  assertThat(none.resolve(), nullValue());
  assertThat(none.resolve(String.class), equalTo((Class) String.class));
  assertThat(none.resolveGeneric(0), nullValue());
  assertThat(none.resolveGenerics().length, equalTo(0));
  assertThat(none.toString(), equalTo("?"));
  assertThat(none.hasUnresolvableGenerics(), equalTo(false));
  assertThat(none.isAssignableFrom(ResolvableType.forClass(Object.class)), equalTo(false));
}

代码示例来源：origin: org.springframework/spring-core

private static ResolvableType resolveVariable(TypeVariable<?> typeVariable, ResolvableType contextType) {
  ResolvableType resolvedType;
  if (contextType.hasGenerics()) {
    resolvedType = ResolvableType.forType(typeVariable, contextType);
    if (resolvedType.resolve() != null) {
      return resolvedType;
    }
  }
  ResolvableType superType = contextType.getSuperType();
  if (superType != ResolvableType.NONE) {
    resolvedType = resolveVariable(typeVariable, superType);
    if (resolvedType.resolve() != null) {
      return resolvedType;
    }
  }
  for (ResolvableType ifc : contextType.getInterfaces()) {
    resolvedType = resolveVariable(typeVariable, ifc);
    if (resolvedType.resolve() != null) {
      return resolvedType;
    }
  }
  return ResolvableType.NONE;
}

代码示例来源：origin: com.alibaba/fastjson

private static ResolvableType resolveVariable(TypeVariable<?> typeVariable, ResolvableType contextType) {
    ResolvableType resolvedType;
    if (contextType.hasGenerics()) {
      resolvedType = ResolvableType.forType(typeVariable, contextType);
      if (resolvedType.resolve() != null) {
        return resolvedType;
      }
    }
    ResolvableType superType = contextType.getSuperType();
    if (superType != ResolvableType.NONE) {
      resolvedType = resolveVariable(typeVariable, superType);
      if (resolvedType.resolve() != null) {
        return resolvedType;
      }
    }
    for (ResolvableType ifc : contextType.getInterfaces()) {
      resolvedType = resolveVariable(typeVariable, ifc);
      if (resolvedType.resolve() != null) {
        return resolvedType;
      }
    }
    return ResolvableType.NONE;
  }
}

代码示例来源：origin: spring-projects/spring-hateoas

private static ResolvableType findGenericType(ResolvableType source, Class<?> type) {
    Class<?> rawType = getRawType(source);
    if (Object.class.equals(rawType)) {
      return null;
    }
    if (rawType.equals(type)) {
      return source;
    }
    return findGenericType(source.getSuperType(), type);
  }
}

代码示例来源：origin: spring-projects/spring-data-rest

private static ResolvableType findGenericType(ResolvableType source, Class<?> type) {
    Class<?> rawType = getRawType(source);
    if (Object.class.equals(rawType)) {
      return null;
    }
    if (rawType.equals(type)) {
      return source;
    }
    return findGenericType(source.getSuperType(), type);
  }
}

代码示例来源：origin: mulesoft/mule

private static ResolvableType getInterfaceBaseImplementingClass(Map<String, java.lang.reflect.Type> genericTypes,
                                ResolvableType searchClass, Class<?> implementedInterface) {
 while (!Object.class.equals(searchClass.getRawClass()) && searchClass.getSuperType() != NONE
   && implementedInterface.isAssignableFrom(searchClass.getSuperType().getRawClass())) {
  searchClass = searchClass.getSuperType();
  addGenericsToMap(genericTypes, searchClass);
 }
 return implementedInterface.isAssignableFrom(searchClass.getRawClass()) ? searchClass : null;
}

内容来源于网络，如有侵权，请联系作者删除！

ResolvableType

相关文章

    查看更多
    微信公众号

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多

    ResolvableType类方法

    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com