From 42f43fa0ff55c4d8ef10ce437550871f3f4f713a Mon Sep 17 00:00:00 2001 From: Donghyeon Kim Date: Mon, 31 Oct 2022 17:37:15 +0900 Subject: [PATCH 1/2] Extract ParseHandlersByName.createMethodHandler Extract the function so that the ParseHandlersByName.apply function is easy to understand. --- core/src/main/java/feign/ReflectiveFeign.java | 44 +++++++++++-------- 1 file changed, 26 insertions(+), 18 deletions(-) diff --git a/core/src/main/java/feign/ReflectiveFeign.java b/core/src/main/java/feign/ReflectiveFeign.java index df81b1254..57f5595fb 100644 --- a/core/src/main/java/feign/ReflectiveFeign.java +++ b/core/src/main/java/feign/ReflectiveFeign.java @@ -160,27 +160,35 @@ public Map apply(Target target, C requestContext) { List metadata = contract.parseAndValidateMetadata(target.type()); Map result = new LinkedHashMap(); for (MethodMetadata md : metadata) { - BuildTemplateByResolvingArgs buildTemplate; - if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) { - buildTemplate = - new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target); - } else if (md.bodyIndex() != null || md.alwaysEncodeBody()) { - buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target); - } else { - buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder, target); - } - if (md.isIgnored()) { - result.put(md.configKey(), args -> { - throw new IllegalStateException(md.configKey() + " is not a method handled by feign"); - }); - } else { - result.put(md.configKey(), - factory.create(target, md, buildTemplate, options, decoder, errorDecoder, - requestContext)); - } + MethodHandler handler = createMethodHandler(target, md, requestContext); + result.put(md.configKey(), handler); } return result; } + + private MethodHandler createMethodHandler(final Target target, + final MethodMetadata md, + final C requestContext) { + if (md.isIgnored()) { + return args -> { + throw new IllegalStateException(md.configKey() + " is not a method handled by feign"); + }; + } + + BuildTemplateByResolvingArgs buildTemplate = getBuildTemplate(target, md); + return factory.create( + target, md, buildTemplate, options, decoder, errorDecoder, requestContext); + } + + private BuildTemplateByResolvingArgs getBuildTemplate(Target target, MethodMetadata md) { + if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) { + return new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target); + } else if (md.bodyIndex() != null || md.alwaysEncodeBody()) { + return new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target); + } else { + return new BuildTemplateByResolvingArgs(md, queryMapEncoder, target); + } + } } private static class BuildTemplateByResolvingArgs implements RequestTemplate.Factory { From 6ecb8370ae382725f7cfe764558d9e9c0361b8f7 Mon Sep 17 00:00:00 2001 From: Donghyeon Kim Date: Mon, 31 Oct 2022 17:59:15 +0900 Subject: [PATCH 2/2] Refactor ReflectiveFeign.newInstance Extract the function so that the ReflectiveFeign.newInstance function is easy to understand. --- core/src/main/java/feign/ReflectiveFeign.java | 50 ++++++++++--------- 1 file changed, 27 insertions(+), 23 deletions(-) diff --git a/core/src/main/java/feign/ReflectiveFeign.java b/core/src/main/java/feign/ReflectiveFeign.java index 57f5595fb..f6bcbb5b0 100644 --- a/core/src/main/java/feign/ReflectiveFeign.java +++ b/core/src/main/java/feign/ReflectiveFeign.java @@ -55,28 +55,18 @@ public T newInstance(Target target) { public T newInstance(Target target, C requestContext) { TargetSpecificationVerifier.verify(target); - Map nameToHandler = targetToHandlersByName.apply(target, requestContext); - Map methodToHandler = new LinkedHashMap(); - List defaultMethodHandlers = new LinkedList(); - - 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))); - } - } + Map methodToHandler = + targetToHandlersByName.apply(target, requestContext); 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); + for (MethodHandler methodHandler : methodToHandler.values()) { + if (methodHandler instanceof DefaultMethodHandler) { + ((DefaultMethodHandler) methodHandler).bindTo(proxy); + } } + return proxy; } @@ -156,13 +146,27 @@ static final class ParseHandlersByName { this.decoder = checkNotNull(decoder, "decoder"); } - public Map apply(Target target, C requestContext) { - List metadata = contract.parseAndValidateMetadata(target.type()); - Map result = new LinkedHashMap(); - for (MethodMetadata md : metadata) { - MethodHandler handler = createMethodHandler(target, md, requestContext); - result.put(md.configKey(), handler); + public Map apply(Target target, C requestContext) { + final Map result = new LinkedHashMap<>(); + + final List metadataList = contract.parseAndValidateMetadata(target.type()); + for (MethodMetadata md : metadataList) { + final Method method = md.method(); + if (method.getDeclaringClass() == Object.class) { + continue; + } + + final MethodHandler handler = createMethodHandler(target, md, requestContext); + result.put(method, handler); + } + + for (Method method : target.type().getMethods()) { + if (Util.isDefault(method)) { + final MethodHandler handler = new DefaultMethodHandler(method); + result.put(method, handler); + } } + return result; }