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

ResolvableType.hasGenerics介绍

[英]Return true if this type contains generic parameters.
[中]如果此类型包含泛型参数，则返回true。

代码示例

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

@Override
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
  if (source == null) {
    return Optional.empty();
  }
  else if (source instanceof Optional) {
    return source;
  }
  else if (targetType.getResolvableType().hasGenerics()) {
    Object target = this.conversionService.convert(source, sourceType, new GenericTypeDescriptor(targetType));
    if (target == null || (target.getClass().isArray() && Array.getLength(target) == 0) ||
          (target instanceof Collection && ((Collection<?>) target).isEmpty())) {
      return Optional.empty();
    }
    return Optional.of(target);
  }
  else {
    return Optional.of(source);
  }
}

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

/**
 * Resolve the single type argument of the given generic interface against
 * the given target class which is assumed to implement the generic interface
 * and possibly declare a concrete type for its type variable.
 * @param clazz the target class to check against
 * @param genericIfc the generic interface or superclass to resolve the type argument from
 * @return the resolved type of the argument, or {@code null} if not resolvable
 */
@Nullable
public static Class<?> resolveTypeArgument(Class<?> clazz, Class<?> genericIfc) {
  ResolvableType resolvableType = ResolvableType.forClass(clazz).as(genericIfc);
  if (!resolvableType.hasGenerics()) {
    return null;
  }
  return getSingleGeneric(resolvableType);
}

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

@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
  if (targetType.getResolvableType().hasGenerics()) {
    return this.conversionService.canConvert(sourceType, new GenericTypeDescriptor(targetType));
  }
  else {
    return true;
  }
}

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

@Override
public String[] getBeanNamesForType(ResolvableType type) {
  Class<?> resolved = type.resolve();
  if (resolved != null && !type.hasGenerics()) {
    return getBeanNamesForType(resolved, true, true);
  }
  else {
    return doGetBeanNamesForType(type, true, true);
  }
}

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

@Override
public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
  if (source == null) {
    return Optional.empty();
  }
  else if (source instanceof Optional) {
    return source;
  }
  else if (targetType.getResolvableType().hasGenerics()) {
    Object target = this.conversionService.convert(source, sourceType, new GenericTypeDescriptor(targetType));
    if (target == null || (target.getClass().isArray() && Array.getLength(target) == 0) ||
          (target instanceof Collection && ((Collection<?>) target).isEmpty())) {
      return Optional.empty();
    }
    return Optional.of(target);
  }
  else {
    return Optional.of(source);
  }
}

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

/**
 * Return a String representation of this type in its fully resolved form
 * (including any generic parameters).
 */
@Override
public String toString() {
  if (isArray()) {
    return getComponentType() + "[]";
  }
  if (this.resolved == null) {
    return "?";
  }
  if (this.type instanceof TypeVariable) {
    TypeVariable<?> variable = (TypeVariable<?>) this.type;
    if (this.variableResolver == null || this.variableResolver.resolveVariable(variable) == null) {
      // Don't bother with variable boundaries for toString()...
      // Can cause infinite recursions in case of self-references
      return "?";
    }
  }
  StringBuilder result = new StringBuilder(this.resolved.getName());
  if (hasGenerics()) {
    result.append('<');
    result.append(StringUtils.arrayToDelimitedString(getGenerics(), ", "));
    result.append('>');
  }
  return result.toString();
}

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

/**
 * Resolve the single type argument of the given generic interface against the given
 * target method which is assumed to return the given interface or an implementation
 * of it.
 * @param method the target method to check the return type of
 * @param genericIfc the generic interface or superclass to resolve the type argument from
 * @return the resolved parameter type of the method return type, or {@code null}
 * if not resolvable or if the single argument is of type {@link WildcardType}.
 */
@Nullable
public static Class<?> resolveReturnTypeArgument(Method method, Class<?> genericIfc) {
  Assert.notNull(method, "Method must not be null");
  ResolvableType resolvableType = ResolvableType.forMethodReturnType(method).as(genericIfc);
  if (!resolvableType.hasGenerics() || resolvableType.getType() instanceof WildcardType) {
    return null;
  }
  return getSingleGeneric(resolvableType);
}

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

/**
 * Resolve the type arguments of the given generic interface against the given
 * target class which is assumed to implement the generic interface and possibly
 * declare concrete types for its type variables.
 * @param clazz the target class to check against
 * @param genericIfc the generic interface or superclass to resolve the type argument from
 * @return the resolved type of each argument, with the array size matching the
 * number of actual type arguments, or {@code null} if not resolvable
 */
@Nullable
public static Class<?>[] resolveTypeArguments(Class<?> clazz, Class<?> genericIfc) {
  ResolvableType type = ResolvableType.forClass(clazz).as(genericIfc);
  if (!type.hasGenerics() || type.isEntirelyUnresolvable()) {
    return null;
  }
  return type.resolveGenerics(Object.class);
}

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

/**
 * Resolve the single type argument of the given generic interface against
 * the given target class which is assumed to implement the generic interface
 * and possibly declare a concrete type for its type variable.
 * @param clazz the target class to check against
 * @param genericIfc the generic interface or superclass to resolve the type argument from
 * @return the resolved type of the argument, or {@code null} if not resolvable
 */
@Nullable
public static Class<?> resolveTypeArgument(Class<?> clazz, Class<?> genericIfc) {
  ResolvableType resolvableType = ResolvableType.forClass(clazz).as(genericIfc);
  if (!resolvableType.hasGenerics()) {
    return null;
  }
  return getSingleGeneric(resolvableType);
}

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

@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
  if (targetType.getResolvableType().hasGenerics()) {
    return this.conversionService.canConvert(sourceType, new GenericTypeDescriptor(targetType));
  }
  else {
    return true;
  }
}

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

@Test
public void hasGenerics() throws Exception {
  ResolvableType type = ResolvableType.forClass(ExtendsList.class);
  assertThat(type.hasGenerics(), equalTo(false));
  assertThat(type.asCollection().hasGenerics(), equalTo(true));
}

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

@Override
public String[] getBeanNamesForType(ResolvableType type) {
  Class<?> resolved = type.resolve();
  if (resolved != null && !type.hasGenerics()) {
    return getBeanNamesForType(resolved, true, true);
  }
  else {
    return doGetBeanNamesForType(type, true, true);
  }
}

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

/**
 * Resolve the single type argument of the given generic interface against the given
 * target method which is assumed to return the given interface or an implementation
 * of it.
 * @param method the target method to check the return type of
 * @param genericIfc the generic interface or superclass to resolve the type argument from
 * @return the resolved parameter type of the method return type, or {@code null}
 * if not resolvable or if the single argument is of type {@link WildcardType}.
 */
@Nullable
public static Class<?> resolveReturnTypeArgument(Method method, Class<?> genericIfc) {
  Assert.notNull(method, "Method must not be null");
  ResolvableType resolvableType = ResolvableType.forMethodReturnType(method).as(genericIfc);
  if (!resolvableType.hasGenerics() || resolvableType.getType() instanceof WildcardType) {
    return null;
  }
  return getSingleGeneric(resolvableType);
}

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

while (result != ResolvableType.NONE && !result.hasGenerics()) {
  result = result.getSuperType();

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

/**
 * Resolve the type arguments of the given generic interface against the given
 * target class which is assumed to implement the generic interface and possibly
 * declare concrete types for its type variables.
 * @param clazz the target class to check against
 * @param genericIfc the generic interface or superclass to resolve the type argument from
 * @return the resolved type of each argument, with the array size matching the
 * number of actual type arguments, or {@code null} if not resolvable
 */
@Nullable
public static Class<?>[] resolveTypeArguments(Class<?> clazz, Class<?> genericIfc) {
  ResolvableType type = ResolvableType.forClass(clazz).as(genericIfc);
  if (!type.hasGenerics() || type.isEntirelyUnresolvable()) {
    return null;
  }
  return type.resolveGenerics(Object.class);
}

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

else if (typeToMatch.hasGenerics() && containsBeanDefinition(beanName)) {