如何使用littleproxy/netty缓存流量？

import org.littleshoot.proxy.HttpFilters;
import org.littleshoot.proxy.HttpFiltersSource;
import org.littleshoot.proxy.impl.DefaultHttpProxyServer;

public class CachingHttpFiltersSource implements HttpFiltersSource {

    @Override
    public HttpFilters filterRequest(HttpRequest originalRequest, ChannelHandlerContext ctx) {
        return new CachingHttpFilters(originalRequest, ctx);
    }

    @Override
    public int getMaximumRequestBufferSizeInBytes() {
        return 10 * 1024 * 1024; // 设置请求缓冲区大小
    }

    @Override
    public int getMaximumResponseBufferSizeInBytes() {
        return 10 * 1024 * 1024; // 设置响应缓冲区大小
    }
}

public class CachingHttpFilters implements HttpFilters {

    private final HttpRequest originalRequest;
    private final ChannelHandlerContext ctx;

    public CachingHttpFilters(HttpRequest originalRequest, ChannelHandlerContext ctx) {
        this.originalRequest = originalRequest;
        this.ctx = ctx;
    }

    @Override
    public HttpResponse clientToProxyRequest(HttpObject httpObject) {
        // 在这里处理客户端到代理服务器的请求
        return null;
    }

    @Override
    public HttpResponse proxyToServerRequest(HttpObject httpObject) {
        // 在这里处理代理服务器到目标服务器的请求
        return null;
    }

    @Override
    public void proxyToServerRequestSending() {
        // 在这里处理代理服务器发送请求到目标服务器之前的逻辑
    }

    @Override
    public void proxyToServerRequestSent() {
        // 在这里处理代理服务器发送请求到目标服务器之后的逻辑
    }

    @Override
    public HttpObject serverToProxyResponse(HttpObject httpObject) {
        // 在这里处理目标服务器到代理服务器的响应
        return null;
    }

    @Override
    public void serverToProxyResponseTimedOut() {
        // 在这里处理目标服务器响应超时的逻辑
    }

    @Override
    public void serverToProxyResponseReceiving() {
        // 在这里处理代理服务器接收目标服务器响应之前的逻辑
    }

    @Override
    public void serverToProxyResponseReceived() {
        // 在这里处理代理服务器接收目标服务器响应之后的逻辑
    }

    @Override
    public HttpObject proxyToClientResponse(HttpObject httpObject) {
        // 在这里处理代理服务器到客户端的响应
        return null;
    }

    @Override
    public void proxyToServerConnectionQueued() {
        // 在这里处理代理服务器连接到目标服务器之前的逻辑
    }

    @Override
    public InetSocketAddress proxyToServerResolutionStarted(String resolvingServerHostAndPort) {
        // 在这里处理代理服务器解析目标服务器地址之前的逻辑
        return null;
    }

    @Override
    public void proxyToServerResolutionFailed(String hostAndPort) {
        // 在这里处理代理服务器解析目标服务器地址失败的逻辑
    }

    @Override
    public void proxyToServerResolutionSucceeded(String serverHostAndPort, InetSocketAddress resolvedRemoteAddress) {
        // 在这里处理代理服务器解析目标服务器地址成功的逻辑
    }
}

import org.littleshoot.proxy.HttpProxyServer;
import org.littleshoot.proxy.impl.DefaultHttpProxyServer;

public class ProxyServer {

    public static void main(String[] args) {
        int port = 8888; // 设置代理服务器监听的端口号

        HttpProxyServer proxyServer = DefaultHttpProxyServer.bootstrap()
                .withPort(port)
                .withFiltersSource(new CachingHttpFiltersSource()) // 设置自定义的HttpFiltersSource
                .start();

        System.out.println("Proxy server started on port " + port);
    }
}