ejs koa

2018-08-25 601

ejs

简介

中文官网 https://ejs.bootcss.com/
npm https://www.npmjs.com/package/ejs
github https://github.com/mde/ejs
官网 http://ejs.co/

安装

 npm install --save ejs

下面接着创建package.json

npm init

继续安装koa

网址 https://koa.bootcss.com/
github https://github.com/koajs/koa
官网 https://koajs.com/
npm https://www.npmjs.com/package/koa

npm --install --save koa

koa2基础

架设http服务器

const koa = require('koa');
const app = new koa();

app.listen(3000);

输入网址 http://127.0.0.1:3000/ 即可完成假设

输出hello world

const koa = require('koa');
const app = new koa();

const main = ctx => {
    ctx.response.body = "hello world";
}

app.use(main);
app.listen(3000);

上方是回调，将会使用main，main进行回调一个匿名函数，完成body的设置。

ctx.response

代表着一个http的请求

不同的请求返回不同的类型

const koa = require('koa');
const app = new koa();

const main = ctx => {
    if (ctx.request.accepts('xml')) {
        ctx.response.type = 'xml';
        ctx.response.body = '<data>hello world</data>';
    } else if (ctx.request.accepts('json')) {
        ctx.response.type = 'json';
        ctx.response.body = {'data': 'hello world'};
    } else if (ctx.request.accepst('html')) {
        ctx.response.type = 'html';
        ctx.response.body = '<p>hello world</p>'
    } else {
        ctx.response.type = 'text';
        ctx.response.body = 'hello world';
    }
}

app.use(main);
app.listen(3000);

ps 使用https://www.getpostman.com/ 编辑http请求，发送http请求

即可完成。

网页模板

使用fs模块，使用流，将客户端和文件之间建立流的关系，然后将其对接

const koa = require('koa');
const fs = require('fs');
const app = new koa();

const main = ctx => {
    ctx.response.type = 'html';
     ctx.response.body = fs.createReadStream('./index.html');    // 创建一个流，将流进行对接
}

app.use(main);
app.listen(3000);

路由

ctx.request.path

ctx.request.path 外加if语句实现路由

使用koa-route

继续下载

npm install --save koa-route

编写代码

const koa = require('koa');
const route = require('koa-route');
const app = new koa();

const about = ctx => {
    ctx.response.type = 'html';
    ctx.response.body = '<h2>hello world</h2>'
}

const main = ctx => {
    ctx.response.type = 'html';
    ctx.response.body = 'hello world'
}

app.use(route.get('/', main));
app.use(route.get('/about', about));
app.listen(3000);

访问
http://127.0.0.1:3000/about
http://127.0.0.1:3000/
完成路由

静态资源

koa-static
npm https://www.npmjs.com/package/koa-static
接着下载安装

npm i koa-static

编写入口文件。

const koa = require('koa');
const app = new koa();
const server = require('koa-static');    // 静态资源
const route = require('koa-route');

const static = server(__dirname + '/public');
const about = ctx => {
    ctx.response.type = 'html';
    ctx.response.body = '<h2>hello world</h2>';
}

app.use(route.get('/about', about));
app.use(static);

app.listen(3000);

访问 http://127.0.0.1:3000/1.png 将会返回public下的1.png文件
访问 http://127.0.0.1:3000/about 将会被路由进行捕获

重定向

const koa = require('koa');
const app = new koa();
const server = require('koa-static');    // 静态资源
const route = require('koa-route');

const static = server(__dirname + '/public');
const about = ctx => {
    ctx.response.type = 'html';
    ctx.response.body = '<h2>hello world</h2>';
}
const redirect = ctx => {
    ctx.response.redirect('/');
    ctx.response.body = '<a href="/">Index Page</a>'
};

app.use(route.get('/about', about));
app.use(route.get('/redirect', redirect));
app.use(static);

app.listen(3000);

上方完成了一次页面的跳转

中间件

const koa = require('koa');
const app = new koa();
const server = require('koa-static');    // 静态资源
const route = require('koa-route');

const static = server(__dirname + '/public');
const about = ctx => {
    ctx.response.type = 'html';
    ctx.response.body = '<h2>hello world</h2>';
}
const redirect = ctx => {
    ctx.response.redirect('/');
    ctx.response.body = '<a href="/">Index Page</a>'
};
const main = ctx => {
    ctx.response.body = 'hello world';
}

// 中间件
const logger = (ctx, next) => {
    console.log('info!')
    next();    // 继续调用下一个中间件
}
app.use(logger);
app.use(route.get('/', main));
app.use(route.get('/about', about));
app.use(route.get('/redirect', redirect));
app.use(static);

app.listen(3000);

上方的加载所有的都会使用一个中间件

中间件栈

中间件栈实现的是一个先进后出

PS C:\Users\mingm\Desktop\ejs> node index.js
> one
> two
> three
< three
< two
< one

const koa = require('koa');
const app = new koa();
const server = require('koa-static');    // 静态资源
const route = require('koa-route');

const static = server(__dirname + '/public');
const about = ctx => {
    ctx.response.type = 'html';
    ctx.response.body = '<h2>hello world</h2>';
}
const redirect = ctx => {
    ctx.response.redirect('/');
    ctx.response.body = '<a href="/">Index Page</a>'
};
const main = ctx => {
    ctx.response.body = 'hello world';
}

// 中间件
const one = (ctx, next) => {
    console.log('> one');
    next();    // 装载下一个中间件
    console.log('< one');
}
const two = (ctx, next) => {
    console.log('> two');
    next();    
    console.log('< two');
}
const three = (ctx, next) => {
    console.log('> three');
    next();
    console.log('< three');
}
app.use(one);
app.use(two);
app.use(three);
app.use(route.get('/', main));
app.use(route.get('/about', about));
app.use(route.get('/redirect', redirect));
app.use(static);

app.listen(3000);

异步

是滴，node.js最重要的是异步，以及回调

es7的异步函数

一段代码直接说明

function resolveAfter2Seconds() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve('resolved');
      console.log('我是执行结果4')
    }, 2000);
  });
}

async function asyncCall() {
  console.log('calling');
  console.log('我是执行结果3')
  var result = await resolveAfter2Seconds();
  console.log(result);
  console.log('我是执行结果2');
  // expected output: 'resolved'
}

asyncCall();
console.log('我是执行结果1');

输出结果为

> "calling"
> "我是执行结果3"
> "我是执行结果1"
> "我是执行结果4"
> "resolved"
> "我是执行结果2"

运行过程为先运行函数asyncCall，接着输出calling和结果3，继续到await语句的时候，为一个回调的语句，此时主线程，因为遇到await语句，将会直接进行输出执行结果1的内容，等待着resolveAfter2Seconds后执行完毕，进行回调。（Promise 对象为一个暂时保存回调内容的一个对象）Promise对象将会暂时保存运行的结果，运行结果为结果4和resolved，等待执行完毕以后，将会把暂时保存的内容，赋值给result变量，由于此时已经执行完毕，将会继续运行下方的内容，输出result中的内容，result中的内容为异步的执行的内容，接着，输出结果2，完成运行。

koa2中运行异步

const koa = require('koa');
const fs = require('fs');
const app = new koa();
const server = require('koa-static');    // 静态资源
const route = require('koa-route');

// 路由处理函数
const static = server(__dirname + '/public');
const main = async ctx => {
  ctx.response.type = 'html';
  console.log('one one one one');
  ctx.response.body = await file();
  console.log('one one one');
};
// 异步函数
function file() {
    return new Promise((resolve, reject) => {
        fs.readFile('./index.html', 'utf8', (err, data) => {
            if (err) {
                reject(console.log(err));
            } else {
                resolve(data);
                console.log('one one');
            }
        })
    })
}
// 中间件
const one = async (ctx, next) => {
    console.log('one');
    await next();
    console.log('one one one one one one ')
}


app.use(one);
app.use(route.get('/', main));
console.log('one one one one one one ')
app.use(static);

app.listen(3000);

结果

oen one one one one
one
one one one one
one one
one one one
one one one one one one

所有的都要使用异步操作，
由于全部都是异步，将会先调用最后的一个，
接着调用中间件的内容。
由于中间件也为异步，将会继续异步main，
由于main也为异步，将会调用异步函数file中的内容。
接着，按照上面的顺序倒着回来，最后完成中间件

ps 由于中间件的异步，这样就成功的模拟的中间件的正常的模型

正常的中间件

const koa = require('koa');
const app = new koa();

const main = ctx => {
    ctx.response.type = 'html';
    console.log('3')
    ctx.response.body = '<h1>hello world</h1>'
    console.log('4');
};

const one = (ctx, next) => {
    console.log('info!');
    console.log('1')
    next();
    console.log('2')
}

app.use(one);
app.use(main);

app.listen(3000);

运行结果

info!
1
3
4
2

先进去，等到全部执行完成以后，在出来，中间件包裹着全部

不加异步的中间件

const koa = require('koa');
const fs = require('fs');
const app = new koa();
const server = require('koa-static');    // 静态资源
const route = require('koa-route');

// 路由处理函数
const static = server(__dirname + '/public');
const main = async ctx => {
  ctx.response.type = 'html';
  console.log('one one one one');
  ctx.response.body = await file();
  console.log('one one one');
};
// 异步函数
function file() {
    return new Promise((resolve, reject) => {
        fs.readFile('./index.html', 'utf8', (err, data) => {
            if (err) {
                reject(console.log(err));
            } else {
                resolve(data);
                console.log('one one');
            }
        })
    })
}
// 中间件
const one =  (ctx, next) => {
    console.log('one');
     next();
    console.log('one one one one one one ')
}


app.use(one);
app.use(route.get('/', main));
console.log('oen one one one one');
app.use(static);

app.listen(3000);

运行结果

oen one one one one
one
one one one one
one one one one one one
one one
one one one

可以发现，变现的'溢出'

中间件的合成

koa-compose

npm https://www.npmjs.com/package/koa-compose
下载安装
比较简单，看文档就行。

错误处理

同try类似使用throw抛出错误。

cookies

ctx.cookies 用来读取cookies客户端发送的cookies内容

const koa = require('koa');
const app = new koa();
const route = require('koa-route');

const main = (ctx) => {
    const n = Number(ctx.cookies.get('view') || 0) + 1;    // 获取客户端的cookice，如果不存在，直接取0，括号内的为一个选择语句，然后将其cookice进行加1操作
    ctx.cookies.set('view', n);    // 发送读取到的cookice
    ctx.response.type = 'html';
    ctx.response.body = n + 'views';     // 将结果输出
}

app.use(route.get('/', main));

app.listen(3000);

完成操作

表单操作

即post和get操作
继续使用模块 koa-body
github https://github.com/dlau/koa-body
npm https://www.npmjs.com/package/koa-body
安装

npm i koa-body

支持json格式数据的提交哦

const Koa = require('koa');
const koaBody = require('koa-body');

const app = new Koa();

const main = ctx => {
  ctx.body = JSON.stringify(ctx.request.body);
};

app.use(koaBody());
app.use(main);

app.listen(3000);

客户端发送

name=Jack

格式为

text/plain

返回的都为字符串
文件上传暂时搞不定。

ejs

需要先安装koa模板中间件

官网 https://www.npmjs.com/package/koa-views

npm install --save koa-views

index.js文件

const koa = require('koa');
const views = require('koa-views');
const path = require('path');
const app = new koa();

// 加载模板引擎
app.use(views(path.join(__dirname, './view'), { extension: 'ejs' }));

const main = async ctx => {
  let title = 'hello';
  await ctx.render('index', {title})
}
app.use(main);
app.listen(3000);

view下的index.ejs文件

<!doctype html>
<html>
<head>
    <title><%= title %></title>
</head>
<body>
<h1><%= title %></h1>
<p>hello world</p>
</body>
</html>

访问http://127.0.0.1:3000/
内容完成动态的更新

ps 上传文件还是不太会，无奈

微信关注我们

原文链接：https://yq.aliyun.com/articles/629140

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

分布式系统的架构思路

在互联网大行其道的今天，各种分布式系统已经司空见惯。搜索引擎、电商网站、微博、微信、O2O平台。。凡是涉及到大规模用户、高并发访问的，无一不是分布式。但不管那种业务，不管何种分布式系统，有一些基本的思想还是相通的。本文将对这些基本思想进行一个梳理汇总。分拆系统分拆微信的架构师说过一句话：“大系统小做“。对于一个大的复杂系统，首先想到的就是对其分拆，拆成多个子系统。每个子系统自己的存储/Service/接口层，各个子系统独立开发、测试、部署、运维。从团队管理角度讲，也可以不同团队用自己熟悉的语言体系，团队之间基于接口进行协作，职责清晰，各司其职。子系统分拆拆成子系统之后，子系统内部又可以分层，分模块。当然，这里“系统“，“子系统“，“层“，“模块“ 都只是一个相对概念。在一个系统里面，某个模块复杂到一定程度，会把它抽出来，单独做成一个系统；而在初期，很大简单模块，可能不回拆分，集中在一个系统里面。这就像一个生物组织，自身是在不断成长、演化、有分有合，不断变化发展的。存储分拆 Nosql：对于Nosql数据库，比如MongoDB，其天生就是分布式的，很容易实现数据的分片。 ...

2018-08-24

633

引言大家在面试的时候，是否遭遇过，面试官询问那这个问题应该怎么答呢？其实写这个题材的原因是我这几天看到各公众号转的一篇数据库调优的知识（不上链接了），我就稍微翻了几下，上面动不动就来说要对数据库进行水平拆分，我就想反问各位读者，你们几个人经历过水平拆分?现在很多文章，实践性实在太差，只能说纯理论分析。这篇文章最早来自知乎的一个提问，我在其基础上完善了一下。第一阶段优化sql和索引这才是调优的第一阶段啊，为什么呢？因为这一步成本最低啊，不需要加什么中间件。你没经过索引优化和SQL优化，就来什么水平拆分，这不是坑人么。那步骤是什么样呢?我说个大概 (1)用慢查询日志定位执行效率低的SQL语句 (2)用explain分析SQL的执行计划 (3)确定问题，采取相应的优化措施，建立索引啊，等我就不举例了，因为如何优化SQL的文章，一抓一大把，再贴过来，读者看着也累。第二阶段搭建缓存在优化sql无法解决问题的情况下，才考虑搭建缓存。毕竟你使用缓存的目的，就是将复杂的、耗时的、不常变的执行结果缓存起来，降低数据库的资源消耗。这里需要注意的是:搭建缓存后，系统的复杂性增加了。...

2018-08-25

586

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。