从jsonRpc接入http请求直至开始业务逻辑处理总体层级如下:
JsonServiceExporter->handleRequest-> handle -> handleRequest0 ->handleRequest -> handleJsonNodeRequest -> handleObject -> methodInvoke
- google的jsonrpc4j通过实现springframework中的httpRequestHandler来对请求进行处理;源码如下:
package com.googlecode.jsonrpc4j.spring;
import com.googlecode.jsonrpc4j.JsonRpcServer;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.HttpRequestHandler;
class JsonServiceExporter extends AbstractJsonServiceExporter implements HttpRequestHandler {
private JsonRpcServer jsonRpcServer;
JsonServiceExporter() {
}
protected void exportService() {
this.jsonRpcServer = this.getJsonRpcServer();
}
public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.jsonRpcServer.handle(request, response);
response.getOutputStream().flush();
}
}
- 进入handle可以看到在此层会对捕获http请求中出现的所有异常,并进行异常处理,回显jsonrpc中自定义的错误代码以及结构;源码如下:
/**
* Handles a servlet request.
*
* @param request the {@link HttpServletRequest}
* @param response the {@link HttpServletResponse}
* @throws IOException on error
*/
public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException {
logger.debug("Handling HttpServletRequest {}", request);
response.setContentType(contentType);
OutputStream output = response.getOutputStream();
InputStream input = getRequestStream(request);
int result = ErrorResolver.JsonError.PARSE_ERROR.code;
int contentLength = 0;
ByteArrayOutputStream byteOutput = new ByteArrayOutputStream();
try {
String acceptEncoding = request.getHeader(ACCEPT_ENCODING);
result = handleRequest0(input, output, acceptEncoding, response, byteOutput);
contentLength = byteOutput.size();
} catch (Throwable t) {
if (StreamEndedException.class.isInstance(t)) {
logger.debug("Bad request: empty contents!");
} else {
logger.error(t.getMessage(), t);
}
}
int httpStatusCode = httpStatusCodeProvider == null ? DefaultHttpStatusCodeProvider.INSTANCE.getHttpStatusCode(result)
: httpStatusCodeProvider.getHttpStatusCode(result);
response.setStatus(httpStatusCode);
response.setContentLength(contentLength);
byteOutput.writeTo(output);
output.flush();
}
- 进入handleRequest0 ->handleRequest -> handleJsonNodeRequest,这一步从输入流中读取对应的请求并归属为jsonrpc请求、处理对应请求,并返回结果代码;源码如下:
/**
* Handles a single request from the given {@link InputStream},
* that is to say that a single {@link JsonNode} is read from
* the stream and treated as a JSON-RPC request. All responses
* are written to the given {@link OutputStream}.
*
* @param input the {@link InputStream}
* @param output the {@link OutputStream}
* @return the error code, or {@code 0} if none
* @throws IOException on error
*/
public int handleRequest(final InputStream input, final OutputStream output) throws IOException {
final ReadContext readContext = ReadContext.getReadContext(input, mapper);
try {
readContext.assertReadable();
final JsonNode jsonNode = readContext.nextValue();
for (JsonRpcInterceptor interceptor : interceptorList) {
interceptor.preHandleJson(jsonNode);
}
JsonResponse jsonResponse = handleJsonNodeRequest(jsonNode);
writeAndFlushValue(output, jsonResponse.getResponse());
if (jsonResponse.getExceptionToRethrow() != null) {
throw jsonResponse.getExceptionToRethrow();
}
return jsonResponse.getCode();
} catch (JsonParseException | JsonMappingException e) {
JsonResponse responseError = createResponseError(VERSION, NULL, JsonError.PARSE_ERROR);
writeAndFlushValue(output, responseError.getResponse());
return responseError.getCode();
}
}
- 进入handleJsonNodeRequest,这里会对请求体中的json对象进行判别并进行对应处理;源码如下:
/**
* Handles the given {@link JsonNode} and creates {@link JsonResponse}
*
* @param node the {@link JsonNode}
* @return the {@link JsonResponse} instance
*/
protected JsonResponse handleJsonNodeRequest(final JsonNode node)
throws JsonParseException, JsonMappingException {
if (node.isArray()) {
return handleArray((ArrayNode) node);
}
if (node.isObject()) {
return handleObject((ObjectNode) node);
}
return createResponseError(VERSION, NULL, JsonError.INVALID_REQUEST);
}
REQUEST);
}
- 这里以handleObject为例,进来后其实就是对json的结构进行验证并调用对应方法;部分解析我会写道下面源码里边;
/**
* Handles the given {@link ObjectNode} and creates {@link JsonResponse}
*
* @param node the {@link JsonNode}
* @return the {@link JsonResponse} instance
*/
private JsonResponse handleObject(final ObjectNode node)
throws JsonParseException, JsonMappingException {
logger.debug("Request: {}", node);
// 验证请求中是否存在"jsonRpc" 以及 "method"
if (!isValidRequest(node)) {
return createResponseError(VERSION, NULL, JsonError.INVALID_REQUEST);
}
// 获取对应请求id
Object id = parseId(node.get(ID));
// 验证参数是否为空
String jsonRpc = hasNonNullData(node, JSONRPC) ? node.get(JSONRPC).asText() : VERSION;
if (!hasNonNullData(node, METHOD)) {
return createResponseError(jsonRpc, id, JsonError.METHOD_NOT_FOUND);
}
// 获取方法路径信息
final String fullMethodName = node.get(METHOD).asText();
final String partialMethodName = getMethodName(fullMethodName);
final String serviceName = getServiceName(fullMethodName);
Set<Method> methods = findCandidateMethods(getHandlerInterfaces(serviceName), partialMethodName);
if (methods.isEmpty()) {
return createResponseError(jsonRpc, id, JsonError.METHOD_NOT_FOUND);
}
// 验证方法参数是否齐全
AMethodWithItsArgs methodArgs = findBestMethodByParamsNode(methods, node.get(PARAMS));
if (methodArgs == null) {
return createResponseError(jsonRpc, id, JsonError.METHOD_PARAMS_INVALID);
}
try (InvokeListenerHandler handler = new InvokeListenerHandler(methodArgs, invocationListener)) {
try {
// 若设置预处理拦截器则会在此处拦截请求
if (this.requestInterceptor != null) {
this.requestInterceptor.interceptRequest(node);
}
// serviceName 其实就是我们通过@JsonRpcService设置的层级,在程序启动时会自动加载到内存当中
Object target = getHandler(serviceName);
// interceptors preHandle
for (JsonRpcInterceptor interceptor : interceptorList) {
interceptor.preHandle(target, methodArgs.method, methodArgs.arguments);
}
// invocation 做内部方法调用执行业务逻辑
JsonNode result = invoke(target, methodArgs.method, methodArgs.arguments);
handler.result = result;
// interceptors postHandle 若设置post拦截器则会在此处拦截请求
for (JsonRpcInterceptor interceptor : interceptorList) {
interceptor.postHandle(target, methodArgs.method, methodArgs.arguments, result);
}
// 验证id不为空
if (!isNotificationRequest(id)) {
return createResponseSuccess(jsonRpc, id, handler.result);
}
return new JsonResponse(null, JsonError.OK.code);
} catch (JsonParseException | JsonMappingException e) {
throw e; // rethrow this, it will be handled as PARSE_ERROR later
} catch (Throwable e) {
handler.error = e;
return handleError(id, jsonRpc, methodArgs, e);
}
}
}