Node.js(二)

1. Web开发概述

传统的动态网站开发需要应用软件

  • PHP ： Apache + php模块
  • java ：Tomcat 、Weblogic

Node.js : 不需要应用软件（可以自己实现）

Node.js服务器模型与php服务器模型的区别

image-20200710110513378

2. Node.js实现静态网站功能

2.1 使用http模块初步实现服务器功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
    初步实现服务器功能
*/
const http = require('http');
// 创建服务器实例对象
let server = http.createServer();
// 绑定请求事件
server.on('request', (req, res) => {
    res.end('hello');
});
// 监听端口
server.listen(3000);
-----------------------------

http.createServer((req, res) => {
    res.end('ok');
}).listen(3000, '127.0.0.1', () => {
    console.log('running...');
});

image-20200710111526161

image-20200710111627065

2.2 实现静态服务器功能

2.2.1 处理请求路径的分发

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
    处理请求路径的分发
    1、req对象是Class: http.IncomingMessage的实例对象
    2、res对象是Class: http.ServerResponse的实例对象
*/
const http = require('http');
http.createServer((req, res) => {
    // req.url可以获取URL中的路径（端口之后部分）
    // res.end(req.url);
    if (req.url.startsWith('/index')) {
        // write向客户端响应内容,可以写多次
        res.write('hello');
        res.write('hi');
        res.write('nihao');
        // end方法用来完成响应，只能执行一次
        res.end();
    } else if (req.url.startsWith('/about')) {
        res.end('about');
    } else {
        res.end('no content');
    }
}).listen(3000, '192.168.0.106', () => {
    console.log('running...');
});

2.2.2 响应完整的页面信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*
    响应完整的页面信息
*/
const http = require('http');
const path = require('path');
const fs = require('fs');

// 根据路径读取文件的内容，并且响应到浏览器端
let readFile = (url, res) => {
    fs.readFile(path.join(__dirname, 'www', url), 'utf8', (err, fileContent) => {
        if (err) {
            res.end('server error');
        } else {
            res.end(fileContent);
        }
    });
}

http.createServer((req, res) => {
    // 处理路径的分发
    if (req.url.startsWith('/index')) {
        readFile('index.html', res);
    } else if (req.url.startsWith('/about')) {
        readFile('about.html', res);
    } else if (req.url.startsWith('/list')) {
        readFile('list.html', res);
    } else {
        // 设置相应类型和编码
        res.writeHead(200, {
            'Content-Type': 'text/plain; charset=utf8'
        });
        res.end('页面被狗狗叼走了');
    }
}).listen(3000, '192.168.0.106', () => {
    console.log('running...');
});

2.2.3 单独封装方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
const path = require('path');
const fs = require('fs');
const mime = require('./mime.json');

exports.staticServer = (req, res, root) => {
    fs.readFile(path.join(root, req.url), (err, fileContent) => {
        if (err) {
            // 没有找到对应文件
            res.writeHead(404, {
                'Content-Type': 'text/plain; charset=utf8'
            });
            res.end('页面被狗狗叼走了');
        } else {
            let dtype = 'text/html';
            // 获取请求文件的后缀
            let ext = path.extname(req.url);
            // 如果请求的文件后缀合理，就获取到标准的响应格式
            if (mime[ext]) {
                dtype = mime[ext];
            }
            // 如果响应的内容是文本，就设置成utf8编码
            if (dtype.startsWith('text')) {
                dtype += '; charset=utf8'
            }
            // 设置响应头信息
            res.writeHead(200, {
                'Content-Type': dtype
            });
            res.end(fileContent);
        }
    });
}
--------------------------------------------------------------

const http = require('http');
const ss = require('./06.js');
const path = require('path');

http.createServer((req, res) => {
    // ss.staticServer(req,res,path.join(__dirname,'www'));
    ss.staticServer(req, res, path.join('C:\\Users\\www\\Desktop', 'test'));
}).listen(3000, () => {
    console.log('running....');
});

3. 参数传递与获取

3.1 url核心模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const url = require('url');
// 1. parse方法的作用就是把URL字符串转化为对象
let str = 'http://www.baidu.com/abc/qqq?flag=123&keyword=java';
let ret = url.parse(str, true);
console.log(ret.query.keyword); ->java

// 2. format的作用就是把对象转化为标准的URL字符串
let obj = {
    protocol: 'http:',
    slashes: true,
    auth: null,
    host: 'www.baidu.com',
    port: null,
    hostname: 'www.baidu.com',
    hash: null,
    search: '?flag=123&keyword=java',
    query: 'flag=123&keyword=java',
    pathname: '/abc/qqq',
    path: '/abc/qqq?flag=123&keyword=java',
    href: 'http://www.baidu.com/abc/qqq?flag=123&keyword=java'
};
let ret1 = url.format(obj);
console.log(ret1); ->http://www.baidu.com/abc/qqq?flag=123&keyword=java

3.2 get参数获取

1
2
3
4
5
6
7
8
9
10
const http = require('http');
const path = require('path');
const url = require('url');

http.createServer((req, res) => {
    let obj = url.parse(req.url, true);
    res.end(obj.query.username + '=========' + obj.query.password);
}).listen(3000, () => {
    console.log('running....');
});

3.3 post参数获取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
const querystring = require('querystring');
const http = require('http');

// parse方法的作用就是把字符串转成对象
let param = 'username=lisi&password=123';
// let param = 'foo=bar&abc=xyz&abc=123';
let obj = querystring.parse(param);
console.log(obj); ->[Object: null prototype] { username: 'lisi', password: '123' }
// stringify的作用就是把对象转成字符串
let obj1 = {
    flag: '123',
    abc: ['hello', 'hi']
};
let str1 = querystring.stringify(obj1);
console.log(str1); ->flag=123&abc=hello&abc=hi
-----------------------------------------------------
    
http.createServer((req, res) => {
    if (req.url.startsWith('/login')) {
        let pdata = '';
        req.on('data', (chunk) => {
            // 每次获取一部分数据
            pdata += chunk;
        });

        req.on('end', () => {
            // 这里才能得到完整的数据
            console.log(pdata);
            let obj = querystring.parse(pdata);
            res.end(obj.username + '-----' + obj.password);
        });
    }
}).listen(3000, () => {
    console.log('running...');
});

3.4 案例：登录验证功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Document</title>
</head>
<body>
    <form action="http://localhost:3000/login" method="post">
        用户名：<input type="text" name="username"><br>
        密码：<input type="password" name="password"><br>
        <input type="submit" value="提交">
    </form>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
/*
    登录验证功能
*/
const http = require('http');
const url = require('url');
const querystring = require('querystring');
const ss = require('./06.js');

http.createServer((req, res) => {
    // 启动静态资源服务
    if (req.url.startsWith('/www')) {
        ss.staticServer(req, res, __dirname);
    }
    console.log(req.url);
    // 动态资源
    if (req.url.startsWith('/login')) {
        // get请求
        if (req.method == 'GET') {
            let param = url.parse(req.url, true).query;
            if (param.username == 'admin' && param.password == '123') {
                res.end('get success');
            } else {
                res.end('get failure');
            }
        }
        // post请求
        if (req.method == 'POST') {
            let pdata = '';
            req.on('data', (chunk) => {
                pdata += chunk;
            });
            req.on('end', () => {
                let obj = querystring.parse(pdata);
                if (obj.username == 'admin' && obj.password == '123') {
                    res.end('post success');
                } else {
                    res.end('post failure');
                }
            });
        }
    }

}).listen(3000, () => {
    console.log('running....');
});

4. 动态网站开发

创建服务器实现动态网站效果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/*
    动态网站开发

    成绩查询功能
*/

const http = require('http');
const path = require('path');
const fs = require('fs');
const querystring = require('querystring');
const scoreData = require('./scores.json');

http.createServer((req, res) => {
    // 路由（请求路径+请求方式）
    // 查询成绩的入口地址 /query
    if (req.url.startsWith('/query') && req.method == 'GET') {
        fs.readFile(path.join(__dirname, 'view', 'index.tpl'), 'utf8', (err, content) => {
            if (err) {
                res.writeHead(500, {
                    'Content-Type': 'text/plain; charset=utf8'
                });
                res.end('服务器错误，请与管理员联系');
            }
            res.end(content);
        });
    } else if (req.url.startsWith('/score') && req.method == 'POST') {
        // 获取成绩的结果 /score
        let pdata = '';
        req.on('data', (chunk) => {
            pdata += chunk;
        });
        req.on('end', () => {
            let obj = querystring.parse(pdata);
            let result = scoreData[obj.code];
            fs.readFile(path.join(__dirname, 'view', 'result.tpl'), 'utf8', (err, content) => {
                if (err) {
                    res.writeHead(500, {
                        'Content-Type': 'text/plain; charset=utf8'
                    });
                    res.end('服务器错误，请与管理员联系');
                }
                // 返回内容之前要进行数据渲染
                content = content.replace('$$chinese$$', result.chinese);
                content = content.replace('$$math$$', result.math);
                content = content.replace('$$english$$', result.english);
                content = content.replace('$$summary$$', result.summary);

                res.end(content);
            });
        });
    }

}).listen(3000, () => {
    console.log('running....');
});
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
  "no123": {
    "chinese": "100",
    "math": "140",
    "english": "149",
    "summary": "289"
  },
  "no124": {
    "chinese": "120",
    "math": "120",
    "english": "119",
    "summary": "239"
  },
  "no125": {
    "chinese": "130",
    "math": "110",
    "english": "139",
    "summary": "269"
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>查询成绩</title>
</head>
<body>
    <form action="http://localhost:3000/score" method="post">
        请输入考号：<input type="text" name="code">
        <input type="submit" value="查询">
    </form>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>成绩结果</title>
</head>
<body>
    <div>
        <ul>
            <li>语文：$$chinese$$</li>
            <li>数学：$$math$$</li>
            <li>外语：$$english$$</li>
            <li>综合：$$summary$$</li>
        </ul>
    </div>
</body>
</html>

5. 模板引擎

模板引擎是为了使用户界面与业务数据（内容）分离而产生的，它可以生成一个标准的HTML结构。

模板+数据—>静态页面片段

流行的模板引擎:

image-20200710115010627

5.1 artTemplate

5.1.1 特性

  1. 性能卓越，执行速度通常是 Mustache 与 tmpl 的 20 多倍（性能测试）
  2. 支持运行时调试，可精确定位异常模板所在语句（演示）
  3. 对 NodeJS Express 友好支持
  4. 安全，默认对输出进行转义、在沙箱中运行编译后的代码（Node版本可以安全执行用户上传的模板）
  5. 支持include语句
  6. 可在浏览器端实现按路径加载模板（详情）
  7. 支持预编译，可将模板转换成为非常精简的 js 文件
  8. 模板语句简洁，无需前缀引用数据，有简洁版本与原生语法版本可选
  9. 支持所有流行的浏览器

5.1.2 安装

1
2
3
4
5
6
7
npm install art-template

// 使用
var template = require('art-template');
var data = {list: ["aui", "test"]};

var html = template(__dirname + '/index/main', data);

5.1.3 快速上手

5.1.3.1 编写模板

使用一个type="text/html"的script标签存放模板：

1
2
3
4
5
6
7
8
<script id="test" type="text/html">
    <h1>{ {title} }</h1>
    <ul>
        { {each list as value i} }
            <li>索引 { {i + 1} } ：{ {value} }</li>
        { {/each} }
    </ul>
</script>

5.1.3.2 渲染模板

1
2
3
4
5
6
7
8
9
10
var data = {
	title: '标签',
	list: ['文艺', '博客', '摄影', '电影', '民谣', '旅行', '吉他']
};
var html = template('test', data);
document.getElementById('content').innerHTML = html;

template的作用就是把模板和数据拼接到一块生成一个静态HTML片段，实际就是该方法的返回值
    参数一：模板id
    参数二：用来渲染的数据

5.1.4 模板语法

有两个版本的模板语法可以选择。

5.1.4.1 简洁语法

推荐使用，语法简单实用，利于读写。

1
2
3
4
5
6
7
{ {if admin} }
	{ {include 'admin_content'} }
	
	{ {each list} }
		<div>{ {$index} }. { {$value.user} }</div>
	{{/each}}
{ {/if} }

5.1.4.2 原生语法

1
2
3
4
5
6
7
< % if (admin){ % >
	< %include('admin_content')% >

	< %for (var i=0;i<list.length;i++) { % >
		<div>< % =i % >. < %=list[i].user % ></div>
	< % } % >
< % } % >

5.1.5 方法

5.1.5.1 template(id, data)

根据 id 渲染模板。内部会根据document.getElementById(id)查找模板。

如果没有 data 参数，那么将返回一渲染函数。

1
2
3
{ {if user} }
  <h2>{ {user.name} }</h2>
{ {/if} }
1
2
3
4
5
6
7
let template = require('art-template');
let html = template(__dirname + '/mytpl.art', {
    user: {
        name: 'lisi'
    }
});
console.log(html);

5.1.5.2 template.compile(source, options)

将返回一个渲染函数。

1
2
3
4
5
6
let tpl = '<ul>{ {each list as value} }<li>{ {value} }</li>{ {/each} }</ul>';
let render = template.compile(tpl);
let ret = render({
    list: ['apple', 'orange', 'banana']
});
console.log(ret);

5.1.5.3 template.render(source, options)

将返回渲染结果。

1
2
3
4
5
let tpl = '<ul>{ {each list} }<li>{ {$index} }-------------{ {$value} }</li>{ {/each} }</ul>';
let ret = template.render(tpl, {
    list: ['apple', 'orange', 'banana', 'pineapple']
});
console.log(ret);

5.1.5.4 template.helper(name, callback)

添加辅助方法。

5.1.5.5 template.config(name, value)

更改引擎的默认配置。

字段 类型 默认值 说明
openTag String '{ {' 逻辑语法开始标签
closeTag String "} }" 逻辑语法结束标签
escape Boolean true 是否编码输出 HTML 字符
cache Boolean true 是否开启缓存（依赖 options 的 filename 字段）
compress Boolean false 是否压缩 HTML 多余空白字符

6. Express

基于Node.js平台，快速、开放、极简的 Web 开发框架

6.1 Express之HelloWorld

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var express = require('express');
var app = express();

// 绑定路由
app.get('/', function (req, res) {
    // 响应请求
    res.send('Hello World!');
});

var server = app.listen(3000, "localhost", function () {
    // 监听的域名或者IP
    var host = server.address().address;
    // 监听的端口
    var port = server.address().port;
    console.log("Example app listening at http:// % s:% s", host, port);
});

6.2 初步实现服务器功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const express = require('express');
const app = express();
-----------------------------------
    
// 上面两行与下面一行代码等效
const app = require('express')();

app.get('/', (req, res) => {
    res.send('ok');
}).listen(3000, () => {
    console.log('running...');
});
----------------------------------

let server = app.get('/',(req,res)=>{
    res.send('abc');
});
server.listen(3000,()=>{
    console.log('running...');
});

6.3 托管静态文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
const express = require('express');
const app = express();

// 实现静态资源服务
// use方法的第一个参数可以指定一个虚拟路径
let server = app.use('/abc', express.static('public'));
app.use('/nihao', express.static('hello'));
server.listen(3000, () => {
    console.log('running...');
});
-----------------------------------
    
app.use('/abc',express.static('public'));
app.use('/nihao',express.static('hello'));
app.listen(3000,()=>{
    console.log('running...');
});

6.4 路由

根据请求路径和请求方式进行路径分发处理

1
2
3
4
5
6
7
http的常用请求方式：
    post   添加
    get    查询
    put    更新
    delete 删除

    restful api (一种URL的格式)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
const express = require('express');
const app = express();
const router = require('./myrouter.js');

// 直接使用use分发可以处理所有的路由请求
app.use((req, res) => {
    res.send('ok');
});
------------------------------

// all方法绑定的路由与请求方式无关
app.all('/abc', (req, res) => {
    res.end('test router');
});
------------------------------

// 基本的路由处理
app.get('/', (req, res) => {
    res.send('get data');
});

app.post('/', (req, res) => {
    res.send('post data');
});

app.put('/', (req, res) => {
    res.send('put data');
});

app.delete('/', (req, res) => {
    res.send('delete data');
});
----------------------------

// route方法可以指定特定的请求方式
app.route('/hello')
    .get((req, res) => {
        res.send('get data');
    }).post((req, res) => {
    res.send('post data');
});

app.use('/admin', router);

app.listen(3000, () => {
    console.log('running...');
});

myrouter.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const express = require('express');
const router = express.Router();

router.get('/hi', (req, res) => {
    res.send('hi router');
});

router.get('/hello', (req, res) => {
    res.send('hello router');
});

router.post('/abc', (req, res) => {
    res.send('abc router');
});

module.exports = router;

6.5 中间件

就是处理过程中的一个环节（本质上就是一个函数）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
const express = require('express');
const app = express();
let total = 0;

app.use((req, res, next) => {
    console.log('有人访问');
    // next方法的作用就是把请求传递到下一个中间件
    next()
});

app.use('/user', (req, res, next) => {
    // 记录访问时间
    console.log(Date.now());
    // next方法的作用就是把请求传递到下一个中间件
    next()
});

app.use('/user', (req, res, next) => {
    // 记录访问日志
    console.log('访问了/user');
    next()
});

app.use('/user', (req, res) => {
    total++;
    console.log(total);
    res.send('result');
});

app.listen(3000, () => {
    console.log('running...');
});

6.5.1 中间件的挂载方式和执行流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
const express = require('express');
const app = express();

app.get('/abc', (req, res, next) => {
    console.log(1);
    // next(); 走2
    // 跳转到下一个路由3，不走2
    next('route');
}, (req, res) => {
    console.log(2);
    res.send('abc');
});

app.get('/abc', (req, res) => {
    console.log(3);
    res.send('hello');
});
--------------------------------

var cb0 = function (req, res, next) {
    console.log('CB0');
    next();
}

var cb1 = function (req, res, next) {
    console.log('CB1');
    next();
}

var cb2 = function (req, res) {
    res.send('Hello from C!');
}

app.get('/example', [cb0, cb1, cb2]);

app.listen(3000, () => {
    console.log('running...');
});

6.6 参数处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
const express = require('express');
const app = express();
const bodyParser = require('body-parser')
// 挂载内置中间件
app.use(express.static('public'));

// 挂载参数处理中间件（post）
app.use(bodyParser.urlencoded({extended: false}));
// 处理json格式的参数
app.use(bodyParser.json());

// 处理get提交参数
app.get('/login', (req, res) => {
    let data = req.query;
    console.log(data);
    res.send('get data');
});

// 处理post提交参数
app.post('/login', (req, res) => {
    let data = req.body;
    // console.log(data);
    if (data.username == 'admin' && data.password == '123') {
        res.send('success');
    } else {
        res.send('failure');
    }
});

app.put('/login', (req, res) => {
    res.end('put data');
});

app.delete('/login', (req, res) => {
    res.end('delete data');
});

app.listen(3000, () => {
    console.log('running...');
});

6.7 模板引擎整合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
const express = require('express');
const path = require('path');
const template = require('art-template');
const app = express();

// 设置模板的路径
app.set('views', path.join(__dirname, 'views'));
// 设置模板引擎
app.set('view engine', 'art');

// 使express兼容art-template模板引擎
app.engine('art', require('express-art-template'));

app.get('/list', (req, res) => {
    let data = {
        title: '水果',
        list: ['apple', 'orange', 'banana']
    }
    // 参数一：模板名称；参数二：渲染模板的数据
    res.render('list', data);
});

app.listen(3000, () => {
    console.log('running...');
});

list.art

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>模板</title>
</head>
<body>
    <div>{ {title} }</div>
    <div>
        <ul>
            { {each list} }
                <li>{ {$value} }</li>
            { {/each} }
        </ul>
    </div>
</body>
</html>

7. Mysql API

7.1 封装操作数据库的通用api

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
const mysql = require('mysql');

exports.base = (sql, data, callback) => {
    // 创建数据库连接
    const connection = mysql.createConnection({
        host: 'localhost', // 数据库所在的服务器的域名或者IP地址
        user: 'root', // 登录数据库的账号
        password: 'root', // 登录数据库的密码
        database: 'book' // 数据库名称
    });
    // 执行连接操作
    connection.connect();

    // 操作数据库(数据库操作也是异步的)
    connection.query(sql, data, function (error, results, fields) {
        if (error) throw error;
        callback(results);
    });
    // 关闭数据库
    connection.end();
};

7.2 测试通用api

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
const db = require('./db.js');

// 插入操作
let sql = 'insert into book set ?';
let data = {
    name: '笑傲江湖',
    author: '金庸',
    category: '文学',
    description: '武侠小说'
}
db.base(sql, data, (result) => {
    console.log(result);
});
---------------------------------------
    
// 更新操作
let sql = 'update book set name=?,author=?,category=?,description=? where id=?';
let data = ['天龙八部', '金庸', '文学', '武侠小说', 11];
db.base(sql, data, (result) => {
    console.log(result);
});
---------------------------------------
    
// 删除操作
let sql = 'delete from book where id = ?';
let data = [11];
db.base(sql, data, (result) => {
    console.log(result);
});
---------------------------------------
    
// 查询操作
let sql = 'select * from book where id = ?';
let data = [8];
db.base(sql, data, (result) => {
    console.log(result[0].name);
});

8. 后台接口开发

8.1 json接口

1
2
3
4
5
6
7
// 指定api路径 allBooks (json接口)
app.get('/allBooks', (req, res) => {
    let sql = 'select * from book';
    db.base(sql, null, (result) => {
        res.json(result);
    });
});

8.2 jsonp接口

1
2
3
4
5
6
7
8
9
// 修改jsonp回调函数传递参数的key
app.set('jsonp callback name', 'cb');
// 指定api路径 allBooks （jsonp接口）
app.get('/allBooks', (req, res) => {
    let sql = 'select * from book';
    db.base(sql, null, (result) => {
        res.jsonp(result);
    });
});

8.3 restful接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*
    restful api  是从URL的格式来表述的
    get     http://localhost:3000/books
    get     http://localhost:3000/books/book
    post    http://localhost:3000/books/book
    get     http://localhost:3000/books/book/1
    put     http://localhost:3000/books/book
    delete  http://localhost:3000/books/book/2

    传统的URL风格
    http://localhost:3000/
    http://localhost:3000/toAddBook
    http://localhost:3000/addBook
    http://localhost:3000/toEditBook?id=1
    http://localhost:3000/editBook
    http://localhost:3000/deleteBook?id=2
*/
const express = require('express');
const db = require('./db.js');
const app = express();

app.get('/books', (req, res) => {
    let sql = 'select * from book';
    db.base(sql, null, (result) => {
        res.json(result);
    });
});

// http://localhost:3000/books/book/1
app.get('/books/book/:id', (req, res) => {
    let id = req.params.id;
    let sql = 'select * from book where id=?';
    let data = [id];
    db.base(sql, data, (result) => {
        res.json(result[0]);
    });
});

app.listen(3000, () => {
    console.log('running...');
});

9. 从服务器主动发送请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
    从服务器主动发送请求
    http.request(options[, callback])
*/

const http = require('http');
const path = require('path');
const fs = require('fs');

let options = {
    hostname: 'www.baidu.com',
    port: 80
}

let req = http.request(options, (res) => {
    let info = '';

    res.on('data', (chunk) => {
        info += chunk;
    });
    res.on('end', () => {
        fs.writeFile(path.join(__dirname, 'baidu.html'), info, (err) => {
            console.log('已经获取到百度主页的内容');
        });
    });
});

req.end();

9.1 查询数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
const http = require('http');

let options = {
    protocol: 'http:',
    hostname: 'localhost',
    port: 3000,
    path: '/books'
}

let req = http.request(options, (res) => {
    let info = '';

    res.on('data', (chunk) => {
        info += chunk;
    });
    res.on('end', () => {
        console.log(info);
    });
});

req.end();

9.2 添加数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const http = require('http');
const querystring = require('querystring');

let options = {
    protocol: 'http:',
    hostname: 'localhost',
    port: 3000,
    path: '/books/book',
    method: 'post',
    headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
    }
}

let req = http.request(options, (res) => {
    let info = '';

    res.on('data', (chunk) => {
        info += chunk;
    });
    res.on('end', () => {
        console.log(info);
    });
});

let data = querystring.stringify({
    name: 'adafa',
    author: 'asdfa',
    category: 'afdasf',
    description: 'adsfa'
});
req.write(data);
req.end();

9.3 根据id去查询数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const http = require('http');
const querystring = require('querystring');

let options = {
    protocol: 'http:',
    hostname: 'localhost',
    port: 3000,
    path: '/books/book/2',
    method: 'get'
}

let req = http.request(options, (res) => {
    let info = '';

    res.on('data', (chunk) => {
        info += chunk;
    });
    res.on('end', () => {
        console.log(info);
    });
});

req.end();

9.4 编辑数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
const http = require('http');
const querystring = require('querystring');

let options = {
    protocol: 'http:',
    hostname: 'localhost',
    port: 3000,
    path: '/books/book',
    method: 'put',
    headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
    }
}

let req = http.request(options, (res) => {
    let info = '';

    res.on('data', (chunk) => {
        info += chunk;
    });
    res.on('end', () => {
        console.log(info);
    });
});

let data = querystring.stringify({
    id: 34,
    name: 'ddddddddd',
    author: 'sssssssss',
    category: 'eeeeeeeee',
    description: 'gggggggg'
});
req.write(data);
req.end();

9.5 删除数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const http = require('http');
const querystring = require('querystring');

let options = {
    protocol: 'http:',
    hostname: 'localhost',
    port: 3000,
    path: '/books/book/34',
    method: 'delete'
}

let req = http.request(options, (res) => {
    let info = '';

    res.on('data', (chunk) => {
        info += chunk;
    });
    res.on('end', () => {
        console.log(info);
    });
});

req.end();

10. 调用第三方接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const http = require('http');
const querystring = require('querystring');

let cityCode = '101010300';
let options = {
    protocol: 'http:',
    hostname: 'www.weather.com.cn',
    port: 80,
    path: '/data/sk/' + cityCode + '.html',
    method: 'get'
}

let req = http.request(options, (res) => {
    let info = '';

    res.on('data', (chunk) => {
        info += chunk;
    });
    res.on('end', () => {
        console.log(info);
    });
});

req.end();


-------------本文结束感谢您的阅读-------------



本文作者： Wgy
本文标题： Node.js(二)
本文链接： https://wgy1993.gitee.io/archives/543e3a79.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

本站总访问量:

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

程序员的一天