CompensableHystrixFallbackHandler fallback = new CompensableHystrixFallbackHandler(constant); Object proxy = Proxy.newProxyInstance(constant.getClass().getClassLoader(), new Class<?>[] { CompensableHystrixInvocationHandler.class, target.type() }, fallback); constantField.set(factory, proxy); } else { CompensableHystrixFallbackFactoryHandler factoryHandler = new CompensableHystrixFallbackFactoryHandler( factory, target.type()); FallbackFactory<?> proxy = (FallbackFactory<?>) Proxy.newProxyInstance(factory.getClass().getClassLoader(), new Class<?>[] { FallbackFactory.class }, factoryHandler);
@Test public void testGetters() { Target<ApiInterface1> target1 = new LambdaServiceFunctionTarget<>(ApiInterface1.class, "a"); assertEquals("a", target1.name()); assertEquals(ApiInterface1.class, target1.type()); assertEquals("", target1.url()); Target<ApiInterface2> target2 = new LambdaServiceFunctionTarget<>(ApiInterface2.class, "b"); assertEquals("b", target2.name()); assertEquals(ApiInterface2.class, target2.type()); assertEquals("", target2.url()); }
@Override public HystrixCommand.Setter create(Target<?> target, Method method) { String groupKey = target.name(); String commandKey = Feign.configKey(target.type(), method); return HystrixCommand.Setter .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey)) .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey)); } }
private ReactiveClientMethodHandler(Target target, MethodMetadata methodMetadata, ReactiveHttpClient reactiveClient) { this.target = checkNotNull(target, "target must be not null"); this.methodMetadata = checkNotNull(methodMetadata, "methodMetadata must be not null"); this.reactiveClient = checkNotNull(reactiveClient, "client must be not null"); this.defaultUriBuilderFactory = new DefaultUriBuilderFactory(target.url()); Stream<AbstractMap.SimpleImmutableEntry<String, String>> simpleImmutableEntryStream = methodMetadata .template().headers().entrySet().stream() .flatMap(e -> e.getValue().stream() .map(v -> new AbstractMap.SimpleImmutableEntry<>(e.getKey(), v))); this.headerExpanders = simpleImmutableEntryStream.collect(groupingBy( entry -> entry.getKey(), mapping(entry -> buildExpandHeaderFunction(entry.getValue()), toList()))); }
@Override public HystrixObservableCommand.Setter create(Target<?> target, MethodMetadata methodMetadata) { String groupKey = target.name(); String commandKey = methodMetadata.configKey(); return HystrixObservableCommand.Setter .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey)) .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey)); } }
Request targetRequest(RequestTemplate template) { for (RequestInterceptor interceptor : requestInterceptors) { interceptor.apply(template); } return target.apply(new RequestTemplate(template)); }
@Override public HystrixCommand.Setter create(Target<?> target, Method method) { String groupKey = target.name(); String commandKey = Feign.configKey(target.type(), method); return HystrixCommand.Setter .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey)) .andCommandPropertiesDefaults(HystrixCommandProperties.Setter() .withExecutionTimeoutInMilliseconds(timeout) .withExecutionIsolationSemaphoreMaxConcurrentRequests(connections)) .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey)); } };
protected ReactiveHttpRequest buildRequest(Object[] argv) { Map<String, ?> substitutionsMap = methodMetadata.indexToName().entrySet().stream() .flatMap(e -> e.getValue().stream() .map(v -> new AbstractMap.SimpleImmutableEntry<>(e.getKey(), v))) .collect(Collectors.toMap(Map.Entry::getValue, entry -> argv[entry.getKey()])); try { String path = pathExpander.apply(substitutionsMap); Map<String, Collection<String>> queries = queries(argv, substitutionsMap); Map<String, List<String>> headers = headers(argv, substitutionsMap); URI uri = new URI(target.url() + path + queryLine(queries)); return new ReactiveHttpRequest(methodMetadata.template().method(), uri, headers, body(argv)); } catch (URISyntaxException e) { throw new RuntimeException(e); } }
@Override public HystrixObservableCommand.Setter create(Target<?> target, MethodMetadata methodMetadata) { String groupKey = target.name(); String commandKey = methodMetadata.configKey(); return HystrixObservableCommand.Setter .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey)) .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey)); } }
/** * Associates request to defined target. * * @param template request template * * @return fully formed request */ private Request targetRequest(final RequestTemplate template) { for (final RequestInterceptor interceptor : requestInterceptors) { interceptor.apply(template); } return target.apply(new RequestTemplate(template)); }
@Override protected ReactiveClientFactory buildReactiveClientFactory() { ReactiveClientFactory reactiveClientFactory = super.buildReactiveClientFactory(); return methodMetadata -> { ReactiveHttpClient reactiveClient = reactiveClientFactory.apply(methodMetadata); String serviceName = extractServiceName(target.url()); return new RibbonReactiveClient(methodMetadata, loadBalancerCommandFactory.apply(serviceName), reactiveClient); }; }
@Override public HystrixObservableCommand.Setter create(Target<?> target, MethodMetadata methodMetadata) { String groupKey = target.name(); String commandKey = methodMetadata.configKey(); return HystrixObservableCommand.Setter .withGroupKey(HystrixCommandGroupKey.Factory.asKey(groupKey)) .andCommandKey(HystrixCommandKey.Factory.asKey(commandKey)); } }
@Test public void apply_RequestTemplateGiven_ShouldInvokeRequestAndNothingElse() { Target<ApiInterface1> target = new LambdaServiceFunctionTarget<>(ApiInterface1.class); RequestTemplate tmpl = mock(RequestTemplate.class); target.apply(tmpl); verify(tmpl, times(1)).request(); verifyNoMoreInteractions(tmpl); }
@SuppressWarnings("unchecked") public <T> T newInstance(Target<T> target) { final Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target); final Map<Method, InvocationHandlerFactory.MethodHandler> methodToHandler = new LinkedHashMap<>(); final List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<>(); for (final Method method : target.type().getMethods()) { if (isDefault(method)) { final DefaultMethodHandler handler = new DefaultMethodHandler(method); defaultMethodHandlers.add(handler); methodToHandler.put(method, handler); } else { methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method))); } } final InvocationHandler handler = factory.create(target, methodToHandler); T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[] {target.type()}, handler); for (final DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) { defaultMethodHandler.bindTo(proxy); } return proxy; }
@Override protected PublisherClientFactory buildReactiveClientFactory() { PublisherClientFactory publisherClientFactory = super.buildReactiveClientFactory(); return methodMetadata -> { PublisherHttpClient publisherClient = publisherClientFactory.apply(methodMetadata); String serviceName = extractServiceName(target.url()); return new RibbonPublisherClient(loadBalancerCommandFactory.apply(serviceName), publisherClient, returnPublisherType(methodMetadata)); }; }
@Test public void init_NoNameGiven_ShouldDeriveNameFromType() { Target<ApiInterface1> target = new LambdaServiceFunctionTarget<>(ApiInterface1.class); assertEquals("lambda service: ApiInterface1", target.name()); }
Map<String, MethodHandler> apply(final Target target) { Map<String, MethodMetadata> metadata = contract.parseAndValidatateMetadata(target.type()) .stream() .collect(Collectors.toMap( MethodMetadata::configKey, md -> md )); Map<String, Method> configKeyToMethod = Stream.of(target.type().getMethods()) .collect(Collectors.toMap( method -> Feign.configKey(target.type(), method), method -> method )); final Map<String, MethodHandler> result = new LinkedHashMap<>(); for (final Map.Entry<String, Method> entry : configKeyToMethod.entrySet()) { String configKey = entry.getKey(); MethodMetadata md = metadata.get(configKey); MethodHandler methodHandler = md != null ? factory.create(target, md) : factory.createDefault(entry.getValue()); //isDefault(entry.getValue()) result.put(configKey, methodHandler); } return result; } }
@Override public PublisherHttpClient create(MethodMetadata methodMetadata) { PublisherHttpClient publisherClient = publisherClientFactory.create(methodMetadata); String serviceName = extractServiceName(target.url()); return new RibbonPublisherClient(loadBalancerCommandFactory.apply(serviceName), publisherClient, returnPublisherType(methodMetadata)); } };
Map<String, MethodHandler> apply(final Target target) { final List<MethodMetadata> metadata = contract .parseAndValidatateMetadata(target.type()); final Map<String, MethodHandler> result = new LinkedHashMap<>(); for (final MethodMetadata md : metadata) { ReactiveMethodHandler methodHandler = factory.create(target, md); result.put(md.configKey(), methodHandler); } return result; } }