public List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType) { List<MethodMetadata> metas = this.delegate.parseAndValidatateMetadata(targetType); for (int i = 0; metas != null && i < metas.size(); i++) { MethodMetadata meta = metas.get(i); if (meta.returnType() == void.class) { meta.returnType(Void.class); } } return metas == null ? new ArrayList<MethodMetadata>() : metas; }
public static Class returnPublisherType(MethodMetadata methodMetadata) { final Type returnType = methodMetadata.returnType(); return (Class)((ParameterizedType) returnType).getRawType(); }
public RibbonReactiveClient(MethodMetadata metadata, @Nullable LoadBalancerCommand<Object> loadBalancerCommand, ReactiveHttpClient reactiveClient) { this.loadBalancerCommand = loadBalancerCommand; this.reactiveClient = reactiveClient; returnPublisherType = ((ParameterizedType) metadata.returnType()).getRawType(); }
public List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType) { List<MethodMetadata> metas = this.delegate.parseAndValidatateMetadata(targetType); for (int i = 0; i < metas.size(); i++) { MethodMetadata meta = metas.get(i); if (meta.returnType() == void.class) { meta.returnType(Void.class); } } return metas; }
Object decode(Response response) throws Throwable { try { return decoder.decode(response, metadata.returnType()); } catch (FeignException e) { throw e; } catch (RuntimeException e) { throw new DecodeException(e.getMessage(), e); } }
public RetryReactiveHttpClient(ReactiveHttpClient reactiveClient, MethodMetadata methodMetadata, Function<Flux<Throwable>, Publisher<Throwable>> retryFunction) { this.reactiveClient = reactiveClient; this.feignMethodTag = methodMetadata.configKey().substring(0, methodMetadata.configKey().indexOf('(')); this.retryFunction = wrapWithLog(retryFunction, feignMethodTag); final Type returnType = methodMetadata.returnType(); returnPublisherType = ((ParameterizedType) returnType).getRawType(); }
@Override public List<MethodMetadata> parseAndValidatateMetadata(final Class<?> targetType) { final List<MethodMetadata> metadatas = this.delegate .parseAndValidatateMetadata(targetType); for (final MethodMetadata metadata : metadatas) { final Type type = metadata.returnType(); if (!isMonoOrFlux(type)) { throw new IllegalArgumentException(String.format( "Method %s of contract %s doesn't returns reactor.core.publisher.Mono or reactor.core.publisher.Flux", metadata.configKey(), targetType.getSimpleName())); } } return metadatas; }
@Override public List<MethodMetadata> parseAndValidatateMetadata(final Class<?> targetType) { final List<MethodMetadata> methodsMetadata = this.delegate.parseAndValidatateMetadata(targetType); for (final MethodMetadata metadata : methodsMetadata) { final Type type = metadata.returnType(); if (!isRx2Type(type)) { throw new IllegalArgumentException(String.format( "Method %s of contract %s doesn't returns rx2 types", metadata.configKey(), targetType.getSimpleName())); } } return methodsMetadata; }
public static Type returnActualType(MethodMetadata methodMetadata) { return resolveLastTypeParameter(methodMetadata.returnType(), returnPublisherType(methodMetadata)); }
public static WebReactiveHttpClient webClient(MethodMetadata methodMetadata, WebClient webClient) { final Type returnType = methodMetadata.returnType(); Type returnPublisherType = ((ParameterizedType) returnType).getRawType(); ParameterizedTypeReference<Object> returnActualType = ParameterizedTypeReference.forType( resolveLastTypeParameter(returnType, (Class<?>) returnPublisherType)); ParameterizedTypeReference<Object> bodyActualType = ofNullable( getBodyActualType(methodMetadata.bodyType())) .map(type -> ParameterizedTypeReference.forType(type)) .orElse(null); return new WebReactiveHttpClient(webClient, bodyActualType, returnPublisherType, returnActualType); }
HystrixMethodHandler( Target target, MethodMetadata methodMetadata, MethodHandler methodHandler, CloudReactiveFeign.SetterFactory setterFactory, @Nullable Function<Throwable, Object> fallbackFactory) { checkNotNull(target, "target must be not null"); checkNotNull(methodMetadata, "methodMetadata must be not null"); method = Arrays.stream(target.type().getMethods()) .filter(method -> configKey(target.type(), method).equals(methodMetadata.configKey())) .findFirst().orElseThrow(() -> new IllegalArgumentException()); method.setAccessible(true); returnPublisherType = ((ParameterizedType) methodMetadata.returnType()).getRawType(); this.methodHandler = checkNotNull(methodHandler, "methodHandler must be not null"); this.fallbackFactory = fallbackFactory; checkNotNull(setterFactory, "setterFactory must be not null"); hystrixObservableCommandSetter = setterFactory.create(target, methodMetadata); }
@Override public List<MethodMetadata> parseAndValidatateMetadata(final Class<?> targetType) { final List<MethodMetadata> methodsMetadata = this.delegate.parseAndValidatateMetadata(targetType); for (final MethodMetadata metadata : methodsMetadata) { final Type type = metadata.returnType(); if (!isReactorType(type)) { throw new IllegalArgumentException(String.format( "Method %s of contract %s doesn't returns reactor.core.publisher.Mono or reactor.core.publisher.Flux", metadata.configKey(), targetType.getSimpleName())); } if(returnActualType(metadata) == byte[].class || bodyActualType(metadata) == byte[].class){ throw new IllegalArgumentException(String.format( "Method %s of contract %s will cause data to be copied, use ByteBuffer instead", metadata.configKey(), targetType.getSimpleName())); } } return methodsMetadata; }
private HystrixMethodHandler( Target target, MethodMetadata methodMetadata, ReactiveMethodHandler methodHandler, CloudReactiveFeign.SetterFactory setterFactory, @Nullable Function<Throwable, Object> fallbackFactory) { checkNotNull(target, "target must be not null"); checkNotNull(methodMetadata, "methodMetadata must be not null"); method = Arrays.stream(target.type().getMethods()) .filter(method -> configKey(target.type(), method).equals(methodMetadata.configKey())) .findFirst().orElseThrow(() -> new IllegalArgumentException()); method.setAccessible(true); returnPublisherType = ((ParameterizedType) methodMetadata.returnType()).getRawType(); this.methodHandler = checkNotNull(methodHandler, "methodHandler must be not null"); this.fallbackFactory = fallbackFactory; checkNotNull(setterFactory, "setterFactory must be not null"); hystrixObservableCommandSetter = setterFactory.create(target, methodMetadata); }
public static WebReactiveHttpClient webClient(MethodMetadata methodMetadata, WebClient webClient) { final Type returnType = methodMetadata.returnType(); Type returnPublisherType = ((ParameterizedType) returnType).getRawType(); ParameterizedTypeReference<Object> returnActualType = ParameterizedTypeReference.forType( resolveLastTypeParameter(returnType, (Class<?>) returnPublisherType)); ParameterizedTypeReference<Object> bodyActualType = ofNullable( getBodyActualType(methodMetadata.bodyType())) .map(type -> ParameterizedTypeReference.forType(type)) .orElse(null); return new WebReactiveHttpClient(webClient, bodyActualType, rx2ToReactor(returnPublisherType), returnActualType); }
HystrixMethodHandler( Target target, MethodMetadata methodMetadata, MethodHandler methodHandler, CloudReactiveFeign.SetterFactory setterFactory, @Nullable Function<Throwable, Object> fallbackFactory) { checkNotNull(target, "target must be not null"); checkNotNull(methodMetadata, "methodMetadata must be not null"); method = findMethodInTarget(target, methodMetadata); method.setAccessible(true); returnPublisherType = ((ParameterizedType) methodMetadata.returnType()).getRawType(); this.methodHandler = checkNotNull(methodHandler, "methodHandler must be not null"); this.fallbackFactory = fallbackFactory; checkNotNull(setterFactory, "setterFactory must be not null"); hystrixObservableCommandSetter = setterFactory.create(target, methodMetadata); }
public static JettyReactiveHttpClient jettyClient( MethodMetadata methodMetadata, HttpClient httpClient, JsonFactory jsonFactory, ObjectMapper objectMapper) { final Type returnType = methodMetadata.returnType(); Class returnPublisherType = (Class)((ParameterizedType) returnType).getRawType(); Class returnActualType = getClass(resolveLastTypeParameter(returnType, returnPublisherType)); Class bodyActualType = getClass(getBodyActualType(methodMetadata.bodyType())); return new JettyReactiveHttpClient(httpClient, bodyActualType, returnPublisherType, returnActualType, jsonFactory, objectMapper.writerFor(bodyActualType), objectMapper.readerFor(returnActualType)); }
public WebReactiveHttpClient(MethodMetadata methodMetadata, WebClient webClient, ReactiveHttpRequestInterceptor requestInterceptor, ReactiveStatusHandler statusHandler, boolean decode404) { this.webClient = webClient; this.metadata = methodMetadata; this.requestInterceptor = requestInterceptor; this.statusHandler = statusHandler; this.decode404 = decode404; this.logger = new Logger(); this.methodTag = methodMetadata.configKey().substring(0, methodMetadata.configKey().indexOf('(')); Type bodyType = methodMetadata.bodyType(); bodyActualType = getBodyActualType(bodyType); final Type returnType = methodMetadata.returnType(); returnPublisherType = ((ParameterizedType) returnType).getRawType(); returnActualType = ParameterizedTypeReference.forType( resolveLastTypeParameter(returnType, (Class<?>) returnPublisherType)); }
public static JettyReactiveHttpClient jettyClient( MethodMetadata methodMetadata, HttpClient httpClient, JsonFactory jsonFactory, ObjectMapper objectMapper) { final Type returnType = methodMetadata.returnType(); Class returnPublisherType = (Class)((ParameterizedType) returnType).getRawType(); Type returnActualType = resolveLastTypeParameter(returnType, returnPublisherType); Type bodyActualType = getBodyActualType(methodMetadata.bodyType()); ObjectWriter bodyWriter = bodyActualType != null ? objectMapper.writerFor(objectMapper.constructType(bodyActualType)) : null; ObjectReader responseReader = objectMapper.readerFor(objectMapper.constructType(returnActualType)); return new JettyReactiveHttpClient(httpClient, getClass(bodyActualType), returnPublisherType, getClass(returnActualType), jsonFactory, bodyWriter, responseReader); }
public static Java11ReactiveHttpClient jettyClient( MethodMetadata methodMetadata, HttpClient httpClient, JsonFactory jsonFactory, ObjectMapper objectMapper) { final Type returnType = methodMetadata.returnType(); Class returnPublisherType = (Class)((ParameterizedType) returnType).getRawType(); Type returnActualType = resolveLastTypeParameter(returnType, returnPublisherType); Type bodyActualType = getBodyActualType(methodMetadata.bodyType()); ObjectWriter bodyWriter = bodyActualType != null ? objectMapper.writerFor(objectMapper.constructType(bodyActualType)) : null; ObjectReader responseReader = objectMapper.readerFor(objectMapper.constructType(returnActualType)); return new Java11ReactiveHttpClient(httpClient, getClass(bodyActualType), returnPublisherType, getClass(returnActualType), jsonFactory, bodyWriter, responseReader); }
RestTemplateFakeReactiveHttpClient(MethodMetadata methodMetadata, RestTemplate restTemplate, boolean acceptGzip) { this.restTemplate = restTemplate; this.acceptGzip = acceptGzip; ObjectMapper mapper = new ObjectMapper(); mapper.registerModule(new JavaTimeModule()); MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter(); converter.setObjectMapper(mapper); restTemplate.getMessageConverters().add(0, converter); final Type returnType = methodMetadata.returnType(); returnPublisherType = ((ParameterizedType) returnType).getRawType(); returnActualType = forType( resolveLastTypeParameter(returnType, (Class<?>) returnPublisherType)); }