3080 字

15 分钟

NodeJS技术

2025-09-05

Web3

/

区块链

/

Node.js

/

JavaScript

/

后端开发

NodeJS技术#

概述#

Node.js是Web3和区块链开发中不可或缺的技术栈。本章节详细介绍了Node.js在区块链开发中的应用，包括JavaScript基础、事件循环机制、异步编程等核心概念，以及区块链相关的Node.js开发实践。

1. JavaScript基础#

1.1 异常处理机制#

1.1.1 try-catch语句#

1
try {
2
    throw new Error('1')
3
} catch(error) {
4
    console.log('error')
5
}
6
// 输出结果：error

1.1.2 异步异常处理#

1
try {
2
    setTimeout(function() {
3
        console.log('b');
4
    }, 0);
5
} catch (error) {
6
    console.log('error');
7
}
8
console.log('out try catch')
9
// 输出结果：
10
// out try catch
11
// b

注意：setTimeout是异步操作，异常不会在try-catch中捕获。

1.1.3 Promise异常处理#

1
try {
2
    new Promise(() => {
3
        throw new Error('new promise throw error');
4
    });
5
} catch (error) {
6
    console.log('error');
7
}
8
// 输出结果：Error: new promise throw error

注意：Promise中的异常需要通过.catch()方法捕获。

1.2 事件循环机制#

1.2.1 基本概念#

事件循环机制用于管理异步API的回调函数什么时候回到主线程中执行。

Node.js采用异步IO模型
同步API在主线程中执行
异步API在底层的C++维护的线程中执行
异步API的回调函数也会在主线程中执行

1.2.2 事件循环的六个阶段#

1. Timers阶段

用于存储定时器的回调函数（setInterval, setTimeout）
执行到期的定时器回调

2. Pending callbacks阶段

执行与操作系统相关的回调函数
比如启动服务器端应用时监听端口操作的回调函数

3. Idle, prepare阶段

系统内部使用
程序员通常不需要关心

4. Poll阶段

存储I/O操作的回调函数队列
比如文件读写操作的回调函数
如果事件队列中有回调函数，则执行它们直到清空队列
否则事件循环将在此阶段停留一段时间以等待新的回调函数进入

等待条件：

如果setImmediate队列（check阶段）中存在要执行的调函数，不会等待
如果timers队列中存在要执行的回调函数，也不会等待

5. Check阶段

存储setImmediate的回调函数
执行setImmediate的回调

6. Closing callbacks阶段

执行与关闭事件相关的回调
例如关闭数据库连接的回调函数等

1.2.3 宏任务与微任务#

宏任务：

setInterval
setTimeout
setImmediate
I/O操作

微任务：

Promise.then
Promise.catch
Promise.finally
process.nextTick

1.2.4 执行顺序#

1
console.log('Start');
2
setTimeout(() => {
3
    console.log('Timeout');
4
}, 0);
5
Promise.resolve().then(() => {
6
    console.log('Promise resolved');
7
});
8
console.log('End');
9

10
// 输出结果：
11
// Start
12
// End
13
// Promise resolved
14
// Timeout

执行规则：

微任务优先级高于宏任务
当微任务事件队列中存在可以执行的回调函数时，事件循环在执行完当前阶段的回调函数后会暂停进入事件循环的下一个阶段
会立即进入微任务的事件队列中开始执行回调函数
当微任务队列中的回调函数执行完成后，事件循环才会进入到下一个阶段开始执行回调函数
process.nextTick的优先级高于其他微任务

1.3 ES6新特性#

1.3.1 核心特性#

类的支持：面向对象编程
模块化：import/export语法
箭头操作符：简化函数定义
let/const块作用域：变量作用域控制
字符串模板：模板字符串语法
解构：数组和对象解构
参数默认值/不定参数/拓展参数：函数参数增强
for-of遍历：迭代器语法
generator：生成器函数
Map/Set：新的数据结构
Promise：异步编程解决方案

1.3.2 在区块链开发中的应用#

1
// 使用async/await处理异步操作
2
async function getBlockData(blockNumber) {
3
    try {
4
        const block = await web3.eth.getBlock(blockNumber);
5
        return block;
6
    } catch (error) {
7
        console.error('获取区块数据失败:', error);
8
        throw error;
9
    }
10
}
11

12
// 使用解构获取交易信息
13
const { from, to, value, gas } = transaction;
14

15
// 使用Map存储合约地址映射
16
const contractAddresses = new Map();
17
contractAddresses.set('USDT', '0xdAC17F958D2ee523a2206206994597C13D831ec7');

1.4 类继承#

1.4.1 继承方法#

1. 原型链法

1
function Animal() {
2
    this.name = 'animal';
3
}
4
Animal.prototype.sayName = function(){
5
    alert(this.name);
6
};
7

8
function Person() {}
9
Person.prototype = Animal.prototype; // 人继承自动物
10
Person.prototype.constructor = 'Person'; // 更新构造函数为人

2. 属性复制法

1
function Animal() {
2
    this.name = 'animal';
3
}
4
Animal.prototype.sayName = function() {
5
    alert(this.name);
6
};
7

8
function Person() {}
9

10
for(prop in Animal.prototype) {
11
    Person.prototype[prop] = Animal.prototype[prop];
12
} // 复制动物的所有属性到人
13
Person.prototype.constructor = 'Person'; // 更新构造函数为人

3. 构造器应用法

1
function Animal() {
2
    this.name = 'animal';
3
}
4
Animal.prototype.sayName = function() {
5
    alert(this.name);
6
};
7

8
function Person() {
9
    Animal.call(this); // apply, call, bind方法都可以
10
}

1.4.2 多重继承#

多重继承通过属性复制法实现，将所有父类的prototype属性复制后，子类自然拥有类似行为和属性。

1.5 this指向#

在JavaScript中，this指向对象本身，但在不同情况下this的指向会发生变化：

1
// 全局作用域
2
console.log(this); // 指向全局对象（浏览器中是window，Node.js中是global）
3

4
// 对象方法
5
const obj = {
6
    name: 'test',
7
    getName: function() {
8
        return this.name; // this指向obj
9
    }
10
};
11

12
// 构造函数
13
function Person(name) {
14
    this.name = name; // this指向新创建的实例
15
}
16

17
// 箭头函数
18
const obj = {
19
    name: 'test',
20
    getName: () => {
21
        return this.name; // this指向外层作用域
22
    }
23
};

1.6 apply、call和bind#

三者都可以把一个函数应用到其他对象上，但有一些区别：

1
function Person() {}
2
Person.prototype.sayName = function() {
3
    alert(this.name);
4
}
5

6
var obj = {name: 'michaelqin'}; // 注意这是一个普通对象，它不是Person的实例
7

8
// 1) apply
9
Person.prototype.sayName.apply(obj, [param1, param2, param3]);
10

11
// 2) call
12
Person.prototype.sayName.call(obj, param1, param2, param3);
13

14
// 3) bind
15
var sn = Person.prototype.sayName.bind(obj);
16
sn([param1, param2, param3]); // bind需要先绑定，再执行
17
sn(param1, param2, param3); // bind需要先绑定，再执行

区别：

apply：接受数组作为参数
call：接受逗号分隔的无限多个参数列表
bind：绑定后需要再次调用才能执行

1.7 caller、callee和arguments#

1
function parent(param1, param2, param3) {
2
    child(param1, param2, param3);
3
}
4

5
function child() {
6
    console.log(arguments); // { '0': 'mqin1', '1': 'mqin2', '2': 'mqin3' }
7
    console.log(arguments.callee); // [Function: child]
8
    console.log(child.caller); // [Function: parent]
9
}
10

11
parent('mqin1', 'mqin2', 'mqin3');

caller：返回调用当前函数的函数
callee：返回当前正在执行的函数
arguments：函数的所有参数列表，它是一个类数组的变量

1.8 Map和Set#

1.8.1 Map#

Map是一组键值对的结构，具有极快的查找速度：

1
const map = new Map();
2
map.set('name', 'Alice');
3
map.set('age', 25);
4
console.log(map.get('name')); // Alice

1.8.2 Set#

Set和Map类似，也是一组key的集合，但不存储value。由于key不能重复，所以Set中没有重复的key：

1
const set = new Set();
2
set.add(1);
3
set.add(2);
4
set.add(1); // 重复值，不会添加
5
console.log(set.size); // 2

1.8.3 WeakSet和WeakMap#

WeakSet：

成员都是对象
成员都是弱引用，可以被垃圾回收机制回收
可以用来保存DOM节点，不容易造成内存泄漏
不能遍历，方法有add、delete、has

WeakMap：

只接受对象作为键名（null除外）
键名是弱引用，键值可以是任意的
键名所指向的对象可以被垃圾回收，此时键名是无效的
不能遍历，方法有get、set、has、delete

2. Node.js架构#

2.1 整体架构#

Node.js主要分为三层：

1
应用app >> V8及node内置架构 >> 操作系统

V8：Node.js运行的环境，可以理解为Node虚拟机
Node内置架构：又可分为三层
- 核心模块（JavaScript实现）
- C++绑定
- libuv + CAes + http

2.2 核心模块#

Node.js的核心模块包括：

fs：文件系统操作
http：HTTP服务器和客户端
path：路径处理
crypto：加密功能
util：工具函数
events：事件处理

2.3 在区块链开发中的应用#

2.3.1 文件系统操作#

1
const fs = require('fs');
2
const path = require('path');
3

4
// 读取合约ABI
5
const contractABI = JSON.parse(fs.readFileSync(path.join(__dirname, 'contracts', 'Token.json'), 'utf8'));
6

7
// 写入私钥文件
8
fs.writeFileSync('privateKey.txt', privateKey);

2.3.2 HTTP服务器#

1
const http = require('http');
2
const express = require('express');
3
const app = express();
4

5
// 创建API端点
6
app.get('/balance/:address', async (req, res) => {
7
    try {
8
        const balance = await web3.eth.getBalance(req.params.address);
9
        res.json({ balance: balance.toString() });
10
    } catch (error) {
11
        res.status(500).json({ error: error.message });
12
    }
13
});
14

15
app.listen(3000, () => {
16
    console.log('服务器运行在端口3000');
17
});

2.3.3 加密功能#

1
const crypto = require('crypto');
2

3
// 生成随机私钥
4
const privateKey = crypto.randomBytes(32);
5

6
// 计算哈希
7
const hash = crypto.createHash('sha256').update(data).digest('hex');
8

9
// 签名
10
const sign = crypto.createSign('sha256');
11
sign.update(data);
12
const signature = sign.sign(privateKey, 'hex');

3. 区块链开发实践#

3.1 Web3.js集成#

3.1.1 安装和配置#

1
npm install web3

1
const Web3 = require('web3');
2

3
// 连接到以太坊节点
4
const web3 = new Web3('https://mainnet.infura.io/v3/YOUR_PROJECT_ID');
5

6
// 或者连接到本地节点
7
const web3 = new Web3('http://localhost:8545');

3.1.2 基本操作#

1
// 获取账户余额
2
async function getBalance(address) {
3
    const balance = await web3.eth.getBalance(address);
4
    return web3.utils.fromWei(balance, 'ether');
5
}
6

7
// 发送交易
8
async function sendTransaction(from, to, value) {
9
    const tx = {
10
        from: from,
11
        to: to,
12
        value: web3.utils.toWei(value, 'ether'),
13
        gas: 21000
14
    };
15

16
    const result = await web3.eth.sendTransaction(tx);
17
    return result;
18
}
19

20
// 部署合约
21
async function deployContract(abi, bytecode, from) {
22
    const contract = new web3.eth.Contract(abi);
23
    const deploy = contract.deploy({
24
        data: bytecode,
25
        arguments: []
26
    });
27

28
    const result = await deploy.send({
29
        from: from,
30
        gas: 1500000
31
    });
32

33
    return result;
34
}

3.2 事件监听#

3.2.1 合约事件监听#

1
// 监听合约事件
2
const contract = new web3.eth.Contract(abi, contractAddress);
3

4
contract.events.Transfer({
5
    filter: { from: '0x...' }, // 过滤条件
6
    fromBlock: 'latest'
7
}, (error, event) => {
8
    if (error) {
9
        console.error('事件监听错误:', error);
10
        return;
11
    }
12

13
    console.log('Transfer事件:', event);
14
});

3.2.2 区块监听#

1
// 监听新区块
2
web3.eth.subscribe('newBlockHeaders', (error, blockHeader) => {
3
    if (error) {
4
        console.error('区块监听错误:', error);
5
        return;
6
    }
7

8
    console.log('新区块:', blockHeader.number);
9
});

3.3 错误处理#

3.3.1 异步错误处理#

1
// 使用try-catch处理异步错误
2
async function handleAsyncOperation() {
3
    try {
4
        const result = await someAsyncOperation();
5
        return result;
6
    } catch (error) {
7
        console.error('操作失败:', error);
8
        throw error;
9
    }
10
}
11

12
// 使用Promise.catch处理错误
13
someAsyncOperation()
14
    .then(result => {
15
        console.log('操作成功:', result);
16
    })
17
    .catch(error => {
18
        console.error('操作失败:', error);
19
    });

3.3.2 重试机制#

1
async function retryOperation(operation, maxRetries = 3) {
2
    for (let i = 0; i < maxRetries; i++) {
3
        try {
4
            return await operation();
5
        } catch (error) {
6
            if (i === maxRetries - 1) {
7
                throw error;
8
            }
9
            console.log(`重试 ${i + 1}/${maxRetries}:`, error.message);
10
            await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
11
        }
12
    }
13
}

3.4 性能优化#

3.4.1 连接池#

1
const Web3 = require('web3');
2

3
class Web3Pool {
4
    constructor(urls, maxConnections = 10) {
5
        this.urls = urls;
6
        this.connections = [];
7
        this.maxConnections = maxConnections;
8
        this.currentIndex = 0;
9
    }
10

11
    getConnection() {
12
        if (this.connections.length < this.maxConnections) {
13
            const url = this.urls[this.currentIndex % this.urls.length];
14
            const web3 = new Web3(url);
15
            this.connections.push(web3);
16
            this.currentIndex++;
17
            return web3;
18
        }
19

20
        return this.connections[this.currentIndex++ % this.connections.length];
21
    }
22
}

3.4.2 缓存机制#

1
const NodeCache = require('node-cache');
2
const cache = new NodeCache({ stdTTL: 600 }); // 10分钟过期
3

4
async function getCachedBalance(address) {
5
    const cacheKey = `balance_${address}`;
6
    let balance = cache.get(cacheKey);
7

8
    if (!balance) {
9
        balance = await web3.eth.getBalance(address);
10
        cache.set(cacheKey, balance);
11
    }
12

13
    return balance;
14
}

4. 最佳实践#

4.1 代码组织#

4.1.1 模块化设计#

1
module.exports = {
2
    host: process.env.DB_HOST || 'localhost',
3
    port: process.env.DB_PORT || 5432,
4
    database: process.env.DB_NAME || 'blockchain',
5
    username: process.env.DB_USER || 'postgres',
6
    password: process.env.DB_PASS || 'password'
7
};
8

9
// services/blockchain.js
10
class BlockchainService {
11
    constructor(web3) {
12
        this.web3 = web3;
13
    }
14

15
    async getBalance(address) {
16
        return await this.web3.eth.getBalance(address);
17
    }
18

19
    async sendTransaction(tx) {
20
        return await this.web3.eth.sendTransaction(tx);
21
    }
22
}
23

24
module.exports = BlockchainService;

4.1.2 错误处理中间件#

1
function errorHandler(err, req, res, next) {
2
    console.error('错误:', err);
3

4
    if (err.code === 'INSUFFICIENT_FUNDS') {
5
        return res.status(400).json({
6
            error: '余额不足',
7
            code: 'INSUFFICIENT_FUNDS'
8
        });
9
    }
10

11
    if (err.code === 'NETWORK_ERROR') {
12
        return res.status(503).json({
13
            error: '网络错误',
14
            code: 'NETWORK_ERROR'
15
        });
16
    }
17

18
    res.status(500).json({
19
        error: '服务器内部错误',
20
        code: 'INTERNAL_ERROR'
21
    });
22
}

4.2 安全考虑#

4.2.1 私钥管理#

1
const crypto = require('crypto');
2

3
class KeyManager {
4
    constructor() {
5
        this.encryptionKey = process.env.ENCRYPTION_KEY;
6
    }
7

8
    encryptPrivateKey(privateKey, password) {
9
        const cipher = crypto.createCipher('aes-256-cbc', password);
10
        let encrypted = cipher.update(privateKey, 'hex', 'hex');
11
        encrypted += cipher.final('hex');
12
        return encrypted;
13
    }
14

15
    decryptPrivateKey(encryptedKey, password) {
16
        const decipher = crypto.createDecipher('aes-256-cbc', password);
17
        let decrypted = decipher.update(encryptedKey, 'hex', 'hex');
18
        decrypted += decipher.final('hex');
19
        return decrypted;
20
    }
21
}

4.2.2 输入验证#

1
const Joi = require('joi');
2

3
const transactionSchema = Joi.object({
4
    from: Joi.string().pattern(/^0x[a-fA-F0-9]{40}$/).required(),
5
    to: Joi.string().pattern(/^0x[a-fA-F0-9]{40}$/).required(),
6
    value: Joi.string().pattern(/^\d+$/).required(),
7
    gas: Joi.number().integer().min(21000).max(1000000).optional()
8
});
9

10
function validateTransaction(data) {
11
    const { error, value } = transactionSchema.validate(data);
12
    if (error) {
13
        throw new Error(`验证失败: ${error.details[0].message}`);
14
    }
15
    return value;
16
}

4.3 监控和日志#

4.3.1 日志记录#

1
const winston = require('winston');
2

3
const logger = winston.createLogger({
4
    level: 'info',
5
    format: winston.format.combine(
6
        winston.format.timestamp(),
7
        winston.format.errors({ stack: true }),
8
        winston.format.json()
9
    ),
10
    transports: [
11
        new winston.transports.File({ filename: 'error.log', level: 'error' }),
12
        new winston.transports.File({ filename: 'combined.log' }),
13
        new winston.transports.Console()
14
    ]
15
});
16

17
// 使用日志
18
logger.info('交易发送成功', { txHash: '0x...', from: '0x...', to: '0x...' });
19
logger.error('交易失败', { error: error.message, tx: tx });

4.3.2 性能监控#

1
const performance = require('perf_hooks');
2

3
function measurePerformance(name, fn) {
4
    return async (...args) => {
5
        const start = performance.performanceNow();
6
        try {
7
            const result = await fn(...args);
8
            const end = performance.performanceNow();
9
            console.log(`${name} 执行时间: ${end - start}ms`);
10
            return result;
11
        } catch (error) {
12
            const end = performance.performanceNow();
13
            console.log(`${name} 执行失败，耗时: ${end - start}ms`);
14
            throw error;
15
        }
16
    };
17
}
18

19
// 使用示例
20
const getBalanceWithTiming = measurePerformance('getBalance', getBalance);