/** * Generates the call to * {@link RequestBuilder#sendRequest(String, com.google.gwt.http.client.RequestCallback)} for * proxy methods. * * @return statement representing the request */ private Statement generateRequest(final ContextualStatementBuilder requestBuilder, final ContextualStatementBuilder proxy) { Statement sendRequest = null; if (resourceMethod.getParameters().getEntityParameter() == null) { sendRequest = proxy.invoke("sendRequest", requestBuilder, null, responseDemarshallingCallback()); } else { final Statement body = marshal(resourceMethod.getParameters().getEntityParameter(), resourceMethod.getContentTypeHeader()); sendRequest = proxy.invoke("sendRequest", requestBuilder, body, responseDemarshallingCallback()); } return sendRequest; }
public String getAcceptHeader() { return getHeaders().get("Accept"); }
/** * Generates the return statement of this proxy method if required. If the proxy method returns * void, it will just finish the method block. */ private void generateReturnStatement() { final Statement returnStatement = ProxyUtil.generateProxyMethodReturnStatement(resourceMethod.getMethod()); if (returnStatement != null) { methodBlock.append(returnStatement); } methodBlock.finish(); } }
public void generate() { if (resourceMethod.getHttpMethod() != null) { final JaxrsResourceMethodParameters jaxrsParams = resourceMethod.getParameters(); methodBlock.append(generateUrl(jaxrsParams)); methodBlock.append(generateRequestBuilder()); methodBlock.append(generateHeaders(jaxrsParams)); final List<Class<?>> interceptors = interceptorProvider.getInterceptors(remote, resourceMethod.getMethod()); if (!interceptors.isEmpty()) { methodBlock.append(generateInterceptorLogic(interceptors)); } else { methodBlock.append(generateRequest()); } } generateReturnStatement(); }
final MetaClass methodReturnType = resourceMethod.getMethod().getReturnType(); final Statement result; if (methodReturnType.equals(MetaClassFactory.get(void.class))) { methodReturnType, loadVariable("response").invoke("getText"), resourceMethod.getAcceptHeader());
/** * Generates the declaration for a new {@link RequestBuilder} instance, initialized with the * generated URL {@link #generateUrl(JaxrsResourceMethodParameters)} * * @return the RequestBuilder statement */ private Statement generateRequestBuilder() { final Statement requestBuilder = Stmt.declareVariable("requestBuilder", RequestBuilder.class, Stmt.newObject(RequestBuilder.class) .withParameters(resourceMethod.getHttpMethod(), Stmt.loadVariable("url").invoke("toString"))); return requestBuilder; }
final String path = resourceMethod.getPath(); ContextualStatementBuilder pathValue = Stmt.loadLiteral(path);
JaxrsResourceMethod resourceMethod = new JaxrsResourceMethod(method, headers, rootResourcePath); new JaxrsProxyMethodGenerator(remote, classBuilder, resourceMethod, interceptorProvider, context).generate();
public JaxrsProxyMethodGenerator(final MetaClass remote, final ClassStructureBuilder<?> classBuilder, final JaxrsResourceMethod resourceMethod, final InterceptorProvider interceptorProvider, final GeneratorContext context) { this.remote = remote; this.declaringClass = classBuilder.getClassDefinition(); this.resourceMethod = resourceMethod; this.interceptorProvider = interceptorProvider; this.context = context; final Parameter[] parms = DefParameters.from(resourceMethod.getMethod()).getParameters().toArray(new Parameter[0]); final Parameter[] finalParms = new Parameter[parms.length]; parameters = new ArrayList<>(); for (int i = 0; i < parms.length; i++) { finalParms[i] = Parameter.of(parms[i].getType(), parms[i].getName(), true); parameters.add(Stmt.loadVariable(parms[i].getName())); } this.methodBlock = classBuilder.publicMethod(resourceMethod.getMethod().getReturnType(), resourceMethod.getMethod().getName(), finalParms); }
public String getContentTypeHeader() { return getHeaders().get("Content-Type"); } }
/** * Asserts that the provided type is a valid collection type for JAX-RS resource parameters. * * @param paramType * the provided type. * @param paramName * the name of the resource parameter for error reporting. * @param jaxrsParamType * the JAX-RS resource parameter type for error reporting. * * @return the element type. * @throws GenerationException * if the type parameters of the collection type are invalid for JAX-RS resource * parameters. */ private MetaClass assertValidCollectionParam(final MetaClass paramType, final String paramName, final Class<?> jaxrsParamType) { final MetaParameterizedType queryParamPType = paramType.getParameterizedType(); final MetaType[] typeParams = (queryParamPType != null) ? queryParamPType.getTypeParameters() : null; if (typeParams != null && typeParams.length == 1 && typeParams[0] instanceof MetaClass && PrimitiveTypeMarshaller.canHandle((MetaClass) typeParams[0], "text/plain")) { return (MetaClass) typeParams[0]; } else { throw new GenerationException( "Unsupported type parameter found on " + jaxrsParamType.getSimpleName() + " with name " + paramName + " in method " + resourceMethod.getMethod() + " (check the JavaDocs of " + jaxrsParamType.getName() + " for details!)"); } }
for (final String key : resourceMethod.getHeaders().keySet()) { block.addStatement(Stmt.loadVariable("requestBuilder").invoke("setHeader", key, resourceMethod.getHeaders().get(key)));
JaxrsResourceMethodParameters.fromMethod(resourceMethod.getMethod(), "parameters"); resourceMethod.getMethod(), generateInterceptedRequest(), interceptors) .publicOverridesMethod("setParameters", Parameter.of(Object[].class, "parameters")) .append(new StringStatement("super.setParameters(parameters)"))