加入收藏 | 设为首页 | 会员中心 | 我要投稿 核心网 （https://www.hxwgxz.com/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 业界 > 正文

Node.js 原生 api 搭建 web 服务器

发布时间：2019-02-16 07:08:45 所属栏目：业界 来源：想不起来了
导读：node.js 实现一个简单的 web 服务器还是比较简单的，以前利用 express 框架实现过『nodeJS搭一个简单的(代理)web服务器』。代码量很少，可是使用时需要安装依赖，多处使用难免有点不方便。于是便有了完全使用原生 api 来重写的想法，也当作一次 node.js 复

服务器接收到 http 请求，首先处理代理列表 proxyTable，然后再处理静态资源。虽然这里面只有二个步骤，但如果按照先后顺序编码，这种方式显然不够灵活，，不利于以后功能的扩展。koa 框架的中间件就是一个很好的解决方案。完整代码如下：

  1. 'use strict' 
  2.  
  3. const http = require('http') 
  4. const url = require('url') 
  5. const fs = require('fs') 
  6. const path = require('path') 
  7. const cp = require('child_process') 
  8. // 处理静态资源 
  9. function processStatic(req, res) {   
  10.   const mime = { 
  11.     css: 'text/css', 
  12.     gif: 'image/gif', 
  13.     html: 'text/html', 
  14.     ico: 'image/x-icon', 
  15.     jpeg: 'image/jpeg', 
  16.     jpg: 'image/jpeg', 
  17.     js: 'text/javascript', 
  18.     json: 'application/json', 
  19.     pdf: 'application/pdf', 
  20.     png: 'image/png', 
  21.     svg: 'image/svg+xml', 
  22.     woff: 'application/x-font-woff', 
  23.     woff2: 'application/x-font-woff', 
  24.     swf: 'application/x-shockwave-flash', 
  25.     tiff: 'image/tiff', 
  26.     txt: 'text/plain', 
  27.     wav: 'audio/x-wav', 
  28.     wma: 'audio/x-ms-wma', 
  29.     wmv: 'video/x-ms-wmv', 
  30.     xml: 'text/xml' 
  31.   }   
  32.   const requestUrl = req.url   
  33.   let pathName = url.parse(requestUrl).pathname   
  34.   // 中文乱码处理 
  35.   pathName = decodeURI(pathName)   
  36.   let ext = path.extname(pathName)   
  37.   // 特殊 url 处理 
  38.   if (!pathName.endsWith('/') && ext === '' && !requestUrl.includes('?')) { 
  39.     pathName += '/' 
  40.     const redirect = `http://${req.headers.host}${pathName}` 
  41.     redirectUrl(redirect, res) 
  42.   }   
  43.   // 解释 url 对应的资源文件路径 
  44.   let filePath = path.resolve(__dirname + pathName)   
  45.   // 设置 mime  
  46.   ext = ext ? ext.slice(1) : 'unknown' 
  47.   const contentType = mime[ext] || 'text/plain' 
  48.  
  49.   // 处理资源文件 
  50.   fs.stat(filePath, (err, stats) => {     
  51.    if (err) { 
  52.       res.writeHead(404, { 'content-type': 'text/html;charset=utf-8' }) 
  53.       res.end('<h1>404 Not Found</h1>')       
  54.       return 
  55.     }    // 处理文件 
  56.     if (stats.isFile()) { 
  57.       readFile(filePath, contentType, res) 
  58.     }    // 处理目录 
  59.     if (stats.isDirectory()) {       
  60.       let html = "<head><meta charset = 'utf-8'/></head><body><ul>" 
  61.       // 遍历文件目录，以超链接返回，方便用户选择 
  62.       fs.readdir(filePath, (err, files) => {         
  63.         if (err) { 
  64.           res.writeHead(500, { 'content-type': contentType }) 
  65.           res.end('<h1>500 Server Error</h1>') 
  66.           return 
  67.         } else {          
  68.            for (let file of files) {             
  69.             if (file === 'index.html') {              
  70.               const redirect = `http://${req.headers.host}${pathName}index.html` 
  71.               redirectUrl(redirect, res) 
  72.             } 
  73.             html += `<li><a href='${file}'>${file}</a></li>` 
  74.           } 
  75.           html += '</ul></body>' 
  76.           res.writeHead(200, { 'content-type': 'text/html' }) 
  77.           res.end(html) 
  78.         } 
  79.       }) 
  80.     } 
  81.   }) 
  82. } 
  83. // 重定向处理 
  84. function redirectUrl(url, res) { 
  85.   url = encodeURI(url) 
  86.   res.writeHead(302, { 
  87.     location: url 
  88.   }) 
  89.   res.end() 
  90. } 
  91. // 文件读取 
  92. function readFile(filePath, contentType, res) { 
  93.   res.writeHead(200, { 'content-type': contentType }) 
  94.   const stream = fs.createReadStream(filePath) 
  95.   stream.on('error', function() { 
  96.     res.writeHead(500, { 'content-type': contentType }) 
  97.     res.end('<h1>500 Server Error</h1>') 
  98.   }) 
  99.   stream.pipe(res) 
  100. } 
  101. // 处理代理列表 
  102. function processProxy(req, res) { 
  103.   const requestUrl = req.url 
  104.   const proxy = Object.keys(proxyTable) 
  105.   let not_found = true 
  106.   for (let index = 0; index < proxy.length; index++) {     
  107.     const k = proxy[index]     
  108.     const i = requestUrl.indexOf(k)     
  109.     if (i >= 0) { 
  110.       not_found = false 
  111.       const element = proxyTable[k] 
  112.       const newUrl = element.target + requestUrl.slice(i + k.length) 
  113.  
  114.       if (requestUrl !== newUrl) { 
  115.         const u = url.parse(newUrl, true) 
  116.         const options = { 
  117.           hostname : u.hostname,  
  118.           port     : u.port || 80, 
  119.           path     : u.path,        
  120.           method   : req.method, 
  121.           headers  : req.headers, 
  122.           timeout  : 6000 
  123.         }; 
  124.         if(element.changeOrigin){ 
  125.           options.headers['host'] = u.hostname + ':' + ( u.port || 80) 
  126.         } 
  127.         const request =  
  128.           http.request(options, response => {                 
  129.             // cookie 处理 
  130.             if(element.changeOrigin && response.headers['set-cookie']){ 
  131.               response.headers['set-cookie'] = getHeaderOverride(response.headers['set-cookie']) 
  132.             } 
  133.             res.writeHead(response.statusCode, response.headers) 
  134.             response.pipe(res) 
  135.           }) 
  136.           .on('error', err => { 
  137.             res.statusCode = 503 
  138.             res.end() 
  139.           }) 
  140.         req.pipe(request) 
  141.       } 
  142.       break 
  143.     } 
  144.   } 
  145.   return not_found 
  146. } 
  147. function getHeaderOverride(value){ 
  148.   if (Array.isArray(value)) { 
  149.       for (var i = 0; i < value.length; i++ ) {         
  150.          value[i] = replaceDomain(value[i]) 
  151.       } 
  152.   } else { 
  153.       value = replaceDomain(value) 
  154.   } 
  155.   return value} 
  156. function replaceDomain(value) { 
  157.   return value.replace(/domain=[a-z.]*;/,'domain=.localhost;').replace(/secure/, '') 
  158. } 
  159. function compose (middleware) { 
  160.   if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')   
  161.   for (const fn of middleware) {     
  162.     if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!') 
  163.   }   
  164.   return function (context, next) { 
  165.     // 记录上一次执行中间件的位置     
  166.     let index = -1 
  167.     return dispatch(0)    
  168.     function dispatch (i) { 
  169.       // 理论上 i 会大于 index，因为每次执行一次都会把 i递增， 
  170.       // 如果相等或者小于，则说明next()执行了多次      
  171.       if (i <= index) return Promise.reject(new Error('next() called multiple times'))       
  172.       index = i 
  173.       let fn = middleware[i]       
  174.       if (i === middleware.length) fn = next 
  175.       if (!fn) return Promise.resolve()      
  176.       try {        
  177.         return Promise.resolve(fn(context, function next () {   
  178.            return dispatch(i + 1) 
  179.         })) 
  180.       } catch (err) {         
  181.          return Promise.reject(err) 
  182.       } 
  183.     } 
  184.   } 
  185. } 
  186. function Router(){   
  187.   this.middleware = [] 
  188. } 
  189. Router.prototype.use = function (fn){   
  190.   if (typeof fn !== 'function') throw new TypeError('middleware must be a function!') 
  191.   this.middleware.push(fn)  
  192.   return this} 
  193. Router.prototype.callback= function() {   
  194.   const fn = compose(this.middleware)   
  195.   const handleRequest = (req, res) => { 
  196.     const ctx = {req, res} 
  197.     return this.handleRequest(ctx, fn) 
  198.   } 
  199.   return handleRequest 
  200. } 
  201. Router.prototype.handleRequest= function(ctx, fn) { 
  202.   fn(ctx) 
  203. } 
  204.  
  205. // 代理列表 
  206. const proxyTable = { 
  207.   '/api': { 
  208.     target: 'http://127.0.0.1:8090/api', 
  209.     changeOrigin: true 
  210.   } 
  211. } 
  212.  
  213. const port = 8080 
  214. const hostname = 'localhost' 
  215. const appRouter = new Router() 
  216.  
  217. // 使用中间件 
  218. appRouter.use(async(ctx,next)=>{ 
  219.   if(processProxy(ctx.req, ctx.res)){ 
  220.     next() 
  221.   } 
  222. }).use(async(ctx)=>{ 
  223.   processStatic(ctx.req, ctx.res) 
  224. }) 
  225.  
  226. // 创建 http 服务 
  227. let httpServer = http.createServer(appRouter.callback()) 
  228.  
  229. // 设置监听端口 
  230. httpServer.listen(port, hostname, () => { 
  231.   console.log(`app is running at port:${port}`) 
  232.   console.log(`url: http://${hostname}:${port}`) 
  233.   cp.exec(`explorer http://${hostname}:${port}`, () => {}) 
  234. }) 

（编辑：核心网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
相关内容
    推荐文章
    站长推荐
    热点阅读

      【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

      建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

      Copygight © 2008-2022 https://www.hxwgxz.com/ All Rights Reserved. 核心网