Example usage for org.springframework.core ResolvableType resolve

List of usage examples for org.springframework.core ResolvableType resolve

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.core.*
  5. ResolvableType
  6. resolve

Introduction

In this page you can find the example usage for org.springframework.core ResolvableType resolve.

Prototype

@Nullable
public Class<?> resolve()

Source Link

Document

Resolve this type to a java.lang.Class , returning null if the type cannot be resolved.

Usage

From source file:org.brutusin.rpc.RpcComponent.java

/**
 *
 * @param rt/* www  . j  a va2 s  .co m*/
 * @return
 */
protected static Type getType(final ResolvableType rt) {
    if (!rt.hasGenerics()) {
        return rt.resolve();
    } else {
        return new ParameterizedType() {
            public Type[] getActualTypeArguments() {
                Type[] ret = new Type[rt.getGenerics().length];
                for (int i = 0; i < ret.length; i++) {
                    ret[i] = getType(rt.getGenerics()[i]);
                }
                return ret;
            }

            public Type getRawType() {
                return rt.resolve();
            }

            public Type getOwnerType() {
                return null;
            }
        };
    }
}

From source file:com.ocs.dynamo.utils.ClassUtils.java

/**
 * Return a Class<?> representing the generic parameter for the given indexes. Indexes are zero
 * based; for example given the type Map<Integer, List<String>>, getGeneric(0) will access the
 * Integer. Nested generics can be accessed by specifying multiple indexes; for example
 * getGeneric(1, 0) will access the String from the nested List. For convenience, if no indexes
 * are specified the first generic is returned.
 * //w w  w  .  j  a va 2s.com
 * @param type
 * @param fieldName
 * @param indexes
 * @return
 */
public static <T> Class<?> getResolvedType(Class<T> type, String fieldName, int... indexes) {
    Field field = getField(type, fieldName);
    if (field != null) {
        ResolvableType rt = ResolvableType.forField(field);
        if (rt != null) {
            if (indexes != null && indexes.length > 0) {
                rt = rt.getGeneric(indexes);
            }
            if (rt != null) {
                return rt.resolve();
            }

        }
    }
    return null;
}

From source file:com.fitbur.jestify.junit.spring.injector.IndexMockInjector.java

@Override
public void inject() {
    Map<DescriptorKey, ParameterDescriptor> parameterDescriptors = context.getParamaterDescriptors();
    Field field = fieldDescriptor.getField();

    Mock mock = fieldDescriptor.getMock().get();
    Integer index = mock.index();
    Optional<ParameterDescriptor> optional = parameterDescriptors.values().parallelStream()
            .filter(p -> index.equals(p.getIndex())).findFirst();

    ParameterDescriptor parameterDescriptor = optional.get();
    Parameter parameter = parameterDescriptor.getParameter();

    Type fieldType = field.getGenericType();
    Type parameterType = parameter.getParameterizedType();

    checkArgument(fieldType.equals(parameterType),
            "Can not mock field '%s'. Test class field type '%s' and class under test "
                    + "constructor parameter type '%s' at '%d' index do not match.",
            field.getName(), field.getGenericType(), parameterType, index);

    ResolvableType resolver = ResolvableType.forType(parameterType);

    Class rawType;//from ww w. ja  v a 2 s .  com

    if (resolver.hasGenerics()) {
        if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
            rawType = resolver.getRawClass();
        } else {
            rawType = resolver.resolve();
        }
    } else {
        rawType = (Class) parameterType;
    }

    checkArgument(arguments[index] == null,
            "Can not mock field '%s'. Multipe test class fields have the same index of '%d'", field.getName(),
            index);

    Object instance = testReifier.reifyField(fieldDescriptor, parameterDescriptor);
    arguments[index] = instance;
}

From source file:com.fitbur.jestify.junit.spring.injector.NameMockInjector.java

@Override
public void inject() {
    Map<DescriptorKey, ParameterDescriptor> parameterDescriptors = context.getParamaterDescriptors();
    Field field = fieldDescriptor.getField();
    Type fieldType = field.getGenericType();

    Mock mock = fieldDescriptor.getMock().get();
    String mockName = mock.name();
    DescriptorKey descriptorKey = new DescriptorKey(fieldType, mockName);

    ParameterDescriptor parameterDescriptor = parameterDescriptors.get(descriptorKey);

    checkArgument(parameterDescriptor != null,
            "Can not mock field '%s'. Could not find class under test constructor "
                    + "argument with the name '%s'.",
            field.getName(), mockName);//from   ww  w .ja va  2  s .co  m

    Parameter parameter = parameterDescriptor.getParameter();
    Integer index = parameterDescriptor.getIndex();
    Type parameterType = parameter.getParameterizedType();

    checkArgument(fieldType.equals(parameterType),
            "Can not mock field '%s'. Test class field type '%s' and class under test "
                    + "constructor parameter type '%s' with name '%s' do not match.",
            field.getName(), field.getGenericType(), parameterType, mockName);

    ResolvableType resolver = ResolvableType.forType(parameterType);

    Class rawType;

    if (resolver.hasGenerics()) {
        if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
            rawType = resolver.getRawClass();
        } else {
            rawType = resolver.resolve();
        }
    } else {
        rawType = (Class) parameterType;
    }

    checkArgument(arguments[index] == null,
            "Can not mock field '%s'. Multipe test class fields have the same index of '%d'", field.getName(),
            index);

    Object instance = testReifier.reifyField(fieldDescriptor, parameterDescriptor);

    arguments[index] = instance;
}

From source file:org.jdal.aop.config.SerializableAnnotationBeanPostProcessor.java

/**
 * Lookup for {@link SerializableProxy} annotation on fields or methods and 
 * replace value with a Serializable proxy.
 *//*from   ww w.jav a  2s.co  m*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

    List<AnnotatedElement> elements = AnnotatedElementAccessor.findAnnotatedElements(SerializableProxy.class,
            bean.getClass());

    for (AnnotatedElement element : elements) {
        ResolvableType type = getResolvableType(element);
        Object value = AnnotatedElementAccessor.getValue(element, bean);
        if (value != null && !(value instanceof SerializableAopProxy)) {
            SerializableProxy ann = AnnotationUtils.getAnnotation(element, SerializableProxy.class);
            boolean proxyTargetClass = !type.resolve().isInterface() || ann.proxyTargetClass();
            Object proxy = getProxy(value, proxyTargetClass, ann.useCache(), getDependencyDescriptor(element),
                    beanName);
            if (proxy != null)
                AnnotatedElementAccessor.setValue(element, bean, proxy);
        }
    }

    return bean;
}

From source file:com.fitbur.jestify.junit.spring.injector.TypeMockInjector.java

@Override
public void inject() {
    Map<DescriptorKey, ParameterDescriptor> parameterDescriptors = context.getParamaterDescriptors();
    Field field = fieldDescriptor.getField();

    Mock mock = fieldDescriptor.getMock().get();
    Type fieldType = field.getGenericType();
    String fieldName = field.getName();
    DescriptorKey descriptorKey = new DescriptorKey(fieldType, fieldName);

    //if there is a parameter descriptor that matches the field then lets use that
    if (parameterDescriptors.containsKey(descriptorKey)) {
        ParameterDescriptor descriptor = parameterDescriptors.get(descriptorKey);
        Parameter parameter = descriptor.getParameter();
        Integer index = descriptor.getIndex();
        ResolvableType resolver = ResolvableType.forType(fieldType);

        Class rawType;//from w  w w .ja v  a2s  .  c o m

        if (resolver.hasGenerics()) {
            if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
                rawType = resolver.getRawClass();
            } else {
                rawType = resolver.resolve();
            }
        } else {
            rawType = (Class) fieldType;
        }
        Object instance = testReifier.reifyField(fieldDescriptor, descriptor);
        arguments[index] = instance;
    } else {
        //otherwise find the right parameter based on the type of the field
        Collection<ParameterDescriptor> descriptors = parameterDescriptors.values();
        for (ParameterDescriptor descriptor : descriptors) {
            Parameter parameter = descriptor.getParameter();
            Type parameterType = parameter.getParameterizedType();
            Integer index = descriptor.getIndex();

            ResolvableType resolver = ResolvableType.forType(parameterType);

            Class rawType;

            if (resolver.hasGenerics()) {
                if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
                    rawType = resolver.getRawClass();
                } else {
                    rawType = resolver.resolve();
                }
            } else {
                rawType = resolver.resolve();
            }

            if (arguments[index] != null) {
                continue;
            }

            if (parameterType.equals(fieldType)) {
                Object instance = testReifier.reifyField(fieldDescriptor, descriptor);
                arguments[index] = instance;
                break;
            }

        }
    }

}

From source file:tv.arte.resteventapi.core.querying.convertion.QueryOpParamGenericConverter.java

/**
 * {@inheritDoc}/*from   w ww  .j a v  a2s .co m*/
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {

    Object result = null;

    if (sourceType.getResolvableType().resolve().equals(String.class)
            && targetType.getResolvableType().resolve().equals(QueryOpParamValue.class)) {
        QueryOpParamValue queryOpParamValue = new QueryOpParamValue();

        ResolvableType genericResolvableType = targetType.getResolvableType().getGeneric(0);
        TypeDescriptor finalTargerTypeDescriptor = null;

        if (ResolvableType.NONE.equals(genericResolvableType)) {
            finalTargerTypeDescriptor = TypeDescriptor.valueOf(String.class);
        } else {
            finalTargerTypeDescriptor = new RestEventApiTypeDescriptor(genericResolvableType, null,
                    genericResolvableType.resolve().getAnnotations());
        }

        int queryOpSeparatorPosition = this.queryOpValueSeparatorPosition((String) source);
        QueryOp queryOp = this.extractQueryOp((String) source);
        String valuePart = this.extractValueString(queryOpSeparatorPosition, queryOp, (String) source);

        queryOpParamValue.setQueryOp(queryOp);
        queryOpParamValue.setValue(conversionService.convert(valuePart, sourceType, finalTargerTypeDescriptor));

        result = queryOpParamValue;
    } else if (sourceType.getResolvableType().resolve().equals(QueryOpParamValue.class)
            && targetType.getResolvableType().resolve().equals(String.class)) {
        QueryOpParamValue valToVonvert = (QueryOpParamValue) source;

        if (valToVonvert.getValue() != null) {
            String valueStr = conversionService.convert(valToVonvert.getValue(), String.class);
            if (StringUtils.isNotBlank(valueStr)) {
                result = this.assembleQueryOpValue(valToVonvert.getQueryOp(), valueStr);
            }
        }
    } else {
        throw new RestEventApiRuntimeException("Uncompatible conversion");
    }

    return result;
}

From source file:com.fitbur.jestify.junit.spring.IntegrationTestReifier.java

@Override
public Object reifyCut(CutDescriptor cutDescriptor, Object[] arguments) {
    return AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        try {//from  w w w  .  j av  a 2 s . c  o m
            Cut cut = cutDescriptor.getCut();
            Field field = cutDescriptor.getField();
            Type fieldType = field.getGenericType();
            String fieldName = field.getName();

            field.setAccessible(true);

            Constructor<?> constructor = cutDescriptor.getConstructor();
            constructor.setAccessible(true);

            ResolvableType resolver = ResolvableType.forType(fieldType);

            Class rawType;

            if (resolver.hasGenerics()) {
                if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
                    rawType = resolver.getRawClass();
                } else {
                    rawType = resolver.resolve();
                }
            } else {
                rawType = resolver.resolve();
            }

            Module module = testInstance.getClass().getDeclaredAnnotation(Module.class);

            GenericBeanDefinition bean = new GenericBeanDefinition();
            bean.setBeanClass(rawType);
            bean.setAutowireCandidate(false);
            bean.setScope(SCOPE_PROTOTYPE);
            bean.setPrimary(true);
            bean.setLazyInit(true);
            bean.setRole(RootBeanDefinition.ROLE_APPLICATION);
            bean.setAutowireMode(RootBeanDefinition.AUTOWIRE_NO);
            appContext.registerBeanDefinition(fieldName, bean);
            if (module != null) {
                appContext.register(module.value());
            }
            appContext.refresh();

            Object instance = appContext.getBean(fieldName, arguments);

            if (cut.value()) {
                instance = spy(instance);
            }

            field.set(testInstance, instance);

            return instance;
        } catch (SecurityException | IllegalAccessException | IllegalArgumentException e) {
            throw new RuntimeException(e);
        }
    });
}

From source file:com.fitbur.jestify.junit.spring.IntegrationTestReifier.java

@Override
public Object reifyField(FieldDescriptor fieldDescriptor, ParameterDescriptor parameterDescriptor) {
    return AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        try {/*from   ww w . j a  va2  s.c o  m*/
            Object instance;
            Field field = fieldDescriptor.getField();
            Type fieldType = field.getGenericType();
            field.setAccessible(true);

            Optional<Mock> optMock = fieldDescriptor.getMock();
            if (optMock.isPresent()) {
                Mock mock = optMock.get();
                Object value = field.get(testInstance);
                //if the field value is set then create a mock otherwise create a mock
                //that delegates to the value
                if (value == null) {
                    MockSettings settings = withSettings().defaultAnswer(mock.answer());

                    if (mock.extraInterfaces().length > 0) {
                        settings.extraInterfaces(mock.extraInterfaces());

                    }

                    instance = mock(field.getType(), settings);
                } else {
                    instance = mock(field.getType(), delegatesTo(value));
                }

            } else {
                ResolvableType resolver = ResolvableType.forType(fieldType);

                Class rawType;

                if (resolver.hasGenerics()) {
                    if (resolver.isAssignableFrom(Provider.class)
                            || resolver.isAssignableFrom(Optional.class)) {
                        rawType = resolver.getRawClass();
                    } else {
                        rawType = resolver.resolve();
                    }
                } else {
                    rawType = (Class) fieldType;
                }

                instance = appContext.getBean(rawType);
            }

            field.set(testInstance, instance);
            fieldDescriptor.setInstance(instance);
            parameterDescriptor.setInstance(instance);

            return instance;
        } catch (IllegalAccessException | IllegalArgumentException e) {
            throw new RuntimeException(e);
        }
    });

}

From source file:org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java

/**
 * Determine the target type for the given bean definition which is based on
 * a factory method. Only called if there is no singleton instance registered
 * for the target bean already./*w w  w  .  j  a va 2s . c o m*/
 * <p>This implementation determines the type matching {@link #createBean}'s
 * different creation strategies. As far as possible, we'll perform static
 * type checking to avoid creation of the target bean.
 * @param beanName the name of the bean (for error handling purposes)
 * @param mbd the merged bean definition for the bean
 * @param typesToMatch the types to match in case of internal type matching purposes
 * (also signals that the returned {@code Class} will never be exposed to application code)
 * @return the type for the bean if determinable, or {@code null} otherwise
 * @see #createBean
 */
@Nullable
protected Class<?> getTypeForFactoryMethod(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
    ResolvableType cachedReturnType = mbd.factoryMethodReturnType;
    if (cachedReturnType != null) {
        return cachedReturnType.resolve();
    }

    Class<?> factoryClass;
    boolean isStatic = true;

    String factoryBeanName = mbd.getFactoryBeanName();
    if (factoryBeanName != null) {
        if (factoryBeanName.equals(beanName)) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                    "factory-bean reference points back to the same bean definition");
        }
        // Check declared factory method return type on factory class.
        factoryClass = getType(factoryBeanName);
        isStatic = false;
    } else {
        // Check declared factory method return type on bean class.
        factoryClass = resolveBeanClass(mbd, beanName, typesToMatch);
    }

    if (factoryClass == null) {
        return null;
    }
    factoryClass = ClassUtils.getUserClass(factoryClass);

    // If all factory methods have the same return type, return that type.
    // Can't clearly figure out exact method due to type converting / autowiring!
    Class<?> commonType = null;
    Method uniqueCandidate = null;
    int minNrOfArgs = (mbd.hasConstructorArgumentValues()
            ? mbd.getConstructorArgumentValues().getArgumentCount()
            : 0);
    Method[] candidates = this.factoryMethodCandidateCache.computeIfAbsent(factoryClass,
            ReflectionUtils::getUniqueDeclaredMethods);

    for (Method candidate : candidates) {
        if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)
                && candidate.getParameterCount() >= minNrOfArgs) {
            // Declared type variables to inspect?
            if (candidate.getTypeParameters().length > 0) {
                try {
                    // Fully resolve parameter names and argument values.
                    Class<?>[] paramTypes = candidate.getParameterTypes();
                    String[] paramNames = null;
                    ParameterNameDiscoverer pnd = getParameterNameDiscoverer();
                    if (pnd != null) {
                        paramNames = pnd.getParameterNames(candidate);
                    }
                    ConstructorArgumentValues cav = mbd.getConstructorArgumentValues();
                    Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(
                            paramTypes.length);
                    Object[] args = new Object[paramTypes.length];
                    for (int i = 0; i < args.length; i++) {
                        ConstructorArgumentValues.ValueHolder valueHolder = cav.getArgumentValue(i,
                                paramTypes[i], (paramNames != null ? paramNames[i] : null), usedValueHolders);
                        if (valueHolder == null) {
                            valueHolder = cav.getGenericArgumentValue(null, null, usedValueHolders);
                        }
                        if (valueHolder != null) {
                            args[i] = valueHolder.getValue();
                            usedValueHolders.add(valueHolder);
                        }
                    }
                    Class<?> returnType = AutowireUtils.resolveReturnTypeForFactoryMethod(candidate, args,
                            getBeanClassLoader());
                    uniqueCandidate = (commonType == null && returnType == candidate.getReturnType() ? candidate
                            : null);
                    commonType = ClassUtils.determineCommonAncestor(returnType, commonType);
                    if (commonType == null) {
                        // Ambiguous return types found: return null to indicate "not determinable".
                        return null;
                    }
                } catch (Throwable ex) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Failed to resolve generic return type for factory method: " + ex);
                    }
                }
            } else {
                uniqueCandidate = (commonType == null ? candidate : null);
                commonType = ClassUtils.determineCommonAncestor(candidate.getReturnType(), commonType);
                if (commonType == null) {
                    // Ambiguous return types found: return null to indicate "not determinable".
                    return null;
                }
            }
        }
    }

    if (commonType == null) {
        return null;
    }
    // Common return type found: all factory methods return same type. For a non-parameterized
    // unique candidate, cache the full type declaration context of the target factory method.
    cachedReturnType = (uniqueCandidate != null ? ResolvableType.forMethodReturnType(uniqueCandidate)
            : ResolvableType.forClass(commonType));
    mbd.factoryMethodReturnType = cachedReturnType;
    return cachedReturnType.resolve();
}