请求生命周期监听器

介绍

一个终端请求的处理，包含下面几个比较关键的步骤：

• decode: 将 ByteBuf 初步解码为 Jt808Request
  • 此时消息整体结构已经解码完成
  • body (消息体)部分依旧是 ByteBuf
• dispatch1: 将上一步初步解码的 Jt808Request 对象 分发 出去
  • 如果是分包请求
    • 在 AbstractJt808RequestMsgQueueListener 里暂存分包
    • 直到所有子包都到达之后自动合并请求，再次 dispatch 合并后的请求
  • 否则，进行下一步
• dispatch2: 将请求(包括合并后的分包请求)分发给处理器链 Jt808DispatcherHandler
  • 调用处理器处理请求
  • 处理 处理器返回的结果
  • 回复终端

对应上面描述的处理流程，提供了 Jt808RequestLifecycleListener 以便在消息处理流程的关键步骤:

• 加入自己的逻辑
• 拦截请求的处理流程

点击展开 Jt808RequestLifecycleListener 接口声明

public interface Jt808RequestLifecycleListener extends OrderedComponent {

    /**
     * @param request 尚未解码的原始报文
     * @param channel 当前终端对应的 {@link Channel}
     * @see Jt808DispatchChannelHandlerAdapter#channelRead(ChannelHandlerContext, Object)
     */
    default boolean beforeDecode(ByteBuf request, Channel channel) {
        return true;
    }

    /**
     * @param request 初步解码后的请求(请求体尚未解码)
     * @see Jt808RequestMsgDispatcher#doDispatch(Jt808Request)
     */
    default boolean beforeDispatch(Jt808Request request) {
        return true;
    }

    /**
     * @param exchange 请求上下文
     * @see Jt808DispatcherHandler#handleRequest(Jt808ServerExchange)
     */
    default boolean beforeDispatch(Jt808ServerExchange exchange) {
        return true;
    }

    /**
     * @param exchange 请求上下文
     * @param handler  处理当前请求的处理器。
     *                 目前内置的处理器有两种:
     *                 <ol>
     *                 <li>被 {@link io.github.hylexus.jt.jt808.support.annotation.handler.Jt808RequestHandler @Jt808RequestHandler}</li> 注解标记的处理器方法
     *                 <li>{@link io.github.hylexus.jt.jt808.support.dispatcher.handler.SimpleJt808RequestHandler SimpleJt808RequestHandler}</li> 实例
     *                 </ol>
     * @see Jt808DispatcherHandler#handleRequest(io.github.hylexus.jt.jt808.spec.Jt808ServerExchange)
     */
    default boolean beforeHandle(Jt808ServerExchange exchange, Object handler) {
        return true;
    }

    /**
     * @param exchange      请求上下文
     * @param handlerResult 请求处理器的处理结果
     * @see Jt808HandlerResultHandler#handleResult(Jt808ServerExchange, Jt808HandlerResult)
     */
    default boolean beforeEncode(Jt808ServerExchange exchange, Jt808HandlerResult handlerResult) {
        return true;
    }

    /**
     * @param exchange      请求上下文
     * @param handlerResult 请求处理器的处理结果
     * @param response      回复给客户端的报文
     * @see Jt808HandlerResultHandler#handleResult(Jt808ServerExchange, Jt808HandlerResult)
     */
    default boolean beforeResponse(Jt808ServerExchange exchange, Jt808HandlerResult handlerResult, ByteBuf response) {
        return true;
    }
}

使用示例

这里是一个使用 Prometheus 统计请求次数的示例：

public class PrometheusMetricsExporter implements Jt808RequestLifecycleListener {

    private final MeterRegistry meterRegistry;

    public PrometheusMetricsExporter(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }

    @Override
    public boolean beforeDispatch(Jt808Request request) {
        Counter.builder("jt808_request_total_count")
                .description("A counter for JT/T 808 request processed by current server")
                .tags(
                        "terminal_id", request.terminalId(),
                        "version", request.version().name().toLowerCase()
                )
                .register(this.meterRegistry)
                .increment();

        return true;
    }
}