Example usage for org.springframework.core GenericTypeResolver resolveTypeArguments

Introduction

In this page you can find the example usage for org.springframework.core GenericTypeResolver resolveTypeArguments.

Prototype

@Nullable
public static Class<?>[] resolveTypeArguments(Class<?> clazz, Class<?> genericIfc)

Source Link

Document

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.

Usage

From source file:fr.keemto.spikes.MultipleTypeArgumentsIT.java

@Test
public void genericType() throws Exception {
    ClassWithTypeArguments typor = new ClassWithTypeArguments();

    Class<?>[] args = GenericTypeResolver.resolveTypeArguments(typor.getClass(),
            InterfaceWithTypeArguments.class);

    assertThat(args.length, equalTo(2));
    assertTrue(args[0].equals(Twitter.class));
    assertTrue(args[1].equals(Connection.class));
}

From source file:com.castlemock.web.basis.service.ServiceRegistry.java

/**
 * The initialize method is responsible for initializing the service registry.
 * The initialize method will search for all the classes with the @service annotation and
 * store all the classes that are an instance of the Service class.
 *//*from  w  ww  .  j a  va  2  s . c om*/
public void initialize() {
    final Map<String, Object> components = applicationContext
            .getBeansWithAnnotation(org.springframework.stereotype.Service.class);
    for (Map.Entry<String, Object> entry : components.entrySet()) {
        final Object value = entry.getValue();
        if (value instanceof Service) {
            final Service service = (Service) value;
            final Class<?>[] processorInputOutputClasses = GenericTypeResolver
                    .resolveTypeArguments(service.getClass(), Service.class);
            final Class<I> processorInputClass = (Class<I>) processorInputOutputClasses[0];
            services.put(processorInputClass, service);
        }
    }
}

From source file:sample.data.mock.MockConversionService.java

private CrudRepository<Object, Serializable> getRepository(Class<?> domainClass, Class<?> idClass) {
    for (CrudRepository<Object, Serializable> repository : repositories) {
        Class<?>[] typeArgs = GenericTypeResolver.resolveTypeArguments(repository.getClass(),
                CrudRepository.class);
        if (domainClass.equals(typeArgs[0]) && conversionService.canConvert(typeArgs[1], idClass)) {
            return repository;
        }//from www  .  ja v  a  2s  .  com
    }
    return null;
}

From source file:io.twipple.springframework.data.clusterpoint.convert.support.CustomConversions.java

/**
 * Registers a conversion for the given converter. Inspects either generics or the convertible pairs returned
 * by a {@link GenericConverter}.// w w w.j a va 2s. c o  m
 *
 * @param converter the converter to register.
 */
private void registerConversion(@NotNull Object converter) {

    Assert.notNull(converter);

    Class<?> type = converter.getClass();
    boolean isWriting = type.isAnnotationPresent(WritingConverter.class);
    boolean isReading = type.isAnnotationPresent(ReadingConverter.class);

    if (converter instanceof GenericConverter) {
        GenericConverter genericConverter = (GenericConverter) converter;
        for (GenericConverter.ConvertiblePair pair : genericConverter.getConvertibleTypes()) {
            register(new ConverterRegistration(pair, isReading, isWriting));
        }
    } else if (converter instanceof Converter) {
        Class<?>[] arguments = GenericTypeResolver.resolveTypeArguments(converter.getClass(), Converter.class);
        register(new ConverterRegistration(arguments[0], arguments[1], isReading, isWriting));
    } else {
        throw new IllegalArgumentException("Unsupported Converter type!");
    }
}

From source file:com.frank.search.solr.core.convert.CustomConversions.java

private void registerConversion(Object converter) {
    Class<?> type = converter.getClass();
    boolean isWriting = type.isAnnotationPresent(WritingConverter.class);
    boolean isReading = type.isAnnotationPresent(ReadingConverter.class);

    if (!isReading && !isWriting) {
        isReading = true;/* w ww .  java  2 s.  c  o  m*/
        isWriting = true;
    }

    if (converter instanceof GenericConverter) {
        GenericConverter genericConverter = (GenericConverter) converter;
        for (ConvertiblePair pair : genericConverter.getConvertibleTypes()) {
            register(new ConvertibleContext(pair, isReading, isWriting));
        }
    } else if (converter instanceof Converter) {
        Class<?>[] arguments = GenericTypeResolver.resolveTypeArguments(converter.getClass(), Converter.class);
        register(new ConvertibleContext(arguments[0], arguments[1], isReading, isWriting));
    } else {
        throw new IllegalArgumentException(
                "Unsupported Converter type! Expected either GenericConverter if Converter.");
    }
}

From source file:org.grails.datastore.mapping.simpledb.model.types.SimpleDBTypeConverterRegistrar.java

private GenericConverter.ConvertiblePair getRequiredTypeInfo(Object converter, Class<?> genericIfc) {
    Class<?>[] args = GenericTypeResolver.resolveTypeArguments(converter.getClass(), genericIfc);
    return (args != null ? new GenericConverter.ConvertiblePair(args[0], args[1]) : null);
}

From source file:cz.jirutka.spring.data.jdbc.BaseJdbcRepository.java

@SuppressWarnings("unchecked")
private EntityInformation<T, ID> createEntityInformation() {

    Class<T> entityType = (Class<T>) GenericTypeResolver.resolveTypeArguments(getClass(),
            BaseJdbcRepository.class)[0];

    if (Persistable.class.isAssignableFrom(entityType)) {
        return new PersistableEntityInformation(entityType);
    }//  w  w w . j ava 2 s  .  c  o m
    return new ReflectionEntityInformation(entityType);
}

From source file:gr.abiss.calipso.tiers.processor.ModelDrivenBeanGeneratingRegistryPostProcessor.java

/**
 * Iterate over registered beans to find any manually-created components
 * (Controllers, Services, Repositories) we can skipp from generating.
 * /* w w  w. j  a v  a2 s  .c  o m*/
 * @param registry
 */
protected void findExistingBeans(BeanDefinitionRegistry registry) {
    for (String name : registry.getBeanDefinitionNames()) {

        BeanDefinition d = registry.getBeanDefinition(name);

        if (d instanceof AbstractBeanDefinition) {
            AbstractBeanDefinition def = (AbstractBeanDefinition) d;
            // if controller
            if (isOfType(def, ModelController.class)) {
                Class<?> entity = GenericTypeResolver.resolveTypeArguments(
                        ClassUtils.getClass(def.getBeanClassName()), ModelController.class)[0];

                ModelContext modelContext = entityModelContextsMap.get(entity);
                if (modelContext != null) {
                    modelContext.setControllerDefinition(def);
                }
            }
            // if service
            if (isOfType(def, AbstractModelServiceImpl.class)) {
                Class<?> entity = GenericTypeResolver.resolveTypeArguments(
                        ClassUtils.getClass(def.getBeanClassName()), ModelService.class)[0];
                ModelContext modelContext = entityModelContextsMap.get(entity);
                if (modelContext != null) {
                    modelContext.setServiceDefinition(def);
                }
            }
            // if repository
            else if (isOfType(def, JpaRepositoryFactoryBean.class) || isOfType(def, JpaRepository.class)) {
                String repoName = (String) def.getPropertyValues().get("repositoryInterface");

                Class<?> repoInterface = ClassUtils.getClass(repoName);
                if (JpaRepository.class.isAssignableFrom(repoInterface)) {
                    Class<?> entity = GenericTypeResolver.resolveTypeArguments(repoInterface,
                            JpaRepository.class)[0];
                    ModelContext modelContext = entityModelContextsMap.get(entity);
                    if (modelContext != null) {
                        modelContext.setRepositoryDefinition(def);
                    }
                }
            }

        }

    }
}

From source file:gr.abiss.calipso.tiers.processor.ModelDrivenBeansGenerator.java

/**
 * Iterate over registered beans to find any manually-created components
 * (Controllers, Services, Repositories) we can skipp from generating.
 * //from w  w w  .  jav  a2 s  .  c  om
 * @param registry
 */
protected void findExistingBeans(BeanDefinitionRegistry registry) {
    for (String name : registry.getBeanDefinitionNames()) {

        BeanDefinition d = registry.getBeanDefinition(name);

        if (d instanceof AbstractBeanDefinition) {
            AbstractBeanDefinition def = (AbstractBeanDefinition) d;
            // if controller
            if (isOfType(def, ModelController.class)) {
                Class<?> entity = GenericTypeResolver.resolveTypeArguments(
                        ClassUtils.getClass(def.getBeanClassName()), ModelController.class)[0];

                ModelContext modelContext = entityModelContextsMap.get(entity);
                if (modelContext != null) {
                    modelContext.setControllerDefinition(def);
                }
            }
            // if service 
            if (isOfType(def, AbstractModelServiceImpl.class)) {
                Class<?> entity = GenericTypeResolver.resolveTypeArguments(
                        ClassUtils.getClass(def.getBeanClassName()), ModelService.class)[0];
                ModelContext modelContext = entityModelContextsMap.get(entity);
                if (modelContext != null) {
                    modelContext.setServiceDefinition(def);
                }
            }
            // if repository
            else if (isOfType(def, JpaRepositoryFactoryBean.class) || isOfType(def, JpaRepository.class)) {
                String repoName = (String) def.getPropertyValues().get("repositoryInterface");

                Class<?> repoInterface = ClassUtils.getClass(repoName);
                if (JpaRepository.class.isAssignableFrom(repoInterface)) {
                    Class<?> entity = GenericTypeResolver.resolveTypeArguments(repoInterface,
                            JpaRepository.class)[0];
                    ModelContext modelContext = entityModelContextsMap.get(entity);
                    if (modelContext != null) {
                        modelContext.setRepositoryDefinition(def);
                    }
                }
            }

        }

    }
}