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

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

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

ResolvableType.getInterfaces介绍

[英]Return a ResolvableType array representing the direct interfaces implemented by this type. If this type does not implement any interfaces an empty array is returned.

Note: The resulting ResolvableType instances may not be Serializable.
[中]返回表示此类型实现的直接接口的ResolvableType数组。如果此类型未实现任何接口，则返回空数组。
注意：生成的ResolvableType实例可能无法序列化。

代码示例

代码示例来源：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

@Test
public void noInterfaces() throws Exception {
  assertThat(ResolvableType.forClass(Object.class).getInterfaces().length,
      equalTo(0));
}

代码示例来源：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: 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

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-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: mulesoft/mule

private static ResolvableType getInterfaceTypeFromClass(Map<String, java.lang.reflect.Type> genericTypes,
                            ResolvableType implementingType, Class<?> implementedInterface) {
 while (!implementedInterface.equals(implementingType.getRawClass())
   && implementedInterface.isAssignableFrom(implementingType.getRawClass())) {
  for (ResolvableType innerIType : implementingType.getInterfaces()) {
   if (implementedInterface.isAssignableFrom(innerIType.getRawClass())) {
    addGenericsToMap(genericTypes, innerIType);
    implementingType = innerIType;
    break;
   }
  }
 }
 return implementedInterface.isAssignableFrom(implementingType.getRawClass()) ? implementingType : null;
}

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

/**
   * Returns the {@link ResolvableType} for the given raw super class.
   * 
   * @param source must not be {@literal null}.
   * @param superType must not be {@literal null}.
   * @return
   */
  private static ResolvableType getSuperType(ResolvableType source, Class<?> superType) {
    if (source.getRawClass().equals(superType)) {
      return source;
    }
    ResolvableType candidate = source.getSuperType();
    if (superType.isAssignableFrom(candidate.getRawClass())) {
      return candidate;
    }
    for (ResolvableType interfaces : source.getInterfaces()) {
      if (superType.isAssignableFrom(interfaces.getRawClass())) {
        return interfaces;
      }
    }
    return ResolvableType.forClass(superType);
  }
}

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

/**
 * Introspects a {@link PagingProvider} type and returns their generics.
 *
 * @param pagingProvider {@link PagingProvider} to introspect
 * @return The {@link PagingProvider} generics.
 */
public static Pair<ResolvableType, ResolvableType> getPagingProviderTypes(ResolvableType pagingProvider) {
 if (!PagingProvider.class.isAssignableFrom(pagingProvider.getRawClass())) {
  throw new IllegalArgumentException("The given OutputType is not a PagingProvider");
 }
 ResolvableType[] generics = pagingProvider.getGenerics();
 ResolvableType connectionType = null;
 ResolvableType returnType = null;
 if (generics.length == 0) {
  for (ResolvableType resolvableType : pagingProvider.getInterfaces()) {
   if (resolvableType.getRawClass().equals(PagingProvider.class)) {
    connectionType = resolvableType.getGeneric(0);
    returnType = resolvableType.getGeneric(1);
   }
  }
 } else {
  connectionType = generics[0];
  returnType = generics[1];
 }
 return new Pair<>(connectionType, returnType);
}

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

/**
   * Returns the {@link ResolvableType} for the given raw super class.
   * 
   * @param source must not be {@literal null}.
   * @param superType must not be {@literal null}.
   * @return
   */
  private static ResolvableType getSuperType(ResolvableType source, Class<?> superType) {
    if (source.getRawClass().equals(superType)) {
      return source;
    }
    ResolvableType candidate = source.getSuperType();
    if (superType.isAssignableFrom(candidate.getRawClass())) {
      return candidate;
    }
    for (ResolvableType interfaces : source.getInterfaces()) {
      if (superType.isAssignableFrom(interfaces.getRawClass())) {
        return interfaces;
      }
    }
    return ResolvableType.forClass(superType);
  }
}

代码示例来源：origin: org.mule.runtime/mule-module-extensions-support

/**
 * Introspects a {@link PagingProvider} type and returns their generics.
 *
 * @param pagingProvider {@link PagingProvider} to introspect
 * @return The {@link PagingProvider} generics.
 */
public static Pair<ResolvableType, ResolvableType> getPagingProviderTypes(ResolvableType pagingProvider) {
 if (!PagingProvider.class.isAssignableFrom(pagingProvider.getRawClass())) {
  throw new IllegalArgumentException("The given OutputType is not a PagingProvider");
 }
 ResolvableType[] generics = pagingProvider.getGenerics();
 ResolvableType connectionType = null;
 ResolvableType returnType = null;
 if (generics.length == 0) {
  for (ResolvableType resolvableType : pagingProvider.getInterfaces()) {
   if (resolvableType.getRawClass().equals(PagingProvider.class)) {
    connectionType = resolvableType.getGeneric(0);
    returnType = resolvableType.getGeneric(1);
   }
  }
 } else {
  connectionType = generics[0];
  returnType = generics[1];
 }
 return new Pair<>(connectionType, returnType);
}

代码示例来源：origin: com.github.XDean/spring-annotation

/**
 * 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;
 }
 if (ObjectUtils.nullSafeEquals(resolve(), type)) {
  return this;
 }
 for (ResolvableType interfaceType : getInterfaces()) {
  ResolvableType interfaceAsType = interfaceType.as(type);
  if (interfaceAsType != NONE) {
   return interfaceAsType;
  }
 }
 return getSuperType().as(type);
}

代码示例来源：origin: apache/servicemix-bundles

@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: org.apache.servicemix.bundles/org.apache.servicemix.bundles.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: org.apache.servicemix.bundles/org.apache.servicemix.bundles.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.aliyun.openservices/ons-client

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;
  }
}

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

ResolvableType

相关文章

    查看更多
    微信公众号

    热门标签

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

    最新文章

    更多

    ResolvableType类方法

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