从零手写实现 nginx-07-大文件传输分块传输（chunked transfer）/ 分页传输（paging）

RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r"); // 以只读的方式打开文件

long fileLength = randomAccessFile.length();
// 创建一个默认的HTTP响应
HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);
// 设置Content Length
HttpUtil.setContentLength(response, fileLength);


// 读取文件内容到字节数组
byte[] fileContent = new byte[(int) fileLength];
int bytesRead = randomAccessFile.read(fileContent);
if (bytesRead != fileLength) {
    sendError(ctx, INTERNAL_SERVER_ERROR);
    return;
}

// 将文件内容转换为FullHttpResponse
FullHttpResponse fullHttpResponse = new DefaultFullHttpResponse(HTTP_1_1, OK);
fullHttpResponse.content().writeBytes(fileContent);
fullHttpResponse.headers().set(HttpHeaderNames.CONTENT_LENGTH, fileLength);
// 写入HTTP响应并关闭连接
ctx.writeAndFlush(fullHttpResponse).addListener(ChannelFutureListener.CLOSE);

这段代码的主要变化如下：

读取文件内容：使用randomAccessFile.read(fileContent)一次性读取整个文件到字节数组fileContent中。
创建FullHttpResponse：使用DefaultFullHttpResponse创建一个完整的HTTP响应对象，并将文件内容写入到响应的content()中。
设置Content-Length：在FullHttpResponse的headers中设置Content-Length。
发送响应并关闭连接：使用ctx.writeAndFlush(fullHttpResponse)一次性发送整个响应，并通过.addListener(ChannelFutureListener.CLOSE)确保在发送完成后关闭连接。

请注意，这种方式适用于文件大小不是很大的情况，因为整个文件内容被加载到了内存中。

如果文件非常大，这种方式可能会导致内存溢出。

对于大文件，推荐使用分块传输（chunked transfer）或者分页传输（paging）的方式。

分块传输（chunked transfer）

分块传输（Chunked Transfer）是一种HTTP协议中用于传输数据的方法，允许服务器在知道整个响应内容大小之前就开始发送数据。

这在发送大文件或动态生成的内容时非常有用。

以下是使用Netty实现分块传输的一个示例：

RandomAccessFile randomAccessFile = new RandomAccessFile(file, "r"); // 以只读的方式打开文件
long fileLength = randomAccessFile.length();

// 创建一个默认的HTTP响应
HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK);

// 由于是分块传输，移除Content-Length头
response.headers().remove(HttpHeaderNames.CONTENT_LENGTH);

// 如果request中有KEEP ALIVE信息
if (HttpUtil.isKeepAlive(request)) {
    response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
}

// 将HTTP响应写入Channel
ctx.write(response);

// 分块传输文件内容
final int chunkSize = 8192; // 设置分块大小
ByteBuffer buffer = ByteBuffer.allocate(chunkSize);
while (true) {
    int bytesRead = randomAccessFile.read(buffer.array());
    if (bytesRead == -1) { // 文件读取完毕
        break;
    }
    buffer.limit(bytesRead);
    // 写入分块数据
    ctx.write(new DefaultHttpContent(Unpooled.wrappedBuffer(buffer)));
    buffer.clear(); // 清空缓冲区以供下次使用
}

// 写入最后一个分块，即空的HttpContent，表示传输结束
ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT).addListener(ChannelFutureListener.CLOSE);

这段代码的主要变化如下：

移除Content-Length头：由于是分块传输，我们不需要在响应头中设置Content-Length。
分块读取文件：使用一个固定大小的缓冲区ByteBuffer来分块读取文件内容。
发送分块数据：在循环中，每次读取文件内容到缓冲区后，创建一个DefaultHttpContent对象，并将缓冲区的数据包装在Unpooled.wrappedBuffer()中，然后写入Channel。
发送结束标记：在文件读取完毕后，发送一个空的LastHttpContent对象，以标记HTTP消息体的结束。
关闭连接：在发送完最后一个分块后，使用addListener(ChannelFutureListener.CLOSE)确保关闭连接。

分页传输

分页传输通常是指将大文件分成多个小的部分（页），然后逐个发送这些部分。

这种方式适用于在网络编程中传输大文件，因为它可以减少内存的使用，并且允许接收方逐步处理数据。

在Netty中，实现分页传输通常涉及到手动控制数据的发送，而不是使用HTTP分块编码（chunked encoding）。

以下是一个简化的分页传输实现示例，我们将使用Netty的FileRegion来实现高效的文件传输：

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.FileRegion;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.stream.ChunkedFile;

import java.io.RandomAccessFile;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FilePageTransfer {

    public static void sendFile(ChannelHandlerContext ctx, Path filePath) {
        try {
            RandomAccessFile randomAccessFile = new RandomAccessFile(filePath.toFile(), "r");
            FileChannel fileChannel = randomAccessFile.getChannel();

            long fileSize = fileChannel.size();
            long position = 0;
            final long pageSize = 8192; // 定义每页的大小，可以根据实际情况调整

            while (position < fileSize) {
                long remaining = fileSize - position;
                long size = remaining > pageSize ? pageSize : remaining;

                // 使用FileRegion进行传输
                FileRegion region = new DefaultFileRegion(fileChannel, position, size);
                ((SocketChannel) ctx.channel()).write(region);

                // 更新位置
                position += size;

                // 检查传输是否成功
                if (!region.isWritten()) {
                    // 传输失败，可以进行重试或者发送错误响应
                    break;
                }
            }

            // 发送结束标记
            ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT).addListener(ChannelFutureListener.CLOSE);
        } catch (IOException e) {
            e.printStackTrace();
            // 发送错误响应
            ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND));
        }
    }
}

在这个示例中，我们定义了一个sendFile方法，它接受一个ChannelHandlerContext和一个文件路径Path作为参数。以下是该方法的主要步骤：

打开文件：使用RandomAccessFile打开要传输的文件，并获取FileChannel。
计算文件大小：通过fileChannel.size()获取文件的总大小。
分页传输：使用一个循环来逐页读取文件内容。在每次迭代中，我们计算要传输的数据块的大小，并使用FileRegion来表示这部分数据。
写入Channel：将FileRegion写入Netty的Channel。
更新位置：更新position变量以指向下一页的开始位置。
检查传输状态：通过region.isWritten()检查数据是否成功写入。
发送结束标记：传输完成后，发送LastHttpContent.EMPTY_LAST_CONTENT来标记消息结束，并关闭连接。
错误处理：如果在传输过程中发生异常，发送一个错误响应。

请注意，这个示例是一个简化的版本，它没有处理HTTP协议的细节，也没有设置HTTP头信息。

在实际的HTTP服务器实现中，你需要在发送文件内容之前发送一个包含适当头信息的HTTP响应。

此外，LastHttpContent.EMPTY_LAST_CONTENT用于HTTP/1.1，如果你使用的是HTTP/1.0，可能需要不同的处理方式。

改进后的核心代码

统一的分发

为了避免实现膨胀，难以管理，我们将实现全部抽象。

protected NginxRequestDispatch getDispatch(NginxRequestDispatchContext context) {
    final FullHttpRequest requestInfoBo = context.getRequest();
    final NginxConfig nginxConfig = context.getNginxConfig();
    // 消息解析不正确
    /*如果无法解码400*/
    if (!requestInfoBo.decoderResult().isSuccess()) {
        return NginxRequestDispatches.http400();
    }
    // 文件
    File targetFile = getTargetFile(requestInfoBo, nginxConfig);
    // 是否存在
    if(targetFile.exists()) {
        // 设置文件
        context.setFile(targetFile);
        // 如果是文件夹
        if(targetFile.isDirectory()) {
            return NginxRequestDispatches.fileDir();
        }
        long fileSize = targetFile.length();
        if(fileSize <= NginxConst.BIG_FILE_SIZE) {
            return NginxRequestDispatches.fileSmall();
        }
        return NginxRequestDispatches.fileBig();
    }  else {
        return NginxRequestDispatches.http404();
    }
}

大文件的核心逻辑

大文件我们使用 chunk 的方式

    public void doDispatch(NginxRequestDispatchContext context) {
        final FullHttpRequest request = context.getRequest();
        final File targetFile = context.getFile();
        final String bigFilePath = targetFile.getAbsolutePath();
        final long fileLength = targetFile.length();


        logger.info("[Nginx] match big file, path={}", bigFilePath);

        HttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        response.headers().set(HttpHeaderNames.CONTENT_DISPOSITION, "attachment; filename=\"" + targetFile.getName() + "\"");
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, InnerMimeUtil.getContentType(targetFile));
        response.headers().set(HttpHeaderNames.CONTENT_LENGTH, fileLength);

        final ChannelHandlerContext ctx = context.getCtx();
        ctx.write(response);

        // 分块传输文件内容
        long totalLength = targetFile.length();
        long totalRead = 0;

        try(RandomAccessFile randomAccessFile = new RandomAccessFile(targetFile, "r")) {
            ByteBuffer buffer = ByteBuffer.allocate(NginxConst.CHUNK_SIZE);
            while (true) {
                int bytesRead = randomAccessFile.read(buffer.array());
                if (bytesRead == -1) { // 文件读取完毕
                    break;
                }
                buffer.limit(bytesRead);
                // 写入分块数据
                ctx.write(new DefaultHttpContent(Unpooled.wrappedBuffer(buffer)));
                buffer.clear(); // 清空缓冲区以供下次使用

                // process 可以考虑加一个 listener
                totalRead += bytesRead;
                logger.info("[Nginx] bigFile process >>>>>>>>>>> {}/{}", totalRead, totalLength);
            }

            // 发送结束标记
            ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT)
                    .addListener(ChannelFutureListener.CLOSE);
        } catch (Exception e) {
            logger.error("[Nginx] bigFile meet ex", e);
        }
    }

这里采用的是直接下载的方式。

当然，也可以实现在线播放，但是试了下效果不好，后续有时间可以尝试下。

测试日志

[INFO] [2024-05-26 15:53:58.498] [nioEventLoopGroup-3-3] [c.g.h.n.s.h.NginxNettyServerHandler.channelRead0] - [Nginx] channelRead writeAndFlush start request=HttpObjectAggregator$AggregatedFullHttpRequest(decodeResult: success, version: HTTP/1.1, content: CompositeByteBuf(ridx: 0, widx: 0, cap: 0, components=0))
GET /mime/2.mp4 HTTP/1.1
Host: 192.168.1.12:8080
Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
content-length: 0, id=40a5effffe257be0-00001c6c-00000003-0824dff434805bd3-b09fd676
[INFO] [2024-05-26 15:53:58.498] [nioEventLoopGroup-3-3] [c.g.h.n.s.r.d.h.AbstractNginxRequestDispatchFullResp.doDispatch] - [Nginx] match big file, path=D:\data\nginx4j\mime\2.mp4
[INFO] [2024-05-26 15:53:58.514] [nioEventLoopGroup-3-3] [c.g.h.n.s.r.d.h.AbstractNginxRequestDispatchFullResp.doDispatch] - [Nginx] bigFile process >>>>>>>>>>> 8388608/668918096
...
[INFO] [2024-05-26 15:53:59.616] [nioEventLoopGroup-3-3] [c.g.h.n.s.r.d.h.AbstractNginxRequestDispatchFullResp.doDispatch] - [Nginx] bigFile process >>>>>>>>>>> 668918096/668918096
[INFO] [2024-05-26 15:53:59.627] [nioEventLoopGroup-3-3] [c.g.h.n.s.h.NginxNettyServerHandler.channelRead0] - [Nginx] channelRead writeAndFlush DONE id=40a5effffe257be0-00001c6c-00000003-0824dff434805bd3-b09fd676

小结

本节我们实现了一个大文件的下载处理，主要思想就是分段。

可以考虑类似于视频软件，采用分段加载实时播放的方式。

下一节，我们考虑实现以下文件的范围查询。

我是老马，期待与你的下次重逢。

开源地址

为了便于大家学习，已经将 nginx 开源

https://github.com/houbb/nginx4j

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 204,793评论 6赞 478
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 87,567评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 151,342评论 0赞 338
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,825评论 1赞 277
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,814评论 5赞 368
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,680评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,033评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,687评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 42,175评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,668评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,775评论 1赞 332
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,419评论 4赞 321
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,020评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,978评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,206评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,092评论 2赞 351
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,510评论 2赞 343

从零手写实现 nginx-07-大文件传输 分块传输（chunked transfer）/ 分页传输（paging）

前言

手写 nginx 系列

目标

思路

大文件传输的方式

一次梭哈