Node.js中实现HTTP 206内容分片

开发 前端
在本文中,我会阐述HTTP状态206 分部分内容 的基础概念,并使用Node.js一步步地实现它. 我们还将用一个基于它用法最常见场景的示例来测试代码:一个能够在任何时间点开始播放视频文件的HTML5页面.

介绍

在本文中,我会阐述HTTP状态206 分部分内容 的基础概念,并使用Node.js一步步地实现它. 我们还将用一个基于它用法最常见场景的示例来测试代码:一个能够在任何时间点开始播放视频文件的HTML5页面. 

Partial Content 的简要介绍

HTTP 的 206 Partial Content 状态码和其相关的消息头提供了让浏览器以及其他用户代理从服务器接收部分内容而不是全部内容,这样一种机制. 这一机制被广泛使用在一个被大多数浏览器和诸如Windows Media Player和VLC Player这样的播放器所支持视频文件的传输上.

基础的流程可以用下面这几步描述:

  1. 浏览器请求内容.

  2. 服务器告诉浏览器,该内容可以使用 Accept-Ranges 消息头进行分部分请求.

  3. 浏览器重新发送请求,用 Range 消息头告诉服务器需要的内容范围.

  4. 服务器会分如下两种情况响应浏览器的请求: 

    • 如果范围是合理的,服务器会返回所请求的部分内容,并带上 206 Partial Content 状态码. 当前内容的范围会在 Content-Range 消息头中申明.

    • 如果范围是不可用的(例如,比内容的总字节数大), 服务器会返回 416 请求范围不合理 Requested Range Not Satisfiable 状态码. 可用的范围也会在 Content-Range 消息头中声明.

让我们来看看这几个步骤中的每一个关键消息头.

Accept-Ranges: 字节(bytes)

这是会有服务器发送的字节头,展示可以被分部分发送给浏览器的内容. 这个值声明了可被接受的每一个范围请求, 大多数情况下是字节数 bytes

Range: 字节数(bytes)=(开始)-(结束)

这是浏览器告知服务器所需分部分内容范围的消息头. 注意开始和结束位置是都包括在内的,而且是从0开始的. 这个消息头也可以不发送两个位置,其含义如下: 

  • 如果结束位置被去掉了,服务器会返回从声明的开始位置到整个内容的结束位置内容的最后一个可用字节.

  • 如果开始位置被去掉了,结束位置参数可以被描述成从最后一个可用的字节算起可以被服务器返回的字节数.

Content-Range:字节数(bytes)=(开始)-(结束)/(总数)

这个消息头将会跟随 HTTP 状态码 206 一起出现. 开始和结束的值展示了当前内容的范围. 跟 Range 消息头一样, 两个值都是包含在内的,并且也是从零开始的. 总数这个值声明了可用字节的总数.

Content-Range: */(总数)

这个头信息和上面一个是一样的,不过是用另一种格式,并且仅在返回HTTP状态码416时被发送。其中总数代表了正文总共可用的字节数。

这里有一对有2048个字节文件的例子。注意省略起点和重点的区别。

请求开始的1024个字节

浏览器发送:

  1. GET /dota2/techies.mp4 HTTP/1.1  
  2. Host: localhost:8000  
  3. Range: bytes=0-1023 

服务器返回:

  1. HTTP/1.1 216 Partial Content  
  2. Date: Mon, 15 Sep 2014 22:19:34 GMT  
  3. Content-Type: video/mp4  
  4. Content-Range: bytes 0-1023/2048  
  5. Content-Length: 1024  
  6.    
  7. (Content...) 

没有终点位置的请求

浏览器发送:

  1. GET /dota2/techies.mp4 HTTP/1.1  
  2. Host: localhost:8000  
  3. Range: bytes=1024

服务器返回:

  1. HTTP/1.1 216 Partial Content  
  2. Date: Mon, 15 Sep 2014 22:19:34 GMT  
  3. Content-Type: video/mp4  
  4. Content-Range: bytes 1024-2047/2048  
  5. Content-Length: 1024  
  6.    
  7. (Content...) 

注意:服务器并不需要在单个响应中返回所有剩下的字节,特别是当正文太长或者有其他性能的考虑。所以下面的两个例子在这种情况下也是可接受的:

  1. Content-Range: bytes 1024-1535/2048  
  2. Content-Length: 512 

服务器仅返回剩余正文的一半。下一次请求的范围将从第1536个字节开始。

  1. Content-Range: bytes 1024-1279/2048  
  2. Content-Length: 256 

服务器仅返回剩余正文的256个字节。下一次请求的范围将从第1280个字节开始。

 

服务器返回:

  1. HTTP/1.1 216 Partial Content  
  2. Date: Mon, 15 Sep 2014 22:19:34 GMT  
  3. Content-Type: video/mp4  
  4. Content-Range: bytes 1536-2047/2048  
  5. Content-Length: 512  
  6.    
  7. (Content...) 

请求不可用的范围:

浏览器发送:

  1. GET /dota2/techies.mp4 HTTP/1.1  
  2. Host: localhost:8000  
  3. Range: bytes=1024-4096 

服务器返回:

  1. HTTP/1.1 416 Requested Range Not Satisfiable  
  2. Date: Mon, 15 Sep 2014 22:19:34 GMT  
  3. Content-Range: bytes */2048 

理解了工作流和头部信息后,现在我们可以用Node.js去实现这个机制。

#p#

第一步:创建一个简单的HTTP服务器

我们将像下面的例子那样,从一个基本的HTTP服务器开始。这已经可以基本足够处理大多数的浏览器请求了。首先,我们初始化我们需要用到的对象,并且用initFolder来代表文件的位置。为了生成Content-Type头部,我们列出文件扩展名和它们相对应的MIME名称来构成一个字典。在回调函数httpListener()中,我们将仅允许GET可用。如果出现其他方法,服务器将返回405 Method Not Allowed,在文件不存在于initFolder,服务器将返回404 Not Found

  1. // 初始化需要的对象  
  2. var http = require("http");  
  3. var fs = require("fs");  
  4. var path = require("path");  
  5. var url = require("url");  
  6.    
  7. // 初始的目录,随时可以改成你希望的目录  
  8. var initFolder = "C:\\Users\\User\\Videos";  
  9.    
  10. // 将我们需要的文件扩展名和MIME名称列出一个字典  
  11. var mimeNames = {  
  12.     ".css""text/css",  
  13.     ".html""text/html",  
  14.     ".js""application/javascript",  
  15.     ".mp3""audio/mpeg",  
  16.     ".mp4""video/mp4",  
  17.     ".ogg""application/ogg",   
  18.     ".ogv""video/ogg",   
  19.     ".oga""audio/ogg",  
  20.     ".txt""text/plain",  
  21.     ".wav""audio/x-wav",  
  22.     ".webm""video/webm";  
  23. };  
  24.    
  25. http.createServer(httpListener).listen(8000);  
  26.    
  27. function httpListener (request, response) {  
  28.     // 我们将只接受GET请求,否则返回405 'Method Not Allowed'  
  29.     if (request.method != "GET") {   
  30.         sendResponse(response, 405, {"Allow" : "GET"}, null);  
  31.         return null;  
  32.     }  
  33.    
  34.     var filename =   
  35.         initFolder + url.parse(request.url, truetrue).pathname.split('/').join(path.sep);  
  36.    
  37.     var responseHeaders = {};  
  38.     var stat = fs.statSync(filename);  
  39.     // 检查文件是否存在,不存在就返回404 Not Found  
  40.     if (!fs.existsSync(filename)) {  
  41.         sendResponse(response, 404, nullnull);  
  42.         return null;  
  43.     }  
  44.     responseHeaders["Content-Type"] = getMimeNameFromExt(path.extname(filename));  
  45.     responseHeaders["Content-Length"] = stat.size; // 文件大小  
  46.            
  47.     sendResponse(response, 200, responseHeaders, fs.createReadStream(filename));  
  48. }  
  49.    
  50. function sendResponse(response, responseStatus, responseHeaders, readable) {  
  51.     response.writeHead(responseStatus, responseHeaders);  
  52.    
  53.     if (readable == null)  
  54.         response.end();  
  55.     else 
  56.         readable.on("open"function () {  
  57.             readable.pipe(response);  
  58.         });  
  59.    
  60.     return null;  
  61. }  
  62.    
  63. function getMimeNameFromExt(ext) {  
  64.     var result = mimeNames[ext.toLowerCase()];  
  65.        
  66.     // 最好给一个默认值  
  67.     if (result == null)  
  68.         result = "application/octet-stream";  
  69.        
  70.     return result;  

 

步骤 2 - 使用正则表达式捕获Range消息头

有了这个HTTP服务器做基础,我们现在就可以用如下代码处理Range消息头了. 我们使用正则表达式将消息头分割,以获取开始和结束字符串。然后使用 parseInt() 方法将它们转换成整形数. 如果返回值是 NaN (非数字not a number), 那么这个字符串就是没有在这个消息头中的. 参数totalLength展示了当前文件的总字节数. 我们将使用它计算开始和结束位置. 

  1. function readRangeHeader(range, totalLength) {  
  2.         /*  
  3.          * Example of the method 'split' with regular expression.  
  4.          *   
  5.          * Input: bytes=100-200  
  6.          * Output: [null, 100, 200, null]  
  7.          *   
  8.          * Input: bytes=-200  
  9.          * Output: [null, null, 200, null]  
  10.          */ 
  11.    
  12.     if (range == null || range.length == 0)  
  13.         return null;  
  14.    
  15.     var array = range.split(/bytes=([0-9]*)-([0-9]*)/);  
  16.     var start = parseInt(array[1]);  
  17.     var end = parseInt(array[2]);  
  18.     var result = {  
  19.         Start: isNaN(start) ? 0 : start,  
  20.         End: isNaN(end) ? (totalLength - 1) : end  
  21.     };  
  22.        
  23.     if (!isNaN(start) && isNaN(end)) {  
  24.         result.Start = start;  
  25.         result.End = totalLength - 1;  
  26.     }  
  27.    
  28.     if (isNaN(start) && !isNaN(end)) {  
  29.         result.Start = totalLength - end;  
  30.         result.End = totalLength - 1;  
  31.     }  
  32.    
  33.     return result;  

步骤 3 - 检查数据范围是否合理

回到函数 httpListener(), 在HTTP方法通过之后,现在我们来检查请求的数据范围是否可用. 如果浏览器没有发送 Range 消息头过来, 请求就会直接被当做一般的请求对待. 服务器会返回整个文件,HTTP状态将会是 200 OK. 另外我们还会看看开始和结束位置是否比文件长度更大或者相等. 只要有一个是这种情况,请求的数据范围就是不能被满足的. 返回的状态就将会是 416 Requested Range Not Satisfiable 而 Content-Range 也会被发送. 

  1. var responseHeaders = {};  
  2.     var stat = fs.statSync(filename);  
  3.     var rangeRequest = readRangeHeader(request.headers['range'], stat.size);  
  4.       
  5.     // If 'Range' header exists, we will parse it with Regular Expression.  
  6.     if (rangeRequest == null) {  
  7.         responseHeaders['Content-Type'] = getMimeNameFromExt(path.extname(filename));  
  8.         responseHeaders['Content-Length'] = stat.size;  // File size.  
  9.         responseHeaders['Accept-Ranges'] = 'bytes';  
  10.            
  11.         //  If not, will return file directly.  
  12.         sendResponse(response, 200, responseHeaders, fs.createReadStream(filename));  
  13.         return null;  
  14.     }  
  15.    
  16.     var start = rangeRequest.Start;  
  17.     var end = rangeRequest.End;  
  18.    
  19.     // If the range can't be fulfilled.   
  20.     if (start >= stat.size || end >= stat.size) {  
  21.         // Indicate the acceptable range.  
  22.         responseHeaders['Content-Range'] = 'bytes */' + stat.size; // File size.  
  23.    
  24.         // Return the 416 'Requested Range Not Satisfiable'.  
  25.         sendResponse(response, 416, responseHeaders, null);  
  26.         return null;  
  27.     } 

步骤 4 - 满足请求

最后使人迷惑的一块来了。对于状态 216 Partial Content, 我们有另外一种格式的 Content-Range 消息头,包括开始,结束位置以及当前文件的总字节数. 我们也还有 Content-Length 消息头,其值就等于开始和结束位置之间的差。在最后一句代码中,我们调用了 createReadStream() 并将开始和结束位置的值给了第二个参数选项的对象, 这意味着返回的流将只包含从开始到结束位置的只读数据.

  1. // Indicate the current range.   
  2.     responseHeaders['Content-Range'] = 'bytes ' + start + '-' + end + '/' + stat.size;  
  3.     responseHeaders['Content-Length'] = start == end ? 0 : (end - start + 1);  
  4.     responseHeaders['Content-Type'] = getMimeNameFromExt(path.extname(filename));  
  5.     responseHeaders['Accept-Ranges'] = 'bytes';  
  6.     responseHeaders['Cache-Control'] = 'no-cache';  
  7.    
  8.     // Return the 206 'Partial Content'.  
  9.     sendResponse(response, 206,   
  10.         responseHeaders, fs.createReadStream(filename, { start: start, end: end })); 

下面是完整的 httpListener() 回调函数.

  1. function httpListener(request, response) {  
  2.     // We will only accept 'GET' method. Otherwise will return 405 'Method Not Allowed'.  
  3.     if (request.method != 'GET') {  
  4.         sendResponse(response, 405, { 'Allow''GET' }, null);  
  5.         return null;  
  6.     }  
  7.    
  8.     var filename =  
  9.         initFolder + url.parse(request.url, truetrue).pathname.split('/').join(path.sep);  
  10.    
  11.     // Check if file exists. If not, will return the 404 'Not Found'.   
  12.     if (!fs.existsSync(filename)) {  
  13.         sendResponse(response, 404, nullnull);  
  14.         return null;  
  15.     }  
  16.    
  17.     var responseHeaders = {};  
  18.     var stat = fs.statSync(filename);  
  19.     var rangeRequest = readRangeHeader(request.headers['range'], stat.size);  
  20.    
  21.     // If 'Range' header exists, we will parse it with Regular Expression.  
  22.     if (rangeRequest == null) {  
  23.         responseHeaders['Content-Type'] = getMimeNameFromExt(path.extname(filename));  
  24.         responseHeaders['Content-Length'] = stat.size;  // File size.  
  25.         responseHeaders['Accept-Ranges'] = 'bytes';  
  26.    
  27.         //  If not, will return file directly.  
  28.         sendResponse(response, 200, responseHeaders, fs.createReadStream(filename));  
  29.         return null;  
  30.     }  
  31.    
  32.     var start = rangeRequest.Start;  
  33.     var end = rangeRequest.End;  
  34.    
  35.     // If the range can't be fulfilled.   
  36.     if (start >= stat.size || end >= stat.size) {  
  37.         // Indicate the acceptable range.  
  38.         responseHeaders['Content-Range'] = 'bytes */' + stat.size; // File size.  
  39.    
  40.         // Return the 416 'Requested Range Not Satisfiable'.  
  41.         sendResponse(response, 416, responseHeaders, null);  
  42.         return null;  
  43.     }  
  44.    
  45.     // Indicate the current range.   
  46.     responseHeaders['Content-Range'] = 'bytes ' + start + '-' + end + '/' + stat.size;  
  47.     responseHeaders['Content-Length'] = start == end ? 0 : (end - start + 1);  
  48.     responseHeaders['Content-Type'] = getMimeNameFromExt(path.extname(filename));  
  49.     responseHeaders['Accept-Ranges'] = 'bytes';  
  50.     responseHeaders['Cache-Control'] = 'no-cache';  
  51.    
  52.     // Return the 206 'Partial Content'.  
  53.     sendResponse(response, 206,   
  54.         responseHeaders, fs.createReadStream(filename, { start: start, end: end }));  

#p#

测试实现

我们怎么来测试我们的代码呢?就像在介绍中提到的,部分正文最常用的场景是流和播放视频。所以我们创建了一个ID为mainPlayer并包含一个<source/>标签的<video/>。函数onLoad()将在mainPlayer预读取当前视频的元数据时被触发,这用于检查在URL中是否有数字参数,如果有,mainPlayer将跳到指定的时间点。

  1. <!DOCTYPE html> 
  2. <html> 
  3.     <head> 
  4.         <script type="text/javascript"> 
  5.    
  6.             function onLoad() {  
  7.                 var sec = parseInt(document.location.search.substr(1));  
  8.                    
  9.                 if (!isNaN(sec))  
  10.                     mainPlayer.currentTime = sec;  
  11.             }  
  12.            
  13.         </script> 
  14.         <title>Partial Content Demonstration</title> 
  15.     </head> 
  16.     <body> 
  17.         <h3>Partial Content Demonstration</h3> 
  18.         <hr /> 
  19.         <video id="mainPlayer" width="640" height="360"   
  20.             autoplay="autoplay" controls="controls" onloadedmetadata="onLoad()"> 
  21.             <source src="dota2/techies.mp4" /> 
  22.         </video> 
  23.     </body> 
  24. </html> 

现在我们把页面保存为"player.html"并和"dota2/techies.mp4"一起放在initFolder目录下。然后在浏览器中打开URL:http://localhost:8000/player.html

在Chrome中看起来像这样:

因为在URL中没有任何参数,文件将从最开始出播放。

接下来就是有趣的部分了。让我们试着打开这个然后看看发生了什么:http://localhost:8000/player.html?60

如果你按F12来打开Chrome的开发者工具,切换到网络标签页,然后点击查看最近一次日志的详细信息。你会发现范围的头信息(Range)被你的浏览器发送了:

  1. Range:bytes=225084502

很有趣,对吧?当函数onLoad()改变currentTime属性的时候,浏览器计算这部视频60秒处的字节位置。因为mainPlayer已经预加载了元数据,包括格式、比特率和其他基本信息,这个起始位置立刻就被得到了。之后,浏览器就可以下载并播放视频而不需要请求开头的60秒了。成功了!

我们已经用Node.js来实现支持部分正文的HTTP服务器端了。我们也用HTML5页面测试了。但这只是一个开始。如果你对头部信息和工作流这些都已经理解透彻了,你可以试着用其他像ASP.NET MVC或者WCF服务这类框架来实现它。但是不要忘记启动任务管理器来查看CPU和内存的使用。像我们在之前讨论到的,服务器没有在单个响应中返回所用剩余的字节。要找到性能的平衡点将是一项重要的任务。

英文原文:HTTP 206 Partial Content In Node.js

 

译文出自:http://www.oschina.net/translate/http-partial-content-in-node-js

结论

开始用Node.js实现

请求最后512个字节

浏览器发送:

  1. GET /dota2/techies.mp4 HTTP/1.1  
  2. Host: localhost:8000  
  3. Range: bytes=-512 
责任编辑:林师授 来源: 开源中国社区 编译
相关推荐

2017-04-24 08:31:26

Node.jsExpress.jsHTTP

2011-09-08 14:16:12

Node.js

2023-06-30 23:25:46

HTTP模块内存

2017-03-20 13:43:51

Node.js内存泄漏

2017-03-19 16:40:28

漏洞Node.js内存泄漏

2013-11-01 09:34:56

Node.js技术

2015-03-10 10:59:18

Node.js开发指南基础介绍

2017-08-17 13:56:30

JavascriptNode.jsHttp

2021-10-03 15:02:50

HTTPNodejs

2021-07-16 04:56:03

NodejsAddon

2021-03-09 08:03:21

Node.js 线程JavaScript

2016-08-11 14:02:02

NodeJS前端

2021-05-21 09:36:42

开发技能代码

2020-04-15 15:48:03

Node.jsstream前端

2024-01-05 08:49:15

Node.js异步编程

2021-10-21 08:59:17

技术HTTP攻击

2011-09-08 13:46:14

node.js

2011-11-01 10:30:36

Node.js

2011-09-02 14:47:48

Node

2011-09-09 14:23:13

Node.js
点赞
收藏

51CTO技术栈公众号