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);
@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; }
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; } }
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; } }
@SuppressWarnings("unchecked") public <T> T newInstance(Target<T> target) { final Map<String, MethodHandler> nameToHandler = targetToHandlersByName .apply(target); final Map<Method, 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 @SuppressWarnings("unchecked") public <T> T newInstance(final Target<T> target) { checkNotNull(target, "Argument target must be not null"); final Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target); final Map<Method, MethodHandler> methodToHandler = new HashMap<>(); final List<DefaultMethodHandler> defaultMethodHandlers = new ArrayList<>(); 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); final T proxy = (T) Proxy.newProxyInstance( target.type().getClassLoader(), new Class<?>[] { target.type() }, handler); for (final DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) { defaultMethodHandler.bindTo(proxy); } return proxy; }
/** * creates an api binding to the {@code target}. As this invokes reflection, care should be taken * to cache the result. */ @SuppressWarnings("unchecked") @Override public <T> T newInstance(Target<T> target) { Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target); Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>(); List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>(); for (Method method : target.type().getMethods()) { if (method.getDeclaringClass() == Object.class) { continue; } else if(Util.isDefault(method)) { DefaultMethodHandler handler = new DefaultMethodHandler(method); defaultMethodHandlers.add(handler); methodToHandler.put(method, handler); } else { methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method))); } } InvocationHandler handler = factory.create(target, methodToHandler); T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class<?>[]{target.type()}, handler); for(DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) { defaultMethodHandler.bindTo(proxy); } return proxy; }
@Override public <T> T target(Target<T> target) { ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder .create(defaultReference, target.getClass().getClassLoader(), applicationContext) .interfaceClass(target.type()); try { T object = (T) beanBuilder.build().getObject(); return object; } catch (Exception e) { throw new RuntimeException(e); } } }
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); }
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); }
TransactionHystrixFallbackHandler fallback = new TransactionHystrixFallbackHandler(constant); Object proxy = Proxy.newProxyInstance(constant.getClass().getClassLoader(), new Class<?>[] { TransactionHystrixInvocationHandler.class, target.type() }, fallback); constantField.set(factory, proxy); } else { TransactionHystrixFallbackFactoryHandler factoryHandler = new TransactionHystrixFallbackFactoryHandler( factory, target.type()); FallbackFactory<?> proxy = (FallbackFactory<?>) Proxy.newProxyInstance(factory.getClass().getClassLoader(), new Class<?>[] { FallbackFactory.class }, factoryHandler);
public Map<String, MethodHandler> apply(Target key) { List<MethodMetadata> metadata = contract.parseAndValidatateMetadata(key.type()); Map<String, MethodHandler> result = new LinkedHashMap<String, MethodHandler>(); for (MethodMetadata md : metadata) { BuildTemplateByResolvingArgs buildTemplate; if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) { buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder); } else if (md.bodyIndex() != null) { buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder); } else { buildTemplate = new BuildTemplateByResolvingArgs(md); } result.put(md.configKey(), factory.create(key, md, buildTemplate, options, decoder, errorDecoder)); } return result; } }
@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 Map<String, MethodHandler> apply(final Target key) { final List<MethodMetadata> metadatas = contract.parseAndValidatateMetadata(key.type()); final Map<String, MethodHandler> result = new HashMap<>(); for (final MethodMetadata metadata : metadatas) { BuildTemplateByResolvingArgs buildTemplate; if (!metadata.formParams().isEmpty() && metadata.template().bodyTemplate() == null) { buildTemplate = new BuildTemplateByResolvingArgs .BuildFormEncodedTemplateFromArgs(metadata, encoder); } else if (metadata.bodyIndex() != null) { buildTemplate = new BuildTemplateByResolvingArgs .BuildEncodedTemplateFromArgs(metadata, encoder); } else { buildTemplate = new BuildTemplateByResolvingArgs(metadata); } result.put(metadata.configKey(), factory.create( key, metadata, buildTemplate, decoder, errorDecoder)); } return result; } }
@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)); } };
@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()); }