Example usage for java.lang.reflect Method getGenericReturnType

Introduction

In this page you can find the example usage for java.lang.reflect Method getGenericReturnType.

Prototype

public Type getGenericReturnType() 

Source Link

Document

Returns a Type object that represents the formal return type of the method represented by this Method object.

Usage

From source file:org.rhq.scripting.javascript.JavascriptCompletor.java

private String getSignature(Object object, Method m) {

    StringBuilder buf = new StringBuilder();
    Type[] params = m.getGenericParameterTypes();
    int i = 0;/*  w ww  . j a v  a 2  s  .c o  m*/
    m = metadataProvider.getUnproxiedMethod(m);

    buf.append(metadataProvider.getTypeName(m.getGenericReturnType(), false));
    buf.append(" ");

    buf.append(m.getName());
    buf.append("(");
    boolean first = true;
    for (Type type : params) {
        if (!first) {
            buf.append(", ");
        } else {
            first = false;
        }

        String name = metadataProvider.getTypeName(type, false);
        String paramName = metadataProvider.getParameterName(m, i);
        if (paramName != null) {
            name += " " + paramName;
        }

        buf.append(name);

        i++;
    }
    buf.append(")");
    return buf.toString();
}

---

From source file:org.fusesource.ide.generator.Generator.java

private Class<?> elementTypeClass(Property<?> prop) {
    if (isJavaCollection(prop)) {
        if (prop instanceof FieldProperty) {
            FieldProperty fieldProp = (FieldProperty) prop;
            Field fld = fieldProp.getField();
            return elementTypeClass(fld.getGenericType());
        }//  ww  w .j a va2  s .  c o  m
        if (prop instanceof BeanProperty) {
            BeanProperty beanProp = (BeanProperty) prop;
            Method readMethod = beanProp.descriptor().getReadMethod();
            if (readMethod != null) {
                return elementTypeClass(readMethod.getGenericReturnType());
            }
        }
    }
    return null;
}

---

From source file:org.itest.impl.ITestRandomObjectGeneratorImpl.java

protected void fillMethod(Method m, Object res, String mSignature, Map<String, Type> map,
        ITestContext iTestContext, Map<String, Object> methodResults) {
    try {//from   w  w  w .j a  va 2 s  .  c o  m
        iTestContext.enter(res, mSignature);
        ITestParamState mITestState = iTestContext.getCurrentParam();
        Type rType = ITestTypeUtil.getTypeProxy(m.getGenericReturnType(), map);
        Object o = generateRandom(rType, map, iTestContext);
        methodResults.put(ITestUtils.getMethodSingnature(m, true), o);
        iTestContext.leave(o);
    } catch (ITestException e) {
        e.addPrefix(mSignature);
        throw e;
    } catch (IllegalArgumentException e) {
        throw new ITestIllegalArgumentException(e);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

}

---

From source file:org.appverse.web.framework.backend.rest.services.integration.impl.live.RestPersistenceService.java

/**
 * Use reflection to get the actual generic type
 * /*from   w ww  . j a v a  2 s  .  c  o  m*/
 * @return
 * @throws Exception
 */
@SuppressWarnings("unchecked")
protected Class<T> getClassP() throws Exception {
    Method method = this.getClass().getMethod("getTypeSafeList");

    Type returnType = method.getGenericReturnType();
    Class<T> classP = null;

    if (returnType instanceof ParameterizedType) {
        ParameterizedType type = (ParameterizedType) returnType;
        Type[] typeArguments = type.getActualTypeArguments();
        for (Type typeArgument : typeArguments) {
            classP = (Class<T>) typeArgument;
            System.out.println("typeArgClass = " + classP);
        }
    }
    return classP;

}

---

From source file:com.snaplogic.snaps.firstdata.Create.java

private Object prepareListObj(Object requestObj, String claszPath, String method2Invoke, Object inputData) {
    if (inputData != null) {
        Class<?> clasz = getClassType(claszPath);
        Method method;
        try {//from   w ww .java 2  s . c o  m
            method = clasz.getDeclaredMethod(String.format(GETTER, method2Invoke));
            ParameterizedType fieldGenericType = (ParameterizedType) method.getGenericReturnType();
            Class<?> fieldTypeParameterType = (Class<?>) fieldGenericType.getActualTypeArguments()[0];
            List<Object> list = (List<Object>) method.invoke(requestObj);
            if (inputData instanceof List) {
                List<Map<String, Object>> inputList = List.class.cast(inputData);
                for (Map<String, Object> mapObj : inputList) {
                    Object obj = getObject(fieldTypeParameterType.getName(), mapObj);
                    list.add(obj);
                }
            } else if (inputData instanceof Map) {
                Object obj = getObject(fieldTypeParameterType.getName(), Map.class.cast(inputData));
                list.add(obj);
            }
        } catch (NoSuchMethodException | SecurityException e) {
            log.warn(e.getMessage(), e);
        } catch (IllegalAccessException e) {
            log.warn(e.getMessage(), e);
        } catch (IllegalArgumentException e) {
            log.warn(e.getMessage(), e);
        } catch (InvocationTargetException e) {
            log.warn(e.getMessage(), e);
        }
    }
    return requestObj;
}

---

From source file:com.almende.eve.agent.AgentProxyFactory.java

/**
 * Gen proxy.//  w  ww . j  av a 2  s. c  o m
 * 
 * @param <T>
 *            the generic type
 * @param sender
 *            the sender
 * @param receiverUrl
 *            the receiver url
 * @param proxyInterface
 *            the interface this proxy implements
 * @return the t
 */
@SuppressWarnings("unchecked")
public static <T> T genProxy(final Agent sender, final URI receiverUrl, final Class<T> proxyInterface) {
    // http://docs.oracle.com/javase/1.4.2/docs/guide/reflection/proxy.html
    final T proxy = (T) Proxy.newProxyInstance(proxyInterface.getClassLoader(), new Class[] { proxyInterface },
            new InvocationHandler() {

                private Map<Method, Boolean> cache = new HashMap<Method, Boolean>();

                @Override
                public Object invoke(final Object proxy, final Method method, final Object[] args) {
                    boolean doSync = true;
                    if (cache.containsKey(method)) {
                        doSync = cache.get(method);
                    } else {
                        AnnotatedClass clazz = AnnotationUtil.get(proxyInterface);
                        if (clazz != null) {
                            List<AnnotatedMethod> list = clazz.getMethods(method.getName());
                            for (AnnotatedMethod m : list) {
                                if (m.getAnnotation(NoReply.class) != null) {
                                    doSync = false;
                                }
                            }
                            if (doSync && method.getReturnType().equals(void.class)
                                    && clazz.getAnnotation(NoReply.class) != null) {
                                doSync = false;
                            }
                        }
                        cache.put(method, doSync);
                    }
                    SyncCallback<JsonNode> callback = null;
                    if (doSync) {
                        callback = new SyncCallback<JsonNode>() {
                        };
                    }
                    try {
                        sender.call(receiverUrl, method, args, callback);
                    } catch (final IOException e) {
                        throw new JSONRPCException(CODE.REMOTE_EXCEPTION, e.getLocalizedMessage(), e);
                    }
                    if (callback != null) {
                        try {
                            return TypeUtil.inject(callback.get(), method.getGenericReturnType());
                        } catch (final Exception e) {
                            throw new JSONRPCException(CODE.REMOTE_EXCEPTION, e.getLocalizedMessage(), e);
                        }
                    }
                    return null;
                }
            });
    return proxy;
}

---

From source file:com.evolveum.midpoint.prism.marshaller.BeanMarshaller.java

private void setExplicitTypeDeclarationIfNeeded(XNode node, Method getter, Object getterResult,
        QName typeName) {// www . j  a  v  a 2 s  .  co  m
    if (typeName == null) {
        // the idea is not to overwrite pre-existing explicit type declaration with null value
        // TODO reconsider
        return;
    }
    Class getterReturnType = getter.getReturnType();
    Class getterType = null;
    if (Collection.class.isAssignableFrom(getterReturnType)) {
        Type genericReturnType = getter.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType) {
            Type actualType = inspector.getTypeArgument(genericReturnType, "explicit type declaration");
            if (actualType instanceof Class) {
                getterType = (Class) actualType;
            } else if (actualType instanceof ParameterizedType) {
                ParameterizedType parameterizedType = (ParameterizedType) actualType;
                Type typeArgument = inspector.getTypeArgument(parameterizedType, "JAXBElement return type");
                getterType = inspector.getUpperBound(typeArgument, "JAXBElement return type");
            }
        }
    }
    if (getterType == null) {
        getterType = getterReturnType;
    }
    Class getterResultReturnType = getterResult.getClass();
    if (node != null && getterType != getterResultReturnType
            && getterType.isAssignableFrom(getterResultReturnType)) {
        node.setExplicitTypeDeclaration(true);
        node.setTypeQName(typeName);
    }
}

---

From source file:com.evolveum.midpoint.repo.sql.helpers.ObjectDeltaUpdater.java

private Class getRealOutputType(Attribute attribute) {
    Class type = attribute.getJavaType();
    if (!Collection.class.isAssignableFrom(type)) {
        return type;
    }/*from w ww . j  a  va  2  s.  c o  m*/

    Method method = (Method) attribute.getJavaMember();
    ParameterizedType parametrized = (ParameterizedType) method.getGenericReturnType();
    Type t = parametrized.getActualTypeArguments()[0];
    if (t instanceof Class) {
        return (Class) t;
    }

    parametrized = (ParameterizedType) t;
    return (Class) parametrized.getRawType();
}

---

From source file:jef.tools.reflect.ClassEx.java

/**
 * ??/* w w  w.j a v  a2s  .  c  om*/
 * 
 * @param method
 * @return
 */
public Type getMethodReturnType(Method method) {
    ClassEx cw = this;
    method = getRealMethod(method);
    if (method.getDeclaringClass() != this.cls) {
        Type type = GenericUtils.getSuperType(null, cls, method.getDeclaringClass());
        cw = new ClassEx(type);
    }
    return BeanUtils.getBoundType(method.getGenericReturnType(), cw);
}

---

From source file:com.bstek.dorado.view.output.ClientOutputHelper.java

protected Map<String, PropertyConfig> doGetPropertyConfigs(Class<?> beanType) throws Exception {
    beanType = ProxyBeanUtils.getProxyTargetType(beanType);
    Map<String, PropertyConfig> propertyConfigs = new HashMap<String, PropertyConfig>();

    ClientObjectInfo clientObjectInfo = getClientObjectInfo(beanType);
    if (clientObjectInfo != null) {
        for (Map.Entry<String, ClientProperty> entry : clientObjectInfo.getPropertyConfigs().entrySet()) {
            String property = entry.getKey();
            ClientProperty clientProperty = entry.getValue();

            PropertyConfig propertyConfig = new PropertyConfig();
            if (clientProperty.ignored()) {
                propertyConfig.setIgnored(true);
            } else {
                if (StringUtils.isNotEmpty(clientProperty.outputter())) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(clientProperty.outputter(),
                            Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                }/*from   w  ww .  ja v  a  2  s  .c om*/

                if (clientProperty.alwaysOutput()) {
                    propertyConfig.setEscapeValue(FAKE_ESCAPE_VALUE);
                } else if (StringUtils.isNotEmpty(clientProperty.escapeValue())) {
                    propertyConfig.setEscapeValue(clientProperty.escapeValue());
                }
            }
            propertyConfigs.put(property, propertyConfig);
        }
    }

    boolean isAssembledComponent = (AssembledComponent.class.isAssignableFrom(beanType));
    Class<?> superComponentType = null;
    if (isAssembledComponent) {
        superComponentType = beanType;
        while (superComponentType != null && AssembledComponent.class.isAssignableFrom(superComponentType)) {
            superComponentType = superComponentType.getSuperclass();
            Assert.notNull(superComponentType);
        }
    }

    for (PropertyDescriptor propertyDescriptor : PropertyUtils.getPropertyDescriptors(beanType)) {
        String property = propertyDescriptor.getName();
        Method readMethod = propertyDescriptor.getReadMethod();
        if (readMethod.getDeclaringClass() != beanType) {
            try {
                readMethod = beanType.getMethod(readMethod.getName(), readMethod.getParameterTypes());
            } catch (NoSuchMethodException e) {
                // do nothing
            }
        }

        TypeInfo typeInfo;
        Class<?> propertyType = propertyDescriptor.getPropertyType();
        if (Collection.class.isAssignableFrom(propertyType)) {
            typeInfo = TypeInfo.parse((ParameterizedType) readMethod.getGenericReturnType(), true);
            if (typeInfo != null) {
                propertyType = typeInfo.getType();
            }
        } else if (propertyType.isArray()) {
            typeInfo = new TypeInfo(propertyType.getComponentType(), true);
        } else {
            typeInfo = new TypeInfo(propertyType, false);
        }

        PropertyConfig propertyConfig = null;
        ClientProperty clientProperty = readMethod.getAnnotation(ClientProperty.class);
        if (clientProperty != null) {
            propertyConfig = new PropertyConfig();
            if (clientProperty.ignored()) {
                propertyConfig.setIgnored(true);
            } else {
                if (StringUtils.isNotEmpty(clientProperty.outputter())) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(clientProperty.outputter(),
                            Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (Component.class.isAssignableFrom(propertyType)) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(COMPONENT_OUTPUTTER, Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (DataControl.class.isAssignableFrom(propertyType)
                        || FloatControl.class.isAssignableFrom(propertyType)) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(COMPONENT_OUTPUTTER, Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (DataType.class.isAssignableFrom(propertyType)) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(DATA_TYPE_PROPERTY_OUTPUTTER,
                            Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (Object.class.equals(propertyType)) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(DATA_OUTPUTTER, Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                } else if (!EntityUtils.isSimpleType(propertyType) && !propertyType.isArray()) {
                    BeanWrapper beanWrapper = BeanFactoryUtils.getBean(OBJECT_OUTPUTTER, Scope.instant);
                    propertyConfig.setOutputter(beanWrapper.getBean());
                }

                if (!clientProperty.evaluateExpression()) {
                    propertyConfig.setEvaluateExpression(false);
                }

                if (clientProperty.alwaysOutput()) {
                    propertyConfig.setEscapeValue(FAKE_ESCAPE_VALUE);
                } else if (StringUtils.isNotEmpty(clientProperty.escapeValue())) {
                    propertyConfig.setEscapeValue(clientProperty.escapeValue());
                }
            }
        } else if (isAssembledComponent && readMethod.getDeclaringClass() == beanType
                && EntityUtils.isSimpleType(propertyType)) {
            if (BeanUtils.getPropertyDescriptor(superComponentType, property) == null) {
                propertyConfig = new PropertyConfig();
                propertyConfig.setIgnored(true);
            }
        }

        ComponentReference componentReference = readMethod.getAnnotation(ComponentReference.class);
        if (componentReference != null && String.class.equals(propertyType)) {
            if (propertyConfig == null) {
                propertyConfig = new PropertyConfig();
            }
            if (propertyConfig.getOutputter() == null) {
                BeanWrapper beanWrapper = BeanFactoryUtils.getBean(COMPONENT_REFERENCE_OUTPUTTER,
                        Scope.instant);
                propertyConfig.setOutputter(beanWrapper.getBean());
            }
        }

        if (!propertyType.isPrimitive() && (Number.class.isAssignableFrom(propertyType)
                || Boolean.class.isAssignableFrom(propertyType))) {
            if (propertyConfig == null) {
                propertyConfig = new PropertyConfig();
            }
            if (propertyConfig.getEscapeValue() == PropertyConfig.NONE_VALUE) {
                propertyConfig.setEscapeValue(null);
            }
        }

        if (propertyConfig != null) {
            propertyConfigs.put(property, propertyConfig);
        }
    }
    return (propertyConfigs.isEmpty()) ? null : propertyConfigs;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• »