From cebbc9e39f615e4a46359971629ea2629ccd68f4 Mon Sep 17 00:00:00 2001 From: qianmoQ Date: Fri, 17 Jan 2025 14:33:32 +0800 Subject: [PATCH] =?UTF-8?q?feat(=E5=86=85=E6=A0=B8):=20=E7=AE=80=E5=8C=96?= =?UTF-8?q?=E5=A4=84=E7=90=86=E5=99=A8=E9=80=BB=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../processor/AbstractMethodProcessor.java | 147 ++++++++++++++++++ .../lightcall/processor/GetProcessor.java | 132 ++-------------- .../lightcall/proxy/LightCallProxy.java | 2 +- 3 files changed, 160 insertions(+), 121 deletions(-) create mode 100644 src/main/java/org/devlive/lightcall/processor/AbstractMethodProcessor.java diff --git a/src/main/java/org/devlive/lightcall/processor/AbstractMethodProcessor.java b/src/main/java/org/devlive/lightcall/processor/AbstractMethodProcessor.java new file mode 100644 index 0000000..f1ae7d0 --- /dev/null +++ b/src/main/java/org/devlive/lightcall/processor/AbstractMethodProcessor.java @@ -0,0 +1,147 @@ +package org.devlive.lightcall.processor; + +import com.fasterxml.jackson.databind.ObjectMapper; +import lombok.extern.slf4j.Slf4j; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.Response; +import org.devlive.lightcall.RequestContext; +import org.devlive.lightcall.RequestException; +import org.devlive.lightcall.handler.ParameterHandler; +import org.devlive.lightcall.handler.ParameterHandlerFactory; +import org.devlive.lightcall.interceptor.Interceptor; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import java.util.List; + +@Slf4j +public abstract class AbstractMethodProcessor + implements MethodProcessor +{ + protected final OkHttpClient client; + protected final ObjectMapper objectMapper; + protected final List interceptors; + + protected AbstractMethodProcessor(OkHttpClient client, ObjectMapper objectMapper, List interceptors) + { + this.client = client; + this.objectMapper = objectMapper; + this.interceptors = interceptors; + } + + @Override + public Object process(Object proxy, Method method, Object[] args, A annotation, RequestContext context) + throws Throwable + { + String path = getPath(annotation); + HttpUrl url = buildUrl(path, method, args, context); + Request request = buildRequest(url, context); + return executeRequest(request, method.getReturnType(), context); + } + + protected abstract String getPath(A annotation); + + protected abstract Request buildRequest(HttpUrl url, RequestContext context); + + protected HttpUrl buildUrl(String path, Method method, Object[] args, RequestContext context) + { + log.debug("Building URL for path: {}", path); + + List handlers = ParameterHandlerFactory.createHandlers(method, context); + Parameter[] parameters = method.getParameters(); + String processedPath = path; + + for (int i = 0; i < parameters.length; i++) { + Parameter parameter = parameters[i]; + Object arg = args[i]; + + for (ParameterHandler handler : handlers) { + if (handler.canHandle(parameter)) { + processedPath = handler.handle(parameter, arg, processedPath); + break; + } + } + } + + if (!processedPath.startsWith("/")) { + processedPath = "/" + processedPath; + } + context.getUrlBuilder().addPathSegments(processedPath.substring(1)); + + HttpUrl url = context.getUrlBuilder().build(); + log.debug("Built URL: {}", url); + return url; + } + + protected T executeRequest(Request request, Class returnType, RequestContext context) + throws Exception + { + log.info("Executing request - URL: {}, Method: {}", request.url(), request.method()); + + Request interceptedRequest = applyBeforeRequestInterceptors(request); + + long startTime = System.currentTimeMillis(); + try { + Response response = client.newCall(interceptedRequest).execute(); + long duration = System.currentTimeMillis() - startTime; + log.debug("Received response in {}ms - Status code: {}", duration, response.code()); + + response = applyAfterResponseInterceptors(response); + + if (!response.isSuccessful()) { + throw new RequestException("Request failed with code: " + response.code()); + } + + if (response.body() == null) { + log.warn("Response body is null for URL: {}", request.url()); + return null; + } + + String responseBody = response.body().string(); + response.close(); + + return objectMapper.readValue(responseBody, returnType); + } + catch (Exception e) { + log.error("Error executing request: {}", e.getMessage(), e); + throw e; + } + } + + protected Request applyBeforeRequestInterceptors(Request request) + { + Request interceptedRequest = request; + for (Interceptor interceptor : interceptors) { + try { + interceptedRequest = interceptor.beforeRequest(interceptedRequest); + log.debug("Applied beforeRequest interceptor: {}", interceptor.getClass().getSimpleName()); + } + catch (Exception e) { + log.error("Error in beforeRequest interceptor {}: {}", + interceptor.getClass().getSimpleName(), e.getMessage(), e); + } + } + return interceptedRequest; + } + + protected Response applyAfterResponseInterceptors(Response response) + throws Exception + { + Response interceptedResponse = response; + for (Interceptor interceptor : interceptors) { + try { + interceptedResponse = interceptor.afterResponse(interceptedResponse); + log.debug("Applied afterResponse interceptor: {}", interceptor.getClass().getSimpleName()); + } + catch (Exception e) { + log.error("Error in afterResponse interceptor {}: {}", + interceptor.getClass().getSimpleName(), e.getMessage(), e); + throw e; + } + } + return interceptedResponse; + } +} diff --git a/src/main/java/org/devlive/lightcall/processor/GetProcessor.java b/src/main/java/org/devlive/lightcall/processor/GetProcessor.java index 9efa932..2bbafec 100644 --- a/src/main/java/org/devlive/lightcall/processor/GetProcessor.java +++ b/src/main/java/org/devlive/lightcall/processor/GetProcessor.java @@ -5,31 +5,24 @@ import okhttp3.HttpUrl; import okhttp3.OkHttpClient; import okhttp3.Request; -import okhttp3.Response; import org.devlive.lightcall.RequestContext; -import org.devlive.lightcall.RequestException; import org.devlive.lightcall.annotation.Get; -import org.devlive.lightcall.handler.ParameterHandler; -import org.devlive.lightcall.handler.ParameterHandlerFactory; import org.devlive.lightcall.interceptor.Interceptor; -import java.lang.reflect.Method; -import java.lang.reflect.Parameter; import java.util.List; @Slf4j public class GetProcessor - implements MethodProcessor + extends AbstractMethodProcessor { - private final OkHttpClient client; - private final ObjectMapper objectMapper; - private final List interceptors; + public static GetProcessor create(OkHttpClient client, ObjectMapper objectMapper, List interceptors) + { + return new GetProcessor(client, objectMapper, interceptors); + } - public GetProcessor(OkHttpClient client, ObjectMapper objectMapper, List interceptors) + private GetProcessor(OkHttpClient client, ObjectMapper objectMapper, List interceptors) { - this.client = client; - this.objectMapper = objectMapper; - this.interceptors = interceptors; + super(client, objectMapper, interceptors); } @Override @@ -39,118 +32,17 @@ public Class getAnnotationType() } @Override - public Object process(Object proxy, Method method, Object[] args, Get annotation, RequestContext context) - throws Throwable + protected String getPath(Get annotation) { - log.debug("Processing GET request for method: {}", method.getName()); - - HttpUrl url = buildUrl(annotation.value(), method, args, context); - return executeGet(url, method.getReturnType(), context); + return annotation.value(); } - private HttpUrl buildUrl(String path, Method method, Object[] args, RequestContext context) - { - // 原有的 buildUrl 逻辑 - log.debug("Building URL for path: {}", path); - - List handlers = ParameterHandlerFactory.createHandlers(method, context); - Parameter[] parameters = method.getParameters(); - String processedPath = path; - - for (int i = 0; i < parameters.length; i++) { - Parameter parameter = parameters[i]; - Object arg = args[i]; - - for (ParameterHandler handler : handlers) { - if (handler.canHandle(parameter)) { - processedPath = handler.handle(parameter, arg, processedPath); - break; - } - } - } - - if (!processedPath.startsWith("/")) { - processedPath = "/" + processedPath; - } - context.getUrlBuilder().addPathSegments(processedPath.substring(1)); - - HttpUrl url = context.getUrlBuilder().build(); - log.debug("Built URL: {}", url); - return url; - } - - private T executeGet(HttpUrl url, Class returnType, RequestContext context) - throws Exception + @Override + protected Request buildRequest(HttpUrl url, RequestContext context) { - log.info("Executing GET request - URL: {}, Expected return type: {}", url, returnType); - - Request originalRequest = context.getRequestBuilder() + return context.getRequestBuilder() .url(url) .get() .build(); - - Request request = applyBeforeRequestInterceptors(originalRequest); - log.info("Executing request - URL: {}, Headers: {}", request.url(), request.headers()); - - long startTime = System.currentTimeMillis(); - try { - Response response = client.newCall(request).execute(); - long duration = System.currentTimeMillis() - startTime; - log.debug("Received response in {}ms - Status code: {}", duration, response.code()); - - response = applyAfterResponseInterceptors(response); - - if (!response.isSuccessful()) { - throw new RequestException("Request failed with code: " + response.code()); - } - - if (response.body() == null) { - log.warn("Response body is null for URL: {}", url); - return null; - } - - String responseBody = response.body().string(); - response.close(); - - return objectMapper.readValue(responseBody, returnType); - } - catch (Exception e) { - log.error("Error executing request: {}", e.getMessage(), e); - throw e; - } - } - - private Request applyBeforeRequestInterceptors(Request request) - { - Request interceptedRequest = request; - for (Interceptor interceptor : interceptors) { - try { - interceptedRequest = interceptor.beforeRequest(interceptedRequest); - log.debug("Applied beforeRequest interceptor: {}", interceptor.getClass().getSimpleName()); - } - catch (Exception e) { - log.error("Error in beforeRequest interceptor {}: {}", - interceptor.getClass().getSimpleName(), e.getMessage(), e); - } - } - return interceptedRequest; - } - - private Response applyAfterResponseInterceptors(Response response) - throws Exception - { - Response interceptedResponse = response; - for (Interceptor interceptor : interceptors) { - try { - interceptedResponse = interceptor.afterResponse(interceptedResponse); - log.debug("Applied afterResponse interceptor: {}", interceptor.getClass().getSimpleName()); - } - catch (Exception e) { - log.error("Error in afterResponse interceptor {}: {}", - interceptor.getClass().getSimpleName(), e.getMessage(), e); - throw e; - } - } - return interceptedResponse; } } diff --git a/src/main/java/org/devlive/lightcall/proxy/LightCallProxy.java b/src/main/java/org/devlive/lightcall/proxy/LightCallProxy.java index f6ed0cb..401f8d6 100644 --- a/src/main/java/org/devlive/lightcall/proxy/LightCallProxy.java +++ b/src/main/java/org/devlive/lightcall/proxy/LightCallProxy.java @@ -39,7 +39,7 @@ public LightCallProxy(LightCallConfig config) this.processors = new HashMap<>(); // 注册默认的 GET 处理器 - registerProcessor(new GetProcessor(client, objectMapper, config.getInterceptors())); + registerProcessor(GetProcessor.create(client, objectMapper, config.getInterceptors())); } public void registerProcessor(MethodProcessor processor)