Exemple #1
0
 private static boolean isIgnorableParameter(Method m, Parameter p) {
   if (p.getType() == ParameterType.CONTEXT) {
     return true;
   }
   return p.getType() == ParameterType.REQUEST_BODY
       && m.getParameterTypes()[p.getIndex()] == AsyncResponse.class;
 }
Exemple #2
0
 private static UserOperation getOperationFromElement(Element e) {
   UserOperation op = new UserOperation();
   op.setName(e.getAttribute("name"));
   op.setVerb(e.getAttribute("verb"));
   op.setPath(e.getAttribute("path"));
   op.setOneway(Boolean.parseBoolean(e.getAttribute("oneway")));
   op.setConsumes(e.getAttribute("consumes"));
   op.setProduces(e.getAttribute("produces"));
   List<Element> paramEls =
       DOMUtils.findAllElementsByTagNameNS(e, "http://cxf.apache.org/jaxrs", "param");
   List<Parameter> params = new ArrayList<Parameter>(paramEls.size());
   for (int i = 0; i < paramEls.size(); i++) {
     Element paramEl = paramEls.get(i);
     Parameter p = new Parameter(paramEl.getAttribute("type"), i, paramEl.getAttribute("name"));
     p.setEncoded(Boolean.valueOf(paramEl.getAttribute("encoded")));
     p.setDefaultValue(paramEl.getAttribute("defaultValue"));
     String pClass = paramEl.getAttribute("class");
     if (!StringUtils.isEmpty(pClass)) {
       try {
         p.setJavaType(ClassLoaderUtils.loadClass(pClass, ResourceUtils.class));
       } catch (Exception ex) {
         throw new RuntimeException(ex);
       }
     }
     params.add(p);
   }
   op.setParameters(params);
   return op;
 }
Exemple #3
0
  private static MultivaluedMap<ParameterType, Parameter> getParametersInfo(
      Method m, Object[] params, OperationResourceInfo ori) {
    MultivaluedMap<ParameterType, Parameter> map = new MetadataMap<ParameterType, Parameter>();

    List<Parameter> parameters = ori.getParameters();
    if (parameters.size() == 0) {
      return map;
    }
    int requestBodyParam = 0;
    int multipartParam = 0;
    for (Parameter p : parameters) {
      if (isIgnorableParameter(m, p)) {
        continue;
      }
      if (p.getType() == ParameterType.REQUEST_BODY) {
        requestBodyParam++;
        if (getMultipart(ori, p.getIndex()) != null) {
          multipartParam++;
        }
      }
      map.add(p.getType(), p);
    }

    if (map.containsKey(ParameterType.REQUEST_BODY)) {
      if (requestBodyParam > 1 && requestBodyParam != multipartParam) {
        reportInvalidResourceMethod(ori.getMethodToInvoke(), "SINGLE_BODY_ONLY");
      }
      if (map.containsKey(ParameterType.FORM)) {
        reportInvalidResourceMethod(ori.getMethodToInvoke(), "ONLY_FORM_ALLOWED");
      }
    }
    return map;
  }
Exemple #4
0
  private static void getAllTypesForResource(
      ClassResourceInfo resource,
      ResourceTypes types,
      boolean jaxbOnly,
      MessageBodyWriter<?> jaxbWriter) {
    for (OperationResourceInfo ori : resource.getMethodDispatcher().getOperationResourceInfos()) {
      Method method = ori.getMethodToInvoke();
      Class<?> realReturnType = method.getReturnType();
      Class<?> cls = realReturnType;
      if (cls == Response.class) {
        cls = getActualJaxbType(cls, method, false);
      }
      Type type = method.getGenericReturnType();
      if (jaxbOnly) {
        checkJaxbType(
            resource.getServiceClass(),
            cls,
            realReturnType == Response.class ? cls : type,
            types,
            method.getAnnotations(),
            jaxbWriter);
      } else {
        types.getAllTypes().put(cls, type);
      }

      for (Parameter pm : ori.getParameters()) {
        if (pm.getType() == ParameterType.REQUEST_BODY) {
          Class<?> inType = method.getParameterTypes()[pm.getIndex()];
          Type paramType = method.getGenericParameterTypes()[pm.getIndex()];
          if (jaxbOnly) {
            checkJaxbType(
                resource.getServiceClass(),
                inType,
                paramType,
                types,
                method.getParameterAnnotations()[pm.getIndex()],
                jaxbWriter);
          } else {
            types.getAllTypes().put(inType, paramType);
          }
        }
      }
    }

    for (ClassResourceInfo sub : resource.getSubResources()) {
      if (!isRecursiveSubResource(resource, sub)) {
        getAllTypesForResource(sub, types, jaxbOnly, jaxbWriter);
      }
    }
  }
Exemple #5
0
  private List<Attachment> handleMultipart(
      MultivaluedMap<ParameterType, Parameter> map, OperationResourceInfo ori, Object[] params) {

    List<Attachment> atts = new LinkedList<Attachment>();
    List<Parameter> fm = getParameters(map, ParameterType.REQUEST_BODY);
    for (Parameter p : fm) {
      Multipart part = getMultipart(ori, p.getIndex());
      if (part != null) {
        Object partObject = params[p.getIndex()];
        if (partObject != null) {
          atts.add(new Attachment(part.value(), part.type(), partObject));
        }
      }
    }
    return atts;
  }
Exemple #6
0
  private MultivaluedMap<String, String> handleForm(
      Method m,
      Object[] params,
      MultivaluedMap<ParameterType, Parameter> map,
      List<Parameter> beanParams) {

    MultivaluedMap<String, String> form = new MetadataMap<String, String>();

    List<Parameter> fm = getParameters(map, ParameterType.FORM);
    for (Parameter p : fm) {
      addFormValue(form, p.getName(), params[p.getIndex()], getParamAnnotations(m, p));
    }
    for (Parameter p : beanParams) {
      Map<String, BeanPair> values = getValuesFromBeanParam(params[p.getIndex()], FormParam.class);
      for (Map.Entry<String, BeanPair> entry : values.entrySet()) {
        addFormValue(form, entry.getKey(), entry.getValue().getValue(), entry.getValue().getAnns());
      }
    }

    return form;
  }
Exemple #7
0
 private void handleCookies(
     Method m,
     Object[] params,
     MultivaluedMap<String, String> headers,
     List<Parameter> beanParams,
     MultivaluedMap<ParameterType, Parameter> map) {
   List<Parameter> cs = getParameters(map, ParameterType.COOKIE);
   for (Parameter p : cs) {
     if (params[p.getIndex()] != null) {
       headers.add(
           HttpHeaders.COOKIE,
           p.getName()
               + '='
               + convertParamValue(params[p.getIndex()].toString(), getParamAnnotations(m, p)));
     }
   }
   for (Parameter p : beanParams) {
     Map<String, BeanPair> values =
         getValuesFromBeanParam(params[p.getIndex()], CookieParam.class);
     for (Map.Entry<String, BeanPair> entry : values.entrySet()) {
       if (entry.getValue() != null) {
         headers.add(
             HttpHeaders.COOKIE,
             entry.getKey()
                 + "="
                 + convertParamValue(entry.getValue().getValue(), entry.getValue().getAnns()));
       }
     }
   }
 }
Exemple #8
0
 private void handleHeaders(
     Method m,
     Object[] params,
     MultivaluedMap<String, String> headers,
     List<Parameter> beanParams,
     MultivaluedMap<ParameterType, Parameter> map) {
   List<Parameter> hs = getParameters(map, ParameterType.HEADER);
   for (Parameter p : hs) {
     if (params[p.getIndex()] != null) {
       headers.add(
           p.getName(), convertParamValue(params[p.getIndex()], getParamAnnotations(m, p)));
     }
   }
   for (Parameter p : beanParams) {
     Map<String, BeanPair> values =
         getValuesFromBeanParam(params[p.getIndex()], HeaderParam.class);
     for (Map.Entry<String, BeanPair> entry : values.entrySet()) {
       if (entry.getValue() != null) {
         headers.add(
             entry.getKey(),
             convertParamValue(entry.getValue().getValue(), entry.getValue().getAnns()));
       }
     }
   }
 }
Exemple #9
0
 private void handleMatrixes(
     Method m,
     Object[] params,
     MultivaluedMap<ParameterType, Parameter> map,
     List<Parameter> beanParams,
     UriBuilder ub) {
   List<Parameter> mx = getParameters(map, ParameterType.MATRIX);
   for (Parameter p : mx) {
     if (params[p.getIndex()] != null) {
       addMatrixQueryParamsToBuilder(
           ub, p.getName(), ParameterType.MATRIX, getParamAnnotations(m, p), params[p.getIndex()]);
     }
   }
   for (Parameter p : beanParams) {
     Map<String, BeanPair> values =
         getValuesFromBeanParam(params[p.getIndex()], MatrixParam.class);
     for (Map.Entry<String, BeanPair> entry : values.entrySet()) {
       if (entry.getValue() != null) {
         addMatrixQueryParamsToBuilder(
             ub,
             entry.getKey(),
             ParameterType.MATRIX,
             entry.getValue().getAnns(),
             entry.getValue().getValue());
       }
     }
   }
 }
Exemple #10
0
 private static Annotation[] getParamAnnotations(Method m, Parameter p) {
   return m.getParameterAnnotations()[p.getIndex()];
 }
Exemple #11
0
  private List<Object> getPathParamValues(
      Method m,
      Object[] params,
      MultivaluedMap<ParameterType, Parameter> map,
      List<Parameter> beanParams,
      OperationResourceInfo ori,
      int bodyIndex) {
    List<Object> list = new LinkedList<Object>();

    List<String> methodVars = ori.getURITemplate().getVariables();
    List<Parameter> paramsList = getParameters(map, ParameterType.PATH);
    Map<String, BeanPair> beanParamValues = new HashMap<String, BeanPair>(beanParams.size());
    for (Parameter p : beanParams) {
      beanParamValues.putAll(getValuesFromBeanParam(params[p.getIndex()], PathParam.class));
    }
    if (!beanParamValues.isEmpty() && !methodVars.containsAll(beanParamValues.keySet())) {
      List<String> classVars = ori.getClassResourceInfo().getURITemplate().getVariables();
      for (String classVar : classVars) {
        BeanPair pair = beanParamValues.get(classVar);
        if (pair != null) {
          Object paramValue = convertParamValue(pair.getValue(), pair.getAnns());
          if (isRoot) {
            valuesMap.put(classVar, paramValue);
          } else {
            list.add(paramValue);
          }
        }
      }
    }
    if (isRoot) {
      list.addAll(valuesMap.values());
    }

    Map<String, Parameter> paramsMap = new LinkedHashMap<String, Parameter>();
    for (Parameter p : paramsList) {
      if (p.getName().length() == 0) {
        MultivaluedMap<String, Object> values =
            InjectionUtils.extractValuesFromBean(params[p.getIndex()], "");
        for (String var : methodVars) {
          list.addAll(values.get(var));
        }
      } else {
        paramsMap.put(p.getName(), p);
      }
    }

    Object requestBody = bodyIndex == -1 ? null : params[bodyIndex];
    for (String varName : methodVars) {
      Parameter p = paramsMap.remove(varName);
      if (p != null) {
        list.add(convertParamValue(params[p.getIndex()], getParamAnnotations(m, p)));
      } else if (beanParamValues.containsKey(varName)) {
        BeanPair pair = beanParamValues.get(varName);
        list.add(convertParamValue(pair.getValue(), pair.getAnns()));
      } else if (requestBody != null) {
        try {
          Method getter =
              requestBody
                  .getClass()
                  .getMethod("get" + StringUtils.capitalize(varName), new Class<?>[] {});
          list.add(getter.invoke(requestBody, new Object[] {}));
        } catch (Exception ex) {
          // continue
        }
      }
    }

    for (Parameter p : paramsMap.values()) {
      if (valuesMap.containsKey(p.getName())) {
        int index = 0;
        for (Iterator<String> it = valuesMap.keySet().iterator(); it.hasNext(); index++) {
          if (it.next().equals(p.getName()) && index < list.size()) {
            list.remove(index);
            list.add(index, convertParamValue(params[p.getIndex()], null));
            break;
          }
        }
      }
    }

    return list;
  }