Study nodejs 「5」

nodejs实现定时任务#

用node-schedule这个模组去实现定时任务然后这边实现自动登录校园网的(，首先先bp抓个包，发现里面东西有点多，就写了一堆配置文件，然后包成docker去定时发送

config.js

1
const config = {
2
    loginUrl: 'http://ip/eportal/InterFace.do?method=login',
3
    userId: '',
4
    password: '',
5
    service: '中国移动',
6
    headers: {
7
        'User-Agent': '',
8
        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
9
        'Accept': '*/*',
10
        'Origin': '',
11
        'Referer': 'http://ip/eportal/index.jsp',
12
        'Cookie': 'EPORTAL_USER_GROUP=; EPORTAL_COOKIE_PASSWORD=; EPORTAL_COOKIE_DOMAIN=false; EPORTAL_COOKIE_USERNAME=; EPORTAL_COOKIE_SERVER=; EPORTAL_COOKIE_SERVER_NAME=; EPORTAL_COOKIE_SAVEPASSWORD=true; EPORTAL_COOKIE_OPERATORPWD='
13
    }
14
};
15

16
export default config;

index.js

1
import schedule from 'node-schedule';
2
import axios from 'axios';
3
import qs from 'qs';
4
import config from './config.js';
5
import fs from 'fs';
6
import path from 'path';
7
import { fileURLToPath } from 'url';
8

9
const __dirname = path.dirname(fileURLToPath(import.meta.url));
10
const logDir = path.join(__dirname, 'logs');
11

12
// 确保日志目录存在
13
if (!fs.existsSync(logDir)) {
14
    fs.mkdirSync(logDir);
15
}
16

17
// 日志函数
18
function log(message, isError = false) {
19
    const now = new Date();
20
    const dateStr = now.toISOString().split('T')[0];
21
    const timeStr = now.toLocaleString();
22
    const logMessage = `${timeStr} - ${message}\n`;
23

24
    // 控制台输出
25
    console.log(logMessage);
26

27
    // 写入文件
28
    const logFile = path.join(logDir, `${dateStr}.log`);
29
    fs.appendFileSync(logFile, logMessage);
30

31
    // 如果是错误，也写入错误日志
32
    if (isError) {
33
        const errorFile = path.join(logDir, `${dateStr}-error.log`);
34
        fs.appendFileSync(errorFile, logMessage);
35
    }
36
}
37

38
async function login() {
39
    try {
40
        const data = {
41
            userId: config.userId,
42
            password: config.password,
43
            service: config.service,
44
            queryString: qs.stringify({
45
                wlanuserip: '',
46
                wlanacname: '',
47
                ssid: '',
48
                nasip: '',
49
                snmpagentip: '',
50
                mac: '',
51
                t: '',
52
                url: '',
53
                apmac: '',
54
                nasid: '',
55
                vid: '',
56
                port: '',
57
                nasportid: ''
58
            }),
59
            operatorPwd: '',
60
            operatorUserId: '',
61
            validcode: '',
62
            passwordEncrypt: false
63
        };
64

65
        const response = await axios({
66
            method: 'post',
67
            url: config.loginUrl,
68
            headers: config.headers,
69
            data: qs.stringify(data)
70
        });
71

72
        log(`登录结果: ${JSON.stringify(response.data)}`);
73
    } catch (error) {
74
        log(`登录失败: ${error.message}`, true);
75
    }
76
}
77

78
// 每天早上7点执行登录
79
schedule.scheduleJob('0 7 * * *', login);
80

81
log('定时任务已启动，将在每天早上7点自动登录');
82

83
// 立即执行一次登录，测试配置是否正确
84
login();

感觉学校这边有点怪，甚至会判定是学生还是老师登录，这玩意还分的？网速不一样呗bro

dockerfile

1
FROM node:18-alpine
2

3
WORKDIR /app
4

5
COPY package*.json ./
6
RUN npm install
7

8
COPY . .
9

10
CMD ["node", "index.js"]

docker-compose.yml

1
version: '3'
2

3
services:
4
  campus-login:
5
    build: .
6
    container_name: campus-login
7
    restart: always
8
    environment:
9
      - TZ=Asia/Shanghai
10
    volumes:
11
      - ./config.js:/app/config.js
12
      - ./logs:/app/logs
13
    logging:
14
      driver: "json-file"
15
      options:
16
        max-size: "10m"
17
        max-file: "3"

然后就好了，只得一提的是Cron表达式，和linux的是一样的

1
*    *    *    *    *    *
2
┬    ┬    ┬    ┬    ┬    ┬
3
│    │    │    │    │    │
4
│    │    │    │    │    └── 星期（0 - 6，0表示星期日）
5
│    │    │    │    └───── 月份（1 - 12）
6
│    │    │    └────────── 日（1 - 31）
7
│    │    └─────────────── 小时（0 - 23）
8
│    └──────────────────── 分钟（0 - 59）
9
└───────────────────────── 秒（0 - 59）

文件上传#

这个问题其实很简单，就是前端向后端发送一个文件，后端接收到文件后，保存到指定位置，然后返回给前端一个状态码，表示上传成功或者失败。但是当文件很大时就会有一个问题，如果我网络突然崩了，再整体重新上传，那不就炸了吗？所以我们可以分段上传，比如一个文件被分成了十份，我在上传到最后一点时寄了，重新上传时只需上传最后一份即可

前端部分#

1
<input id="file" type="file"> <!--用来上传文件-->

定义chunks去切片文件切片 file 接受文件对象，注意file的底层是继承于blob的因此他可以调用blob的方法，slice进行切片，size就是每个切片的大小

1
const file = document.getElementById('file')
2
file.addEventListener('change', (event) => {
3
    const file = event.target.files[0] //获取文件信息
4
    const chunks = chunkFun(file)
5
    uploadFile(chunks)
6
})
7

8
const chunkFun = (file, size = 1024 * 1024 * 4) => {
9
    const chunks = []
10
    for (let i = 0; i < file.size; i += size) {
11
        chunks.push(file.slice(i, i + size))
12
    }
13
    return chunks
14
}

循环调用接口上传，并且存储一些信息，当前分片的索引，注意file必须写在最后一个，因为nodejs端的multer 会按照顺序去读的，不然读不到参数, 最后通过promise.all 并发发送请求，等待所有请求发送完成，通知后端合并切片

1
 const upload = (chunks) => {
2
            const list = []
3
            for (let i = 0; i < chunks.length; i++) {
4
                const formData = new FormData()
5
                formData.append('index', i)
6
                formData.append('filename', zsm)
7
                formData.append('flie', chunks[i])
8
                list.push(fetch('http://localhost:3000/upload', {
9
                    method: 'POST',
10
                    body: formData
11
                }))
12
            }
13
            Promise.all(list).then(res => {
14
                fetch('http://localhost:3000/merge', {
15
                    method: 'POST',
16
                    headers: {
17
                        'Content-Type': 'application/json'
18
                    },
19
                    body: JSON.stringify({
20
                        filename: zsm
21
                    })
22

23
                })
24
                console.log('上传成功')
25
            })
26
        }

node端#

比较值得注意的问题是上传时是分块的，所以我们需要合并，将分块的存入uploads，然后读取出来排序后再合并即可，严谨一点加点判断什么的

1
import express from 'express'
2
import multer from 'multer'
3
import cors from 'cors'
4
import fs from 'fs/promises'
5
import { existsSync, mkdirSync } from 'fs'
6
import path from 'path'
7

8
// 确保上传目录和视频目录存在
9
const uploadDir = path.join(process.cwd(), 'uploads')
10
const videoDir = path.join(process.cwd(), 'video')
11
    ;[uploadDir, videoDir].forEach(dir => {
12
        if (!existsSync(dir)) {
13
            mkdirSync(dir, { recursive: true })
14
        }
15
    })
16

17
const storage = multer.diskStorage({
18
    destination: function (req, file, cb) {
19
        cb(null, 'uploads/')
20
    },
21
    filename(req, file, cb) {
22
        cb(null, `${req.body.index}-${req.body.filename}`)
23
    }
24
})
25

26
// 添加文件过滤器
27
const fileFilter = (req, file, cb) => {
28
    // 记录文件信息
29
    console.log('上传文件信息:', {
30
        fieldname: file.fieldname,
31
        originalname: file.originalname,
32
        mimetype: file.mimetype,
33
        size: file.size
34
    })
35
    // 接受所有文件类型
36
    cb(null, true)
37
}
38

39
const upload = multer({
40
    storage,
41
    fileFilter,
42
    limits: {
43
        fileSize: 500 * 1024 * 1024, // 增加文件大小限制到500MB
44
    }
45
})
46

47
const app = express()
48
app.use(cors())
49
app.use(express.json())
50

51
// 错误处理中间件
52
const errorHandler = (err, req, res, next) => {
53
    console.error(err)
54
    res.status(500).json({ error: err.message || '服务器内部错误' })
55
}
56

57
app.post('/upload', upload.single('file'), (req, res) => {
58
    try {
59
        if (!req.file) {
60
            return res.status(400).json({ error: '没有接收到文件' })
61
        }
62
        res.json({ message: '文件上传成功' })
63
    } catch (error) {
64
        next(error)
65
    }
66
})
67

68
app.post('/merge', async (req, res, next) => {
69
    try {
70
        if (!req.body.filename) {
71
            return res.status(400).json({ error: '未提供文件名' })
72
        }
73

74
        const files = await fs.readdir(uploadDir)
75
        if (files.length === 0) {
76
            return res.status(400).json({ error: '没有找到需要合并的文件' })
77
        }
78

79
        // 排序
80
        files.sort((a, b) => parseInt(a.split('-')[0]) - parseInt(b.split('-')[0]))
81

82
        // 使用原始文件扩展名
83
        const fileExtension = path.extname(req.body.filename) || ''
84
        const outputPath = path.join(videoDir, `${req.body.filename}${fileExtension}`)
85

86
        // 使用 Promise.all 并行读取所有文件
87
        const fileContents = await Promise.all(
88
            files.map(file => fs.readFile(path.join(uploadDir, file)))
89
        )
90

91
        // 合并文件
92
        await fs.writeFile(outputPath, Buffer.concat(fileContents))
93

94
        // 清理临时文件
95
        await Promise.all(
96
            files.map(file => fs.unlink(path.join(uploadDir, file)))
97
        )
98

99
        res.json({
100
            message: '文件合并成功',
101
            path: outputPath,
102
            size: fileContents.reduce((acc, curr) => acc + curr.length, 0)
103
        })
104
    } catch (error) {
105
        next(error)
106
    }
107
})
108

109
app.use(errorHandler)
110

111
app.listen(3000, () => {
112
    console.log('server is running on port 3000')
113
})

文件流下载#

文件流下载是一种通过将文件内容以流的形式发送给客户端，实现文件下载的方法。它适用于处理大型文件或需要实时生成文件内容的情况。

前端实现#

1
<body>
2
    <button id="btn">下载文件</button>
3
    <script>
4
        const btn = document.getElementById('btn');
5
        btn.addEventListener('click', async () => {
6
            try {
7
                const response = await fetch('http://localhost:3000/download', {
8
                    method: 'POST',
9
                    body: JSON.stringify({
10
                        fileName: 'test.txt'
11
                    }),
12
                    headers: {
13
                        'Content-Type': 'application/json'
14
                    }
15
                });
16

17
                if (!response.ok) {
18
                    const error = await response.json();
19
                    throw new Error(error.error || '下载失败');
20
                }
21

22
                const blob = await response.blob();
23
                const url = URL.createObjectURL(blob);
24
                const a = document.createElement('a');
25
                a.href = url;
26
                a.download = 'test.txt';
27
                document.body.appendChild(a);
28
                a.click();
29
                document.body.removeChild(a);
30
                URL.revokeObjectURL(url);
31
            } catch (error) {
32
                console.error('下载出错:', error);
33
                alert(error.message);
34
            }
35
        });
36
    </script>
37
</body>

前端核心逻辑就是接受的返回值是流的方式arrayBuffer,转成blob，生成下载链接，模拟a标签点击下载

node端#

主要的地方在于响应头

Content-Type 指定下载文件的 MIME 类型

application/octet-stream（二进制流数据）
application/pdf：Adobe PDF 文件。
application/json：JSON 数据文件
image/jpeg：JPEG 图像文件

Content-Disposition 指定服务器返回的内容在浏览器中的处理方式。它可以用于控制文件下载、内联显示或其他处理方式

attachment：指示浏览器将响应内容作为附件下载。通常与 filename 参数一起使用，用于指定下载文件的名称
inline：指示浏览器直接在浏览器窗口中打开响应内容，如果内容是可识别的文件类型（例如图片或 PDF），则在浏览器中内联显示

1
import express from "express";
2
import cors from "cors";
3
import fs from "fs";
4
import path from "path";
5

6
const app = express();
7
app.use(cors());
8
app.use(express.json())
9

10
app.post('/download', (req, res) => {
11
  try {
12
    const fileName = req.body.fileName;
13
    if (!fileName) {
14
      return res.status(400).json({ error: '文件名不能为空' });
15
    }
16

17
    const filepath = path.join(process.cwd(), 'static', fileName);
18

19
    // 检查文件是否存在
20
    if (!fs.existsSync(filepath)) {
21
      return res.status(404).json({ error: '文件不存在' });
22
    }
23

24
    const content = fs.readFileSync(filepath);
25

26
    res.setHeader('Content-Type', 'application/octet-stream');
27
    res.setHeader('Content-Disposition', `attachment; filename=${fileName}`);
28
    res.send(content);
29
  } catch (error) {
30
    console.error('下载文件时出错:', error);
31
    res.status(500).json({ error: '服务器内部错误' });
32
  }
33
});
34

35
app.listen(3000, () => {
36
  console.log("Server is running on port 3000");
37
});

a ctfer on the load

nodejs实现定时任务#

文件上传#

前端部分#

node端#

文件流下载#

前端实现#

node端#