How to use

isAssignableFrom

method

in

java.lang.Class

private boolean isSupportedType(@Nullable Class<?> clazz) {
  return (clazz != null && ((HttpEntity.class.isAssignableFrom(clazz) &&
      !RequestEntity.class.isAssignableFrom(clazz)) ||
      HttpHeaders.class.isAssignableFrom(clazz)));
}

@Override
public boolean matches(Method method, Class<?> targetClass) {
  if (TransactionalProxy.class.isAssignableFrom(targetClass) ||
      PlatformTransactionManager.class.isAssignableFrom(targetClass) ||
      PersistenceExceptionTranslator.class.isAssignableFrom(targetClass)) {
    return false;
  }
  TransactionAttributeSource tas = getTransactionAttributeSource();
  return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}

 @Override public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
   Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
  if (!(type instanceof Class<?>)) {
   return null;
  }
  if (!MessageLite.class.isAssignableFrom((Class<?>) type)) {
   return null;
  }
  return new ProtoRequestBodyConverter<>();
 }
}

@Override public @Nullable Converter<?, RequestBody> requestBodyConverter(Type type,
  Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
 if (RequestBody.class.isAssignableFrom(Utils.getRawType(type))) {
  return RequestBodyConverter.INSTANCE;
 }
 return null;
}

private boolean someRawTypeIsSubclassOf(Class<?> superclass) {
 for (Class<?> rawType : getRawTypes()) {
  if (superclass.isAssignableFrom(rawType)) {
   return true;
  }
 }
 return false;
}

@Override
public boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException {
  Class<?> type = getType(name);
  return (typeToMatch == null || (type != null && typeToMatch.isAssignableFrom(type)));
}

/**
 * Is this type a {@link Collection} type?
 */
public boolean isCollection() {
  return Collection.class.isAssignableFrom(getType());
}

@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
  Class<?> sourceClass = sourceType.getObjectType();
  if (String.class == sourceClass) {
    // no conversion required
    return false;
  }
  return (CharSequence.class.isAssignableFrom(sourceClass) ||
      StringWriter.class.isAssignableFrom(sourceClass) ||
      ObjectToObjectConverter.hasConversionMethodOrConstructor(sourceClass, String.class));
}

@Override
public boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException {
  Class<?> type = getType(name);
  return (typeToMatch == null || (type != null && typeToMatch.isAssignableFrom(type)));
}

/**
 * Returns the generic form of {@code supertype}. For example, if this is {@code
 * ArrayList<String>}, this returns {@code Iterable<String>} given the input {@code
 * Iterable.class}.
 *
 * @param supertype a superclass of, or interface implemented by, this.
 */
static Type getSupertype(Type context, Class<?> contextRawType, Class<?> supertype) {
 if (!supertype.isAssignableFrom(contextRawType)) throw new IllegalArgumentException();
 return resolve(context, contextRawType,
   getGenericSupertype(context, contextRawType, supertype));
}

@Override
public boolean supportsParameter(MethodParameter parameter) {
  return checkAnnotatedParamNoReactiveWrapper(parameter, MatrixVariable.class,
      (ann, type) -> !Map.class.isAssignableFrom(type) || StringUtils.hasText(ann.name()));
}

@Override
public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType) {
  return (Resource.class.isAssignableFrom(elementType.toClass()) &&
      super.canDecode(elementType, mimeType));
}

@Override
public boolean canEncode(ResolvableType elementType, @Nullable MimeType mimeType) {
  return super.canEncode(elementType, mimeType)
      && ResourceRegion.class.isAssignableFrom(elementType.toClass());
}

@Override
public boolean matches(Method method, Class<?> targetClass) {
  if (CacheManager.class.isAssignableFrom(targetClass)) {
    return false;
  }
  CacheOperationSource cas = getCacheOperationSource();
  return (cas != null && !CollectionUtils.isEmpty(cas.getCacheOperations(method, targetClass)));
}

@Override
public Object resolveArgumentValue(
    MethodParameter methodParameter, BindingContext context, ServerWebExchange exchange) {
  boolean isMultiValueMap = MultiValueMap.class.isAssignableFrom(methodParameter.getParameterType());
  HttpHeaders headers = exchange.getRequest().getHeaders();
  return (isMultiValueMap ? headers : headers.toSingleValueMap());
}

private boolean hasErrorsArgument(MethodParameter parameter) {
  int i = parameter.getParameterIndex();
  Class<?>[] paramTypes = parameter.getExecutable().getParameterTypes();
  return (paramTypes.length > i + 1 && Errors.class.isAssignableFrom(paramTypes[i + 1]));
}

@Override
public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType) {
  JavaType javaType = getObjectMapper().getTypeFactory().constructType(elementType.getType());
  // Skip String: CharSequenceDecoder + "*/*" comes after
  return (!CharSequence.class.isAssignableFrom(elementType.toClass()) &&
      getObjectMapper().canDeserialize(javaType) && supportsMimeType(mimeType));
}

  @Override
  protected void assertions(MethodInvocation invocation) {
    assertSame(this, invocation.getThis());
    assertTrue("Invocation should be on ITestBean: " + invocation.getMethod(),
      ITestBean.class.isAssignableFrom(invocation.getMethod().getDeclaringClass()));
  }
}

@SuppressWarnings("unchecked")
private <T> T resolveValue(ServerWebExchange exchange, ResolvableType type) {
  MethodParameter param = this.testMethod.arg(type);
  Mono<Object> result = this.resolver.resolveArgument(param, new BindingContext(), exchange);
  Object value = result.block(Duration.ofSeconds(5));
  assertNotNull(value);
  assertTrue("Unexpected return value type: " + value.getClass(),
      param.getParameterType().isAssignableFrom(value.getClass()));
  return (T) value;
}

@Test
public void createXmlMapper() {
  Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json().indentOutput(true);
  ObjectMapper jsonObjectMapper = builder.build();
  ObjectMapper xmlObjectMapper = builder.createXmlMapper(true).build();
  assertTrue(jsonObjectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT));
  assertTrue(xmlObjectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT));
  assertTrue(xmlObjectMapper.getClass().isAssignableFrom(XmlMapper.class));
}