Java TypeUtils.parameterize方法代码示例

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
/**
 * If the requested type is not registered within the class hierarchy it may still be persistable if a superclass is
 * registered. But then we need to find the type that is in the set of registered types.
 *
 * @param type
 * @param classHierarchyNodeForType
 * @return
 */
private Type downGradeType(Type type, ClassHierarchyNode classHierarchyNodeForType) {
    if (classHierarchyNodeForType == null) {
        return type;
    }
    Class<?> clazz = classHierarchyNodeForType.getClazz();

    // if the type is directly assignable, we can simply return the type

    if (TypeUtils.isAssignable(clazz, type)) {
        return type;
    }

    // now we need to downgrade type to clazz
    if (clazz.getTypeParameters().length > 0) {
        //if clazz has type parameters, we need to figure out the correct types
        // TODO encoding with specific type arguments may work, but decoding into
        // TODO the type (that is within the group of registered classes) would loose information, so maybe
        // we should not try to infer the type arguments?
        return TypeUtils.parameterize(clazz, TypeUtils.getTypeArguments(type, clazz));
    } else {
        return clazz;
    }
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private <T> void registerAggregateFactories(
		final RegistrableAggregateSnaphotter snapshotter) {
	Set<Annotation> qualifiers = ImmutableSet.copyOf(getQualifiers());
	for (AggregateRootInfo aggregateRoot : aggregateRootsInfo) {
		if (aggregateRoot.matchQualifiers(QualifierType.SNAPSHOTTER, qualifiers)) {
			Set<Annotation> factoryQualifiers = aggregateRoot
					.getQualifiers(QualifierType.REPOSITORY);
			Type type = TypeUtils.parameterize(EventSourcingRepository.class,
					aggregateRoot.getType());
			EventSourcingRepository<T> repository = (EventSourcingRepository<T>) CdiUtils
					.getReference(getBeanManager(), type, factoryQualifiers);
			if (repository != null) {
				snapshotter.registerAggregateFactory(repository.getAggregateFactory());
			}
			new EventCountSnapshotTriggerDefinition(snapshotter, 10);
		}
	}
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
@SuppressWarnings({ "unchecked" })
protected <T> void registerRepositories(X commandBus) {
	final Set<Annotation> qualifiers = ImmutableSet.copyOf(getQualifiers());
	for (AggregateRootInfo aggregateRootInfo : aggregateRootsInfo) {
		if (aggregateRootInfo.matchQualifiers(QualifierType.COMMAND_BUS, qualifiers)) {
			Class<T> aggregateType = (Class<T>) aggregateRootInfo.getType();
			ParameterizedType repositoryType = TypeUtils.parameterize(EventSourcingRepository.class,
					aggregateType);
			EventSourcingRepository<T> repository = (EventSourcingRepository<T>) CdiUtils.getReference(
					getBeanManager(), repositoryType, aggregateRootInfo.getQualifiers(QualifierType.REPOSITORY));
			AggregateAnnotationCommandHandler<?> aggregateAnnotationCommandHandler = new AggregateAnnotationCommandHandler<>(aggregateType,
					repository);
			aggregateAnnotationCommandHandler.subscribe(commandBus);
			if (commandBus instanceof DisruptorCommandBus) {
				((DisruptorCommandBus) commandBus).createRepository(repository.getAggregateFactory());
			}
		}
	}
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
/**
 * Checks that the actual field is parameterized.
 * 
 * @param expectedRawType the expected raw type
 * @param expectedTypeArguments the expected type arguments
 * @return this {@link FieldAssertion} for fluent linking
 */
public FieldAssertion isParameterizedType(final Class<?> expectedRawType,
    final Type... expectedTypeArguments) {
  isNotNull();
  if (!(actual.getGenericType() instanceof ParameterizedType)) {
    failWithMessage("Expected field <%s> to be a parameterized type but it was not", actual);
  }
  final ParameterizedType actualType = (ParameterizedType) actual.getGenericType();
  final ParameterizedType expectedParameterizedType =
      TypeUtils.parameterize(expectedRawType, expectedTypeArguments);
  if (!TypeUtils.equals(actualType, expectedParameterizedType)) {
    failWithMessage("Expected field %s.%s to be of type %s<%s> but it was %s<%s>",
        actual.getType().getName(), actual.getName(), expectedRawType, expectedTypeArguments,
        actualType.getRawType().getTypeName(), actualType.getActualTypeArguments());
  }
  return this;
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
@Override
public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
                                                        Retrofit retrofit) {
    Type envelopType = TypeUtils.parameterize(ResponseEnvelop.class, type);
    Converter converter = retrofit.nextResponseBodyConverter(CustomConverterFactory.this,
            envelopType, annotations);
    return new ResponseConverter<>(converter);
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private <T> Bean<EventSourcingRepository<T>> createRepositoryBean(
		final BeanManager bm, final AggregateRootInfo aggregateRootInfo) {

	BeanBuilder<T> aggregateRootBean = new BeanBuilder<T>(bm)
			.readFromType((AnnotatedType<T>) aggregateRootInfo.getAnnotatedType(bm));

	ParameterizedType type = TypeUtils.parameterize(EventSourcingRepository.class,
			aggregateRootInfo.getType());

	BeanBuilder<EventSourcingRepository<T>> builder = new BeanBuilder<EventSourcingRepository<T>>(
			bm)
					.beanClass(EventSourcingRepository.class)
					.qualifiers(CdiUtils.normalizedQualifiers(
							aggregateRootInfo.getQualifiers(QualifierType.REPOSITORY)))
					.alternative(aggregateRootBean.isAlternative())
					.nullable(aggregateRootBean.isNullable())
					.types(CdiUtils.typeClosure(type))
					.scope(aggregateRootBean.getScope())
					.stereotypes(aggregateRootBean.getStereotypes())
					.beanLifecycle(
							new RepositoryContextualLifecycle<T, EventSourcingRepository<T>>(bm,
									aggregateRootInfo));

	if (!Strings.isNullOrEmpty(aggregateRootBean.getName())) {
		builder.name(aggregateRootBean.getName() + "Repository");
	}
	return builder.create();
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
@Test
public void testGetMap() throws Exception {
    Cat simon = new Cat(null, "Simon", "mail", "unknown", "Well loved and now deceased.");
    String id = client.create("animals", "cat", simon);

    Type type = TypeUtils.parameterize(Map.class, String.class, Object.class);
    Optional<Map<String, Object>> retrieved = client.get("animals", "cat", id, type);
    assertTrue(retrieved.isPresent());
    assertEquals("unknown", retrieved.get().get("breed"));
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
private static ParameterizedType from(TypeInfo typeInfo) {
  Type[] typeArguments = new Type[0];
  if (typeInfo.typeInfo != null) {
    typeArguments = new Type[]{from(typeInfo.typeInfo)};
  } else if (typeInfo.typeArgs != null) {
    typeArguments = typeInfo.typeArgs;
  }
  return TypeUtils.parameterize(typeInfo.rawType, typeArguments);
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
private void readJson(JsonObject obj, boolean pm) {
    for (Entry<String, JsonElement> entry : obj.entrySet()) {
        Channel chan = getChannel(entry.getKey(), pm);
        Type type = TypeUtils.parameterize(List.class, ChatMessage.class);
        List<Message> list = gson.fromJson(entry.getValue(), type);
        chan.getMessages().addAll(list);
    }
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
/**
 * @param parameterizedType the type to match to
 * @param clazz             the class for which the correct parametrization is to be found
 * @return the parameterized type of clazz or null if no match
 */
private Type getMatchingType(ParameterizedType parameterizedType, Class<?> clazz) {
    Type matchingType = null;
    if (parameterizedType.getRawType().equals(clazz)) {
        matchingType = parameterizedType;
    } else {
        // first find the superclass...may be an interface though
        Type genericSuperclass = null;
        if (ReflectionHelper.extractRawClass(parameterizedType).isInterface()) {
            for (Type genericInterface : clazz.getGenericInterfaces()) {
                if (TypeUtils.isAssignable(genericInterface, parameterizedType)) {
                    genericSuperclass = genericInterface;
                    break;
                }
            }
        } else {
            genericSuperclass = clazz.getGenericSuperclass();
        }


        if (genericSuperclass instanceof ParameterizedType) {
            ParameterizedType parameterizedSuperClassType = (ParameterizedType) genericSuperclass;

            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            Type[] superClassTypeArguments = parameterizedSuperClassType.getActualTypeArguments();
            Map<String, Type> parameter = new HashMap<>();
            for (int i = 0; i < superClassTypeArguments.length; i++) {
                Type classTypeArgument = superClassTypeArguments[i];
                if (classTypeArgument instanceof TypeVariable) {
                    if (actualTypeArguments[i] instanceof WildcardType) {
                        WildcardType wildcardType = (WildcardType) actualTypeArguments[i];
                        parameter.put(((TypeVariable) classTypeArgument).getName(), wildcardType.getUpperBounds()[0]);
                    } else {
                        parameter.put(((TypeVariable) classTypeArgument).getName(), actualTypeArguments[i]);
                    }
                }
            }

            TypeVariable<? extends Class<?>>[] typeParameters = clazz.getTypeParameters();
            Type[] specifiedTypeArguments = new Type[typeParameters.length];
            for (int i = 0; i < typeParameters.length; i++) {
                Type inferredType = inferRealType(typeParameters[i], parameter);

                if (TypeUtils.isAssignable(inferredType, typeParameters[i].getBounds()[0])) {
                    specifiedTypeArguments[i] = inferredType;
                } else {
                    return null;
                }
            }

            if (specifiedTypeArguments.length > 0) {
                matchingType = TypeUtils.parameterize(clazz, specifiedTypeArguments);
            } else {
                matchingType = clazz;
            }
        } else {
            LOGGER.debug("Type {} will be ignored as it has no generic superclass, but should have.", clazz);
        }
    }
    return matchingType;
}
 

import org.apache.commons.lang3.reflect.TypeUtils; //导入方法依赖的package包/类
public DynamicTypeReference(Class type, Type... types) {
  this.type = TypeUtils.parameterize(type, types);
}