private void checkAtMostOne(Method method, Object[] values, String fieldName) { checkState(values != null && (values.length == 0 || values.length == 1), "Method %s can only contain at most 1 %s field. Found: %s", method.getName(), fieldName, values == null ? null : Arrays.asList(values)); }
private static void checkMapString(String name, Class<?> type, Type genericType) { checkState(Map.class.isAssignableFrom(type), "%s parameter must be a Map: %s", name, type); Type[] parameterTypes = ((ParameterizedType) genericType).getActualTypeArguments(); Class<?> keyClass = (Class<?>) parameterTypes[0]; checkState(String.class.equals(keyClass), "%s key must be a String: %s", name, keyClass.getSimpleName()); } }
private void checkAtMostOne(Method method, Object[] values, String fieldName) { checkState(values != null && (values.length == 0 || values.length == 1), "Method %s can only contain at most 1 %s field. Found: %s", method.getName(), fieldName, values == null ? null : Arrays.asList(values)); }
private void checkOne(Method method, Object[] values, String fieldName) { checkState(values != null && values.length == 1, "Method %s can only contain 1 %s field. Found: %s", method.getName(), fieldName, values == null ? null : Arrays.asList(values)); }
private void checkAtMostOne(Method method, Object[] values, String fieldName) { checkState(values != null && (values.length == 0 || values.length == 1), "Method %s can only contain at most 1 %s field. Found: %s", method.getName(), fieldName, values == null ? null : Arrays.asList(values)); }
private void checkAtMostOne(Method method, Object[] values, String fieldName) { checkState(values != null && (values.length == 0 || values.length == 1), "Method %s can only contain at most 1 %s field. Found: %s", method.getName(), fieldName, values == null ? null : Arrays.asList(values)); }
private void checkOne(Method method, Object[] values, String fieldName) { checkState(values != null && values.length == 1, "Method %s can only contain 1 %s field. Found: %s", method.getName(), fieldName, values == null ? null : Arrays.asList(values)); }
private void checkOne(Method method, Object[] values, String fieldName) { checkState(values != null && values.length == 1, "Method %s can only contain 1 %s field. Found: %s", method.getName(), fieldName, values == null ? null : Arrays.asList(values)); }
private void checkOne(Method method, Object[] values, String fieldName) { checkState(values != null && values.length == 1, "Method %s can only contain 1 %s field. Found: %s", method.getName(), fieldName, values == null ? null : Arrays.asList(values)); }
private Response(int status, String reason, Map<String, Collection<String>> headers, Body body) { checkState(status >= 200, "Invalid status code: %s", status); this.status = status; this.reason = reason; //nullable this.headers = Collections.unmodifiableMap(caseInsensitiveCopyOf(headers)); this.body = body; //nullable }
@Override protected MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method method) { MethodMetadata data = super.parseAndValidateMetadata(targetType, method); // perform extra validation for HeaderMap and QueryMap annotations Class<?>[] parameterTypes = method.getParameterTypes(); if (data.headerMapIndex() != null) { feign.Util.checkState(Map.class.isAssignableFrom(parameterTypes[data.headerMapIndex()]), "HeaderMap parameter must be a Map: %s", parameterTypes[data.headerMapIndex()]); } if (data.queryMapIndex() != null) { feign.Util.checkState(Map.class.isAssignableFrom(parameterTypes[data.queryMapIndex()]), "QueryMap parameter must be a Map: %s", parameterTypes[data.queryMapIndex()]); } return data; }
@Override protected boolean processAnnotationsOnParameter(MethodMetadata data, Annotation[] annotations, int paramIndex) { boolean isHttpParam = delegate.processAnnotationsOnParameter(data, annotations, paramIndex); // if any of the annotations on the parameter is a HeaderMap or QueryMap parameter, interpret it for (Annotation parameterAnnotation : annotations) { Class<? extends Annotation> annotationType = parameterAnnotation.annotationType(); if (annotationType == HeaderMap.class) { feign.Util.checkState(data.headerMapIndex() == null, "HeaderMap annotation was present on multiple parameters."); data.headerMapIndex(paramIndex); isHttpParam = true; } else if (annotationType == QueryMap.class) { feign.Util.checkState(data.queryMapIndex() == null, "QueryMap annotation was present on multiple parameters."); data.queryMapIndex(paramIndex); isHttpParam = true; } } return isHttpParam; } }
private static TypeDescriptor createTypeDescriptor(Method method, int paramIndex) { Parameter parameter = method.getParameters()[paramIndex]; MethodParameter methodParameter = MethodParameter.forParameter(parameter); TypeDescriptor typeDescriptor = new TypeDescriptor(methodParameter); // Feign applies the Param.Expander to each element of an Iterable, so in those // cases we need to provide a TypeDescriptor of the element. if (typeDescriptor.isAssignableTo(ITERABLE_TYPE_DESCRIPTOR)) { TypeDescriptor elementTypeDescriptor = typeDescriptor.getElementTypeDescriptor(); checkState(elementTypeDescriptor != null, "Could not resolve element type of Iterable type %s. Not declared?", typeDescriptor); typeDescriptor = elementTypeDescriptor; } return typeDescriptor; }
@Override protected void processAnnotationOnClass(MethodMetadata data, Class<?> targetType) { if (targetType.isAnnotationPresent(Headers.class)) { String[] headersOnType = targetType.getAnnotation(Headers.class).value(); checkState(headersOnType.length > 0, "Headers annotation was empty on type %s.", targetType.getName()); Map<String, Collection<String>> headers = toMap(headersOnType); headers.putAll(data.template().headers()); data.template().headers(null); // to clear data.template().headers(headers); } }
private static TypeDescriptor createTypeDescriptor(Method method, int paramIndex) { Parameter parameter = method.getParameters()[paramIndex]; MethodParameter methodParameter = MethodParameter.forParameter(parameter); TypeDescriptor typeDescriptor = new TypeDescriptor(methodParameter); // Feign applies the Param.Expander to each element of an Iterable, so in those // cases we need to provide a TypeDescriptor of the element. if (typeDescriptor.isAssignableTo(ITERABLE_TYPE_DESCRIPTOR)) { TypeDescriptor elementTypeDescriptor = typeDescriptor.getElementTypeDescriptor(); checkState(elementTypeDescriptor != null, "Could not resolve element type of Iterable type %s. Not declared?", typeDescriptor); typeDescriptor = elementTypeDescriptor; } return typeDescriptor; }
private void handleProducesAnnotation(MethodMetadata data, Produces produces, String name) { String[] serverProduces = produces.value(); String clientAccepts = serverProduces.length == 0 ? null : emptyToNull(serverProduces[0]); checkState(clientAccepts != null, "Produces.value() was empty on %s", name); data.template().header(ACCEPT, (String) null); // remove any previous produces data.template().header(ACCEPT, clientAccepts); }
private void handleConsumesAnnotation(MethodMetadata data, Consumes consumes, String name) { String[] serverConsumes = consumes.value(); String clientProduces = serverConsumes.length == 0 ? null : emptyToNull(serverConsumes[0]); checkState(clientProduces != null, "Consumes.value() was empty on %s", name); data.template().header(CONTENT_TYPE, (String) null); // remove any previous consumes data.template().header(CONTENT_TYPE, clientProduces); }
@Override public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) { String name = ANNOTATION.cast(annotation).value(); checkState(emptyToNull(name) != null, "PathVariable annotation was empty on param %s.", context.getParameterIndex()); context.setParameterName(name); MethodMetadata data = context.getMethodMetadata(); String varName = '{' + name + '}'; if (!data.template().url().contains(varName) && !searchMapValues(data.template().queries(), varName) && !searchMapValues(data.template().headers(), varName)) { data.formParams().add(name); } return true; }
@Override public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) { String name = ANNOTATION.cast(annotation).value(); checkState(emptyToNull(name) != null, "PathVariable annotation was empty on param %s.", context.getParameterIndex()); context.setParameterName(name); MethodMetadata data = context.getMethodMetadata(); String varName = '{' + name + '}'; if (!data.template().url().contains(varName) && !searchMapValues(data.template().queries(), varName) && !searchMapValues(data.template().headers(), varName)) { data.formParams().add(name); } return true; }
@Override public boolean processArgument(AnnotatedParameterContext context, Annotation annotation, Method method) { String name = ANNOTATION.cast(annotation).value(); checkState(emptyToNull(name) != null, "PathVariable annotation was empty on param %s.", context.getParameterIndex()); context.setParameterName(name); MethodMetadata data = context.getMethodMetadata(); String varName = '{' + name + '}'; if (!data.template().url().contains(varName) && !searchMapValues(data.template().queries(), varName) && !searchMapValues(data.template().headers(), varName)) { data.formParams().add(name); } return true; }