NodeJs服务器
创建服务器
res.end()；里面的内容可以展示在定义的接口网页中。
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');
let server = http.createServer((req, res) => {
res.end("hello World")
})
server.listen(3000, "127.0.0.1", () => {
console.log("服务器正在运行...")
})
|
打开服务器，然后浏览器输入 127.0.0.1:3000 即可看到 hello World
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| const http = require('http');
let server = http.createServer();
server.listen(3000,"127.0.0.1",()=>{
console.log("服务器正在运行...");
})
server.on("request",(req,res)=>{
res.end("hello World!")
})
|
打开服务器，然后浏览器输入 127.0.0.1:3000 即可看到 hello World!
响应
给客户端响应的结果数据
在NodeJS创建的服务器上 我们可以响应一些内容 怎么把内容响应到浏览器上，涉及到响应的方法，肯定是response的方法
- response.write() 设置响应的内容，可以有多个，这种方式是直接写出数据，但是并没有关闭流；
- response.end() 响应结束的信号 ，只能有一个，这种方式是写出最后的数据，并且写出后会关闭流；
1
2
3
4
5
6
7
8
9
10
11
12
| const http = require("http");
const server = http.createServer((req, res) => {
res.write("one");
res.write("two");
res.end("last");
})
server.listen(3000, "0.0.0.0", () => {
console.log("server is running");
})
|
返回状态码
Http状态码（Http Status Code）是用来表示Http响应状态的数字代码；
- Http状态码非常多，可以根据不同的情况，给客户端返回不同的状态码；
- 常见的状态码：
| 状态码 |
状态描述 |
说明 |
| 200 |
OK |
客户端请求成功 |
| 400 |
Bad Request |
由于客户端请求有语法错误，不能被服务器所理解。 |
| 401 |
Unauthorized |
未授权的错误，必须携带请求的身份信息。 |
| 403 |
Forbidden |
客户端没有权限访问，被拒接。 |
| 404 |
Not Found |
请求的资源不存在，例如，输入了错误的URL。 |
| 500 |
Internal Server Error |
服务器发生不可预期的错误，导致无法完成客户端的请求。 |
| 503 |
Service Unavailable |
服务器不可用，可能处理维护或者重载状态，暂时无法访问。 |
设置状态码
- res.statusCode=200；
- res.writeHead(500);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| const http = require("http");
const server = http.createServer((req, res) => {
res.writeHead(500);
res.write("one");
res.write("two");
res.end("last");
})
server.listen(3000, "0.0.0.0", () => {
console.log("server is running");
})
|
响应头文件
设置响应的header；
返回头部信息，主要有两种方式：
- res.setHeader：一次写入一个头部信息；
- res.writeHead：同时写入header和status；
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");
const server = http.createServer((req, res) => {
res.setHeader("Content-type", "text/plain;charset=utf8");
res.writeHead(401,{
"Content-Type":"text/html;charset=utf8"
})
res.write("来啦");
res.write("<h2>作用</h2>");
res.end("last");
})
server.listen(3000, "0.0.0.0", () => {
console.log("server is running");
})
|
Header设置 Content-Type有什么作用呢？
- 设置为text/html时,可以解析html标签；
- 设置header为charset=utf8,中文就不会乱码了;
- 等等
demo1: 通过设置writeHead()，来防止乱码，识别H5标签与设置状态码。
1
2
3
4
5
6
7
8
9
10
11
12
13
| const http = require("http");
let server = http.createServer().listen(3000, "127.0.0.1", () => {
console.log("服务器正在运行中...")
});
server.on("request", (req, res) => {
res.writeHead(200,{"Content-type":"text/html;charset=utf-8"})
res.write('<h1>hellow</h1>');
res.write('<h1>世界</h1>');
res.end("加油")
})
|
demo2：通过上述可知，可以用html标签，但是上述这样写有点乱，进而直接读取外部的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
| <!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<style>
* {
padding: 0;
margin: 0;
}
h1 {
background: red
}
p {
background: yellowgreen
}
</style>
</head>
<body>
<h1>this is h1</h1>
<p>this i p </p>
</body>
</html>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| const http = require('http');
const fs = require('fs');
const path = require('path');
let server = http.createServer().listen(3000, "127.0.0.1", () => {
console.log("服务器正在运行");
})
server.on("request", (req, res) => {
res.writeHead(200, {
"Content-type": "text/html"
});
let contents = fs.readFileSync(path.resolve(__dirname, './ce.html'), 'utf-8');
res.end(contents);
})
|
请求
request对象中封装了客户端给我们服务器传过来的所有信息:
- 请求路径：req.url
- 请求方式：req.method
- 请求头：req.headers
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| const http = require("http");
const server = http.createServer((req,res)=>{
console.log(req.url);
console.log(req.method);
console.log(req.headers);
res.end("hello server");
})
server.listen(3000,"0.0.0.0",()=>{
console.log("server is running");
})
|
如何通过不同的请求路由，做出不同响应呢？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| const http = require("http");
const server = http.createServer((req, res) => {
console.log(req.url);
console.log(req.url);
res.end("hello server");
})
server.listen(3000, "0.0.0.0", () => {
console.log("server is running");
})
|
上面我们发现：GET请求的参数会拼接到路径上,导致即使都是”/login”的路由，我们通过req.url获取到的内容也不相同；此时我们需要借助到url模块来进行路由的管理;借助querystring模块来进行参数的管理；
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
| const http = require("http");
const url = require("url");
const qs = require("querystring");
const server = http.createServer((req, res) => {
console.log(req.url);
const reqUrl = url.parse(req.url);
console.log(reqUrl);
const { pathname, query } = url.parse(req.url);
if (pathname === "/login") {
console.log(qs.parse(query));
res.end("欢迎回来！");
} else {
res.end("请注册~");
}
})
server.listen(3000, "0.0.0.0", () => {
console.log("server is running");
})
|
demo：如果路径是index.html则将ce.html的界面渲染上去；如果是别的路径，则将notFound.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
| const http = require("http");
const fs = require("fs");
const path = require("path");
const url = require("url");
let server = http.createServer().listen(3000, "127.0.0.1", () => {
console.log("服务器正在运行...")
})
server.on("request", (req, res) => {
let reqUrl = url.parse(req.url).pathname;
if (reqUrl == "/favicon.ico") {
return false;
}
if (reqUrl == "/index.html") {
res.writeHead(200, {
"Content-type": "text/html"
});
res.end(thePath("./ce.html"))
} else {
res.writeHead(404, {
"Content-type": "text/html"
});
res.end(thePath("./notFound.html"))
}
})
function thePath(absolutePath) {
return fs.readFileSync(path.resolve(__dirname, absolutePath), "utf-8");
}
|
如何获取post请求body中的数据呢？
- 监听数据：req.on(“data”,(data)=>{})；
- 监听数据结束：req.on(“end”, () => {})；
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
| const http = require("http");
const url = require("url");
const qs = require("querystring");
const server = http.createServer((req, res) => {
const { pathname } = url.parse(req.url);
if (pathname === "/login") {
if (req.method == "POST") {
req.on("data", (data) => {
console.log(data.toString());
const { username, password } = JSON.parse(data.toString());
console.log(username, password);
})
}
}
res.end("hello world");
})
server.listen(3000, "0.0.0.0", () => {
console.log("server is running");
})
|
通过 req.headers获取到的headers对象属性；
在request对象的header中也包含很多有用的信息，客户端会默认传递过来一些信息：
1
2
3
4
5
6
7
8
9
10
11
| {
'content-type': 'application/json',
'user-agent': 'PostmanRuntime/7.30.0',
accept: '*/*',
'cache-control': 'no-cache',
'postman-token': '93700e4a-9978-4771-993a-8ecc016d0db5',
host: '127.0.0.1:3000',
'accept-encoding': 'gzip, deflate, br',
connection: 'keep-alive',
'content-length': '50'
}
|
content-type是这次请求携带的数据的类型：
- application/json表示是一个json类型；
- text/plain表示是文本类型
- application/xml表示是xml类型；
- multipart/form-data表示是上传文件；
content-length：文件的大小和长度；
connection:keep-alive：
- http是基于TCP协议的，但是通常在进行一次请求和响应结束后会立刻中断；
- 在http1.1中，所有连接默认是 connection: keep-alive的；
- 不同的Web服务器会有不同的保持 keep-alive的时间；
- Node中默认是5s中；
accept-encoding：告知服务器，客户端支持的文件压缩格式，比如js文件可以使用gzip编码，对应 .gz文件；
accept：告知服务器，客户端可接受文件的格式类型；
user-agent：客户端相关的信息；
登录注册案例
仅仅是个小案例，好多没有限制，比如相同的用户名禁止注册。。。
- 数组方法 find() 返回数组中第一个符合的元素的值(并且不检查剩余值)；参数：(item,index,arr)；找不到返回undefined。
- 异步写入writeFile：相对于同步，多了一个回调函数，内置一个参数err，用于返回错误。
1
2
3
4
5
6
7
8
9
10
11
12
13
| <div id="app">
<form action="http://127.0.0.1:3000/login" method="GET">
<div>
用户名:<input type="text" name="username">
</div>
<div>
密码:<input type="password" name="password">
</div>
<div>
<input type="submit" value="登录" id="btn">
</div>
</form>
|
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
| [{
"id": 1,
"username": "张三",
"password": 123456,
"isBloack": false
}, {
"id": 2,
"username": "李四",
"password": 123456,
"isBloack": false
}, {
"id": 3,
"username": "王五",
"password": 123456,
"isBloack": true
}, {
"username": "fwd",
"password": "123321",
"id": 4,
"isBloack": false
}, {
"username": "AAS",
"password": "321",
"id": 5,
"isBloack": false
}]
|
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
| const http = require("http");
const fs = require("fs");
const path = require("path");
const url = require("url");
const qs = require("querystring");
let server = http.createServer().listen(3000, "127.0.0.1", () => {
console.log("服务器正在运行...");
})
server.on("request", (req, res) => {
let requestUrl = url.parse(req.url).pathname;
if(requestUrl=="/register.html"){
res.writeHead(200,{'Content-type':'text/html;charset=utf-8'});
res.end(thePath("./register.html"))
}else if(requestUrl=="/login.html"){
res.writeHead(200,{'Content-type':'text/html;charset=utf-8'});
res.end(thePath("./login.html"))
}else if (requestUrl == "/add") {
res.writeHead(200,{'Content-type':'text/html;charset=utf-8'});
let reqUrl = url.parse(req.url).query;
let qsResult = qs.parse(reqUrl);
let jsonArr = JSON.parse(thePath("./member.json"));
qsResult.id = jsonArr[jsonArr.length - 1].id + 1,
qsResult.isBloack = false;
jsonArr.push(qsResult);
fs.writeFile(path.resolve(__dirname,"./member.json"), JSON.stringify(jsonArr), {
flag: "w",
encoding: "utf-8"
}, error=>{
if (error) res.end("<script>alert('注册失败');location.href='http://127.0.0.1:3000/register.html'</script>");
else res.end("<script>alert('注册成功');location.href='http://127.0.0.1:3000/login.html'</script>");
})
}else if (requestUrl=="/login"){
res.writeHead(200,{'Content-type':'text/html;charset=utf-8'})
let reqUrl = url.parse(req.url).query;
let qsResult = qs.parse(reqUrl);
let {username,password}=qsResult;
let jsonArr = JSON.parse(thePath("./member.json"));
let loginResult = jsonArr.find(item=>{
return item.username==username;
})
if(loginResult==undefined){
res.end("<script>alert('用户不存在');location.href='http://127.0.0.1:3000/register.html'</script>")
}else{
if (loginResult.isBloack==true){
res.end("<script>alert('账户已被拉黑');location.href='http://127.0.0.1:3000/register.html'</script>")
}else{
if(loginResult.password!=password){
res.end("<script>alert('密码错误');location.href='http://127.0.0.1:3000/register.html'</script>")
}else{
res.end("<script>alert('登陆成功');location.href='http://127.0.0.1:3000/register.html'</script>")
}
}
}
}
})
function thePath(absolutePath) {
return fs.readFileSync(path.resolve(__dirname, absolutePath), "utf-8");
}
|
