静态资源服务器，怎样操作Node静态资源服务器
大家好，关于静态资源服务器很多朋友都还不太明白，不过没关系，因为今天小编就来为大家分享关于怎样操作Node静态资源服务器的知识点，相信应该可以解决大家的一些困惑和问题，如果碰巧可以解决您的问题，还望关注下本站哦，希望对各位有所帮助！
qq空间无法访问我们的静态资源服务器 这是怎么回事
尊敬的腾讯用户您好：
造成QQ空间日志、Flash、模块、相册不能正常打开的原因有很多，这里将腾讯官方给出的解决方案提供给您。请您确定电脑环境安全，网络连接正常后，楼试以下操作：
使用：腾电脑诊所讯电脑管家为QQ空间定制的专修工具，点击上侧绿色的【修复】按钮即可
附：手动修复步骤（由腾讯电脑管家提供）
方案一：清除IE缓存
1.打开IE浏览器→点击【工具】→【Internet选项】→【删除】：
2.勾选所有选项→点击【确定】→在确认窗口中点击【确定】：
方案二：注册IE组件
1.点击【开始】菜单→在搜索框中输入"cmd"→按键盘enter(回车)键：
2.在弹出的黑色窗口中，按顺序输入以下内容，按键盘enter(回车)键，再逐一完成以下全部部件注册：
regsvr32 atl.dll
regsvr32 shdocvw.dll
regsvr32 actxprxy.dll
regsvr32 urlmon.dll
regsvr32 browseui.dll
regsvr32 oleaut32.dll
regsvr32 shell32.dll
regsvr32 jscript.dll
regsvr32 vbscript.dll
regsvr32 mshtmled.dll
regsvr32 CLBCATQ.DLL
regsvr32 cscui.dll
regsvr32 MLANG.DL
regsvr32 stobject.dl
regsvr32 WINHTTP.dll
regsvr32 msxml3.dll
regsvr32 query.dll
regsvr32 jscript9.dll
regsvr32 hlink.dll
建议点击本回答上侧【修复】按钮，使用电脑诊所一键自动完成所有修复步骤。
方案三：调低cookie隐私等级
1.打开IE浏览器→点击【工具】→【Internet选项】
2.点击【隐私】→将【选择Internet区域设置】调为【中】→点击【确定】：
方案四：升级flash(空间显示异常)
1.打开【电脑管家】→点击【软件管理】，在搜索框中输入"flash"→找到相应版本点击【安装】或【升级】(如此步骤无法成功修复，可继续执行第二步骤再进行此步骤)
2.打开文件夹C:\Windows\System32\Macromed\Flash将名为"Flash32_版本号.ocx"文件删除(如果无法删除请右键文件点击【属性】→【安全】→【高级】→【更改权限】→将前两项拒绝权限删除后点击【确定】后，再将QQ、腾讯电脑管家、浏览器关闭后即可删除文件)
如果以上诉步骤未能生效，再进入后续步骤：
方案五：重置IE
（说明：如果您使用网络代理或者对浏览器有特殊设置，请保存设置后再进行操作）
1.打开IE浏览器→点击【工具】→【Internet选项】
2.点击【高级】→点击【重置】→勾选【删除个性化设置】→点击【确定】→【确定】：
方案六：安装其他浏览器后设置其他浏览器为默认浏览器
1.打开电脑管家→点击【软件管理】，在搜索框中输入"谷歌浏览器"→找到软件后点击安装
2.打开电脑管家→点击【工具箱】，点击【默认程序设置】→在上网浏览器列表中选择【谷歌浏览器】：
3.如果你安装了QQ浏览器，需在QQ的设置中，取消QQ浏览器打开链接的勾选：
如果问题仍未解决，请继续追问！
感谢您的提问，希望您的问题得到解决。
如何利用Node静态资源服务器
这次给大家带来如何利用Node静态资源服务器，Node静态资源服务器的注意事项有哪些，下面就是实战案例，一起来看一下。
http服务器是继承自tcp服务器 http协议是应用层协议，是基于TCP的
http的原理是对请求和响应进行了包装，当客户端连接上来之后先触发connection事件，然后可以多次发送请求，每次请求都会触发request事件
let server= http.createServer();
let url= require('url');
server.on('connection', function(socket){
console.log('客户端连接');
});
server.on('request', function(req, res){
let{ pathname, query}= url.parse(req.url, true);
let result= [];
req.on('data', function(data){
result.push(data);
});
req.on('end', function(){
let r= Buffer.concat(result);
res.end(r);
})
});
server.on('close', function(req, res){
console.log('服务器关闭');
});
server.on('error', function(err){
console.log('服务器错误');
});
server.listen(8080, function(){
console.log('server started at http://localhost:8080');
});req代表客户端的连接，server服务器把客户端的请求信息进行解析，然后放在req上面
res代表响应，如果希望向客户端回应消息，需要通过 res
req和res都是从socket来的，先监听socket的data事件，然后等事件发生的时候，进行解析，解析出请头对象，再创建请求对象，再根据请求对象创建响应对象
req.url获取请求路径
req.headers请求头对象
接下来我们对一些核心功能进行讲解
深刻理解并实现压缩和解压
为什么要压缩呢？有什么好处?
可以使用zlib模块进行压缩及解压缩处理,压缩文件以后可以减少体积，加快传输速度和节约带宽代码
压缩和解压缩对象都是transform转换流，继承自duplex双工流即可读可写流
zlib.createGzip：返回Gzip流对象，使用Gzip算法对数据进行压缩处理
zlib.createGunzip：返回Gzip流对象，使用Gzip算法对压缩的数据进行解压缩处理
zlib.createDeflate：返回Deflate流对象，使用Deflate算法对数据进行压缩处理
zlib.createInflate：返回Deflate流对象，使用Deflate算法对数据进行解压缩处理
实现压缩和解压
因为压缩我文件可能很大也可能很小，所以为了提高处理速度，我们用流来实现
let fs= require("fs");
let path= require("path");
let zlib= require("zlib");
function gzip(src){
fs
.createReadStream(src)
.pipe(zlib.createGzip())
.pipe(fs.createWriteStream(src+".gz"));
}
gzip(path.join(__dirname,'msg.txt'));
function gunzip(src){
fs
.createReadStream(src)
.pipe(zlib.createGunzip())
.pipe(
fs.createWriteStream(path.join(__dirname, path.basename(src,".gz")))
);
}
gunzip(path.join(__dirname,"msg.txt.gz"));gzip方法用于实现压缩
gunzip方法用于实现解压
其中文件msg.txt是同级目录
为什么需要这么写：gzip(path.join(__dirname,'msg.txt'));
因为console.log(process.cwd());打印出当前工作目录是根目录，并不是文件所在目录，如果这么写gzip('msg.txt');找不到文件就会报错
basename从一个路径中得到文件名，包括扩展名的，可以传一个扩展名参数，去掉扩展名
extname获取扩展名
压缩的格式和解压的格式需要对上，否则会报错
有些时候我们拿到的字符串不是一个流，那怎么解决呢
let zlib=require('zlib');
let str='hello';
zlib.gzip(str,(err,buffer)=>{
console.log(buffer.length);
zlib.unzip(buffer,(err,data)=>{
console.log(data.toString());
})
});有可能压缩后的内容比原来还大，要是内容太少的话，压缩也没什么意义了
文本压缩的效果会好一点，因为有规律
在http中应用压缩和解压
下面实现这样一个功能，如图：
客户端向服务器发起请求的时候，会通过accept-encoding(比如：Accept-Encoding:gzip,default)告诉服务器我支持的解压缩的格式
服务器端需要根据Accept-Encoding显示的格式进行压缩，没有的格式就不能压缩，因为浏览器无法解压
如果客户端需要的Accept-Encoding中的格式服务端没有，也无法实现压缩
let http= require("http");
let path= require("path");
let url= require("url");
let zlib= require("zlib");
let fs= require("fs");
let{ promisify}= require("util");
let mime= require("mime");
//把一个异步方法转成一个返回promise的方法
let stat= promisify(fs.stat);
http.createServer(request).listen(8080);
async function request(req, res){
let{ pathname}= url.parse(req.url);
let filepath= path.join(__dirname, pathname);
// fs.stat(filepath,(err,stat)=>{});现在不这么写了，异步的处理起来比较麻烦
try{
let statObj= await stat(filepath);
res.setHeader("Content-Type", mime.getType(pathname));
let acceptEncoding= req.headers["accept-encoding"];
if(acceptEncoding){
if(acceptEncoding.match(/\bgzip\b/)){
res.setHeader("Content-Encoding","gzip");
fs
.createReadStream(filepath)
.pipe(zlib.createGzip())
.pipe(res);
} else if(acceptEncoding.match(/\bdeflate\b/)){
res.setHeader("Content-Encoding","deflate");
fs
.createReadStream(filepath)
.pipe(zlib.createDeflate())
.pipe(res);
} else{
fs.createReadStream(filepath).pipe(res);
}
} else{
fs.createReadStream(filepath).pipe(res);
}
} catch(e){
res.statusCode= 404;
res.end("Not Found");
}
}mime：通过文件的名称、路径拿到一个文件的内容类型，可以根据不同的文件内容类型返回不同的Content-Type
acceptEncoding：全部写成小写是为了兼容不同的浏览器，node把所有的请求头全转成了小写
filepath：得到文件的绝对路径
启动服务后，访问http://localhost:8080/msg.txt可看到结果
深刻理解并实现缓存
为什么要缓存呢，缓存有什么好处？
减少了冗余的数据传输，节省了网费。
减少了服务器的负担，大大提高了网站的性能
加快了客户端加载网页的速度
缓存的分类
强制缓存：
强制缓存，在缓存数据未失效的情况下，可以直接使用缓存数据
在没有缓存数据的时候，浏览器向服务器请求数据时，服务器会将数据和缓存规则一并返回，缓存规则信息包含在响应header中
对比缓存：
浏览器第一次请求数据时，服务器会将缓存标识与数据一起返回给客户端，客户端将二者备份至缓存数据库中
再次请求数据时，客户端将备份的缓存标识发送给服务器，服务器根据缓存标识进行判断，判断成功后，返回304状态码，通知客户端比较成功，可以使用缓存数据
两类缓存的区别和联系
强制缓存如果生效，不需要再和服务器发生交互，而对比缓存不管是否生效，都需要与服务端发生交互
两类缓存规则可以同时存在，强制缓存优先级高于对比缓存，也就是说，当执行强制缓存的规则时，如果缓存生效，直接使用缓存，不再执行对比缓存规则
实现对比缓存
实现对比缓存一般是按照以下步骤：
第一次访问服务器的时候，服务器返回资源和缓存的标识，客户端则会把此资源缓存在本地的缓存数据库中。
第二次客户端需要此数据的时候，要取得缓存的标识，然后去问一下服务器我的资源是否是最新的。
如果是最新的则直接使用缓存数据，如果不是最新的则服务器返回新的资源和缓存规则，客户端根据缓存规则缓存新的数据
实现对比缓存一般有两种方式
通过最后修改时间来判断缓存是否可用
let http= require('http');
let url= require('url');
let path= require('path');
let fs= require('fs');
let mime= require('mime');
// http://localhost:8080/index.html
http.createServer(function(req, res){
let{ pathname}= url.parse(req.url, true);
//D:\vipcode\201801\20.cache\index.html
let filepath= path.join(__dirname, pathname);
fs.stat(filepath,(err, stat)=>{
if(err){
return sendError(req, res);
} else{
let ifModifiedSince= req.headers['if-modified-since'];
let LastModified= stat.ctime.toGMTString();
if(ifModifiedSince== LastModified){
res.writeHead(304);
res.end('');
} else{
return send(req, res, filepath, stat);
}
}
});
}).listen(8080);
function sendError(req, res){
res.end('Not Found');
}
function send(req, res, filepath, stat){
res.setHeader('Content-Type', mime.getType(filepath));
//发给客户端之后，客户端会把此时间保存起来，下次再获取此资源的时候会把这个时间再发回服务器
res.setHeader('Last-Modified', stat.ctime.toGMTString());
fs.createReadStream(filepath).pipe(res);
}这种方式有很多缺陷
某些服务器不能精确得到文件的最后修改时间，这样就无法通过最后修改时间来判断文件是否更新了
某些文件的修改非常频繁，在秒以下的时间内进行修改.Last-Modified只能精确到秒。
一些文件的最后修改时间改变了，但是内容并未改变。我们不希望客户端认为这个文件修改了
如果同样的一个文件位于多个CDN服务器上的时候内容虽然一样，修改时间不一样
ETag
ETag是根据实体内容生成的一段hash字符串,可以标识资源的状态
资源发生改变时，ETag也随之发生变化。 ETag是Web服务端产生的，然后发给浏览器客户端
let http= require('http');
let url= require('url');
let path= require('path');
let fs= require('fs');
let mime= require('mime');
let crypto= require('crypto');
http.createServer(function(req, res){
let{ pathname}= url.parse(req.url, true);
let filepath= path.join(__dirname, pathname);
fs.stat(filepath,(err, stat)=>{
if(err){
return sendError(req, res);
} else{
let ifNoneMatch= req.headers['if-none-match'];
let out= fs.createReadStream(filepath);
let md5= crypto.createHash('md5');
out.on('data', function(data){
md5.update(data);
});
out.on('end', function(){
let etag= md5.digest('hex');
let etag= `${stat.size}`;
if(ifNoneMatch== etag){
res.writeHead(304);
res.end('');
} else{
return send(req, res, filepath, etag);
}
});
}
});
}).listen(8080);
function sendError(req, res){
res.end('Not Found');
}
function send(req, res, filepath, etag){
res.setHeader('Content-Type', mime.getType(filepath));
res.setHeader('ETag', etag);
fs.createReadStream(filepath).pipe(res);
}客户端想判断缓存是否可用可以先获取缓存中文档的ETag，然后通过If-None-Match发送请求给Web服务器询问此缓存是否可用。
服务器收到请求，将服务器的中此文件的ETag,跟请求头中的If-None-Match相比较,如果值是一样的,说明缓存还是最新的,Web服务器将发送304 Not Modified响应码给客户端表示缓存未修改过，可以使用。
如果不一样则Web服务器将发送该文档的最新版本给浏览器客户端
实现强制缓存
把资源缓存在客户端，如果客户端再次需要此资源的时候，先获取到缓存中的数据，看是否过期，如果过期了。再请求服务器
如果没过期，则根本不需要向服务器确认，直接使用本地缓存即可
let http= require('http');
let url= require('url');
let path= require('path');
let fs= require('fs');
let mime= require('mime');
let crypto= require('crypto');
http.createServer(function(req, res){
let{ pathname}= url.parse(req.url, true);
let filepath= path.join(__dirname, pathname);
console.log(filepath);
fs.stat(filepath,(err, stat)=>{
if(err){
return sendError(req, res);
} else{
send(req, res, filepath);
}
});
}).listen(8080);
function sendError(req, res){
res.end('Not Found');
}
function send(req, res, filepath){
res.setHeader('Content-Type', mime.getType(filepath));
res.setHeader('Expires', new Date(Date.now()+ 30* 1000).toUTCString());
res.setHeader('Cache-Control','max-age=30');
fs.createReadStream(filepath).pipe(res);
}浏览器会将文件缓存到Cache目录，第二次请求时浏览器会先检查Cache目录下是否含有该文件，如果有，并且还没到Expires设置的时间，即文件还没有过期，那么此时浏览器将直接从Cache目录中读取文件，而不再发送请求
Expires是服务器响应消息头字段，在响应http请求时告诉浏览器在过期时间前浏览器可以直接从浏览器缓存取数据
Cache-Control与Expires的作用一致，都是指明当前资源的有效期，控制浏览器是否直接从浏览器缓存取数据还是重新发请求到服务器取数据,如果同时设置的话，其优先级高于Expires
下面开始写静态服务器
首先创建一个http服务，配置监听端口
let http= require('http');
let server= http.createServer();
server.on('request', this.request.bind(this));
server.listen(this.config.port,()=>{
怎样操作Node静态资源服务器
这次给大家带来怎样操作Node静态资源服务器，操作Node静态资源服务器的注意事项有哪些，下面就是实战案例，一起来看一下。
http服务器是继承自tcp服务器 http协议是应用层协议，是基于TCP的
http的原理是对请求和响应进行了包装，当客户端连接上来之后先触发connection事件，然后可以多次发送请求，每次请求都会触发request事件
let server= http.createServer();
let url= require('url');
server.on('connection', function(socket){
console.log('客户端连接');
});
server.on('request', function(req, res){
let{ pathname, query}= url.parse(req.url, true);
let result= [];
req.on('data', function(data){
result.push(data);
});
req.on('end', function(){
let r= Buffer.concat(result);
res.end(r);
})
});
server.on('close', function(req, res){
console.log('服务器关闭');
});
server.on('error', function(err){
console.log('服务器错误');
});
server.listen(8080, function(){
console.log('server started at http://localhost:8080');
});req代表客户端的连接，server服务器把客户端的请求信息进行解析，然后放在req上面
res代表响应，如果希望向客户端回应消息，需要通过 res
req和res都是从socket来的，先监听socket的data事件，然后等事件发生的时候，进行解析，解析出请头对象，再创建请求对象，再根据请求对象创建响应对象
req.url获取请求路径
req.headers请求头对象
接下来我们对一些核心功能进行讲解
深刻理解并实现压缩和解压
为什么要压缩呢？有什么好处?
可以使用zlib模块进行压缩及解压缩处理,压缩文件以后可以减少体积，加快传输速度和节约带宽代码
压缩和解压缩对象都是transform转换流，继承自duplex双工流即可读可写流
zlib.createGzip：返回Gzip流对象，使用Gzip算法对数据进行压缩处理
zlib.createGunzip：返回Gzip流对象，使用Gzip算法对压缩的数据进行解压缩处理
zlib.createDeflate：返回Deflate流对象，使用Deflate算法对数据进行压缩处理
zlib.createInflate：返回Deflate流对象，使用Deflate算法对数据进行解压缩处理
实现压缩和解压
因为压缩我文件可能很大也可能很小，所以为了提高处理速度，我们用流来实现
let fs= require("fs");
let path= require("path");
let zlib= require("zlib");
function gzip(src){
fs
.createReadStream(src)
.pipe(zlib.createGzip())
.pipe(fs.createWriteStream(src+".gz"));
}
gzip(path.join(dirname,'msg.txt'));
function gunzip(src){
fs
.createReadStream(src)
.pipe(zlib.createGunzip())
.pipe(
fs.createWriteStream(path.join(dirname, path.basename(src,".gz")))
);
}
gunzip(path.join(dirname,"msg.txt.gz"));gzip方法用于实现压缩
gunzip方法用于实现解压
其中文件msg.txt是同级目录
为什么需要这么写：gzip(path.join(dirname,'msg.txt'));
因为console.log(process.cwd());打印出当前工作目录是根目录，并不是文件所在目录，如果这么写gzip('msg.txt');找不到文件就会报错
basename从一个路径中得到文件名，包括扩展名的，可以传一个扩展名参数，去掉扩展名
extname获取扩展名
压缩的格式和解压的格式需要对上，否则会报错
有些时候我们拿到的字符串不是一个流，那怎么解决呢
let zlib=require('zlib');
let str='hello';
zlib.gzip(str,(err,buffer)=>{
console.log(buffer.length);
zlib.unzip(buffer,(err,data)=>{
console.log(data.toString());
})
});有可能压缩后的内容比原来还大，要是内容太少的话，压缩也没什么意义了
文本压缩的效果会好一点，因为有规律
在http中应用压缩和解压
下面实现这样一个功能，如图：
客户端向服务器发起请求的时候，会通过accept-encoding(比如：Accept-Encoding:gzip,default)告诉服务器我支持的解压缩的格式
服务器端需要根据Accept-Encoding显示的格式进行压缩，没有的格式就不能压缩，因为浏览器无法解压
如果客户端需要的Accept-Encoding中的格式服务端没有，也无法实现压缩
let http= require("http");
let path= require("path");
let url= require("url");
let zlib= require("zlib");
let fs= require("fs");
let{ promisify}= require("util");
let mime= require("mime");
//把一个异步方法转成一个返回promise的方法
let stat= promisify(fs.stat);
http.createServer(request).listen(8080);
async function request(req, res){
let{ pathname}= url.parse(req.url);
let filepath= path.join(dirname, pathname);
// fs.stat(filepath,(err,stat)=>{});现在不这么写了，异步的处理起来比较麻烦
try{
let statObj= await stat(filepath);
res.setHeader("Content-Type", mime.getType(pathname));
let acceptEncoding= req.headers["accept-encoding"];
if(acceptEncoding){
if(acceptEncoding.match(/\bgzip\b/)){
res.setHeader("Content-Encoding","gzip");
fs
.createReadStream(filepath)
.pipe(zlib.createGzip())
.pipe(res);
} else if(acceptEncoding.match(/\bdeflate\b/)){
res.setHeader("Content-Encoding","deflate");
fs
.createReadStream(filepath)
.pipe(zlib.createDeflate())
.pipe(res);
} else{
fs.createReadStream(filepath).pipe(res);
}
} else{
fs.createReadStream(filepath).pipe(res);
}
} catch(e){
res.statusCode= 404;
res.end("Not Found");
}
}mime：通过文件的名称、路径拿到一个文件的内容类型，可以根据不同的文件内容类型返回不同的Content-Type
acceptEncoding：全部写成小写是为了兼容不同的浏览器，node把所有的请求头全转成了小写
filepath：得到文件的绝对路径
启动服务后，访问http://localhost:8080/msg.txt可看到结果
深刻理解并实现缓存
为什么要缓存呢，缓存有什么好处？
减少了冗余的数据传输，节省了网费。
减少了服务器的负担，大大提高了网站的性能
加快了客户端加载网页的速度
缓存的分类
强制缓存：
强制缓存，在缓存数据未失效的情况下，可以直接使用缓存数据
在没有缓存数据的时候，浏览器向服务器请求数据时，服务器会将数据和缓存规则一并返回，缓存规则信息包含在响应header中
对比缓存：
浏览器第一次请求数据时，服务器会将缓存标识与数据一起返回给客户端，客户端将二者备份至缓存数据库中
再次请求数据时，客户端将备份的缓存标识发送给服务器，服务器根据缓存标识进行判断，判断成功后，返回304状态码，通知客户端比较成功，可以使用缓存数据
两类缓存的区别和联系
强制缓存如果生效，不需要再和服务器发生交互，而对比缓存不管是否生效，都需要与服务端发生交互
两类缓存规则可以同时存在，强制缓存优先级高于对比缓存，也就是说，当执行强制缓存的规则时，如果缓存生效，直接使用缓存，不再执行对比缓存规则
实现对比缓存
实现对比缓存一般是按照以下步骤：
第一次访问服务器的时候，服务器返回资源和缓存的标识，客户端则会把此资源缓存在本地的缓存数据库中。
第二次客户端需要此数据的时候，要取得缓存的标识，然后去问一下服务器我的资源是否是最新的。
如果是最新的则直接使用缓存数据，如果不是最新的则服务器返回新的资源和缓存规则，客户端根据缓存规则缓存新的数据
实现对比缓存一般有两种方式
通过最后修改时间来判断缓存是否可用
let http= require('http');
let url= require('url');
let path= require('path');
let fs= require('fs');
let mime= require('mime');
// http://localhost:8080/index.html
http.createServer(function(req, res){
let{ pathname}= url.parse(req.url, true);
//D:\vipcode\201801\20.cache\index.html
let filepath= path.join(dirname, pathname);
fs.stat(filepath,(err, stat)=>{
if(err){
return sendError(req, res);
} else{
let ifModifiedSince= req.headers['if-modified-since'];
let LastModified= stat.ctime.toGMTString();
if(ifModifiedSince== LastModified){
res.writeHead(304);
res.end('');
} else{
return send(req, res, filepath, stat);
}
}
});
}).listen(8080);
function sendError(req, res){
res.end('Not Found');
}
function send(req, res, filepath, stat){
res.setHeader('Content-Type', mime.getType(filepath));
//发给客户端之后，客户端会把此时间保存起来，下次再获取此资源的时候会把这个时间再发回服务器
res.setHeader('Last-Modified', stat.ctime.toGMTString());
fs.createReadStream(filepath).pipe(res);
}这种方式有很多缺陷
某些服务器不能精确得到文件的最后修改时间，这样就无法通过最后修改时间来判断文件是否更新了
某些文件的修改非常频繁，在秒以下的时间内进行修改.Last-Modified只能精确到秒。
一些文件的最后修改时间改变了，但是内容并未改变。我们不希望客户端认为这个文件修改了
如果同样的一个文件位于多个CDN服务器上的时候内容虽然一样，修改时间不一样
ETag
ETag是根据实体内容生成的一段hash字符串,可以标识资源的状态
资源发生改变时，ETag也随之发生变化。 ETag是Web服务端产生的，然后发给浏览器客户端
let http= require('http');
let url= require('url');
let path= require('path');
let fs= require('fs');
let mime= require('mime');
let crypto= require('crypto');
http.createServer(function(req, res){
let{ pathname}= url.parse(req.url, true);
let filepath= path.join(dirname, pathname);
fs.stat(filepath,(err, stat)=>{
if(err){
return sendError(req, res);
} else{
let ifNoneMatch= req.headers['if-none-match'];
let out= fs.createReadStream(filepath);
let md5= crypto.createHash('md5');
out.on('data', function(data){
md5.update(data);
});
out.on('end', function(){
let etag= md5.digest('hex');
let etag= `${stat.size}`;
if(ifNoneMatch== etag){
res.writeHead(304);
res.end('');
} else{
return send(req, res, filepath, etag);
}
});
}
});
}).listen(8080);
function sendError(req, res){
res.end('Not Found');
}
function send(req, res, filepath, etag){
res.setHeader('Content-Type', mime.getType(filepath));
res.setHeader('ETag', etag);
fs.createReadStream(filepath).pipe(res);
}客户端想判断缓存是否可用可以先获取缓存中文档的ETag，然后通过If-None-Match发送请求给Web服务器询问此缓存是否可用。
服务器收到请求，将服务器的中此文件的ETag,跟请求头中的If-None-Match相比较,如果值是一样的,说明缓存还是最新的,Web服务器将发送304 Not Modified响应码给客户端表示缓存未修改过，可以使用。
如果不一样则Web服务器将发送该文档的最新版本给浏览器客户端
实现强制缓存
把资源缓存在客户端，如果客户端再次需要此资源的时候，先获取到缓存中的数据，看是否过期，如果过期了。再请求服务器
如果没过期，则根本不需要向服务器确认，直接使用本地缓存即可
let http= require('http');
let url= require('url');
let path= require('path');
let fs= require('fs');
let mime= require('mime');
let crypto= require('crypto');
http.createServer(function(req, res){
let{ pathname}= url.parse(req.url, true);
let filepath= path.join(dirname, pathname);
console.log(filepath);
fs.stat(filepath,(err, stat)=>{
if(err){
return sendError(req, res);
} else{
send(req, res, filepath);
}
});
}).listen(8080);
function sendError(req, res){
res.end('Not Found');
}
function send(req, res, filepath){
res.setHeader('Content-Type', mime.getType(filepath));
res.setHeader('Expires', new Date(Date.now()+ 30* 1000).toUTCString());
res.setHeader('Cache-Control','max-age=30');
fs.createReadStream(filepath).pipe(res);
}浏览器会将文件缓存到Cache目录，第二次请求时浏览器会先检查Cache目录下是否含有该文件，如果有，并且还没到Expires设置的时间，即文件还没有过期，那么此时浏览器将直接从Cache目录中读取文件，而不再发送请求
Expires是服务器响应消息头字段，在响应http请求时告诉浏览器在过期时间前浏览器可以直接从浏览器缓存取数据
Cache-Control与Expires的作用一致，都是指明当前资源的有效期，控制浏览器是否直接从浏览器缓存取数据还是重新发请求到服务器取数据,如果同时设置的话，其优先级高于Expires
下面开始写静态服务器
首先创建一个http服务，配置监听端口
let http= require('http');
let server= http.createServer();
server.on('request', this.request.bind(this));
server.listen(this.config.port,()=>{
let url
关于静态资源服务器的内容到此结束，希望对大家有所帮助。