Node.js和Express后端开发完全指南#

Node.js已经成为现代后端开发的重要工具，它允许我们使用JavaScript编写服务器端代码，实现全栈JavaScript开发。Express是Node.js生态系统中最流行的Web框架，它提供了简洁、灵活的API，帮助我们快速构建Web应用。本文将深入探讨Node.js和Express的使用技巧和最佳实践，帮助你构建高性能、可维护的后端应用。

1. Node.js基础#

1.1 什么是Node.js？#

Node.js是一个基于Chrome V8引擎的JavaScript运行时，它允许我们在服务器端运行JavaScript代码。Node.js采用事件驱动、非阻塞I/O模型，使其轻量且高效。

1.2 安装Node.js#

Windows和macOS： 从Node.js官网下载安装包。

Linux： 使用包管理器安装。

1
# Ubuntu/Debian
2
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
3
sudo apt-get install -y nodejs
4

5
# CentOS/RHEL
6
curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash -
7
sudo yum install -y nodejs

1.3 NPM和Yarn#

NPM： Node.js自带的包管理器。

Yarn： Facebook开发的包管理器，提供更快的安装速度和更可靠的依赖管理。

1
# 安装Yarn
2
npm install -g yarn

1.4 基本模块#

内置模块：

fs：文件系统操作
path：路径处理
http：HTTP服务器和客户端
https：HTTPS服务器和客户端
events：事件处理
stream：流处理
buffer：缓冲区处理
util：实用工具

使用内置模块：

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

2. Express基础#

2.1 什么是Express？#

Express是一个基于Node.js的Web应用框架，它提供了简洁、灵活的API，帮助我们快速构建Web应用。Express是Node.js生态系统中最流行的Web框架，被广泛用于构建RESTful API、Web应用和单页应用的后端。

2.2 安装Express#

1
# 使用NPM
2
npm init -y
3
npm install express
4

5
# 使用Yarn
6
yarn init -y
7
yarn add express

2.3 基本用法#

创建简单的Express应用：

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

5
// 中间件
6
app.use(express.json());
7
app.use(express.urlencoded({ extended: true }));
8

9
// 路由
10
app.get('/', (req, res) => {
11
  res.send('Hello World!');
12
});
13

14
// 启动服务器
15
app.listen(port, () => {
16
  console.log(`Server running at http://localhost:${port}`);
17
});

2.4 路由#

基本路由：

1
// GET请求
2
app.get('/api/users', (req, res) => {
3
  res.json([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
4
});
5

6
// POST请求
7
app.post('/api/users', (req, res) => {
8
  const user = req.body;
9
  res.status(201).json(user);
10
});
11

12
// PUT请求
13
app.put('/api/users/:id', (req, res) => {
14
  const { id } = req.params;
15
  const user = req.body;
16
  res.json({ id, ...user });
17
});
18

19
// DELETE请求
20
app.delete('/api/users/:id', (req, res) => {
21
  const { id } = req.params;
22
  res.status(204).send();
23
});

路由参数：

1
app.get('/api/users/:id', (req, res) => {
2
  const { id } = req.params;
3
  res.json({ id, name: 'John' });
4
});

查询参数：

1
app.get('/api/users', (req, res) => {
2
  const { page, limit } = req.query;
3
  res.json({ page, limit, users: [] });
4
});

2.5 中间件#

内置中间件：

1
// 解析JSON请求体
2
app.use(express.json());
3

4
// 解析URL编码的请求体
5
app.use(express.urlencoded({ extended: true }));
6

7
// 提供静态文件
8
app.use(express.static('public'));

自定义中间件：

1
// 日志中间件
2
const logger = (req, res, next) => {
3
  console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
4
  next();
5
};
6

7
app.use(logger);
8

9
// 认证中间件
10
const auth = (req, res, next) => {
11
  const token = req.headers.authorization;
12
  if (!token) {
13
    return res.status(401).json({ message: 'Unauthorized' });
14
  }
15
  // 验证token
16
  next();
17
};
18

19
app.use('/api', auth);

错误处理中间件：

1
app.use((err, req, res, next) => {
2
  console.error(err.stack);
3
  res.status(500).json({ message: 'Internal Server Error' });
4
});

3. 高级Express功能#

3.1 路由模块化#

创建路由模块：

1
const express = require('express');
2
const router = express.Router();
3

4
router.get('/', (req, res) => {
5
  res.json([{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]);
6
});
7

8
router.post('/', (req, res) => {
9
  const user = req.body;
10
  res.status(201).json(user);
11
});
12

13
module.exports = router;

使用路由模块：

1
const express = require('express');
2
const app = express();
3
const usersRouter = require('./routes/users');
4

5
app.use('/api/users', usersRouter);

3.2 中间件链#

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

4
// 中间件1
5
const middleware1 = (req, res, next) => {
6
  console.log('Middleware 1');
7
  next();
8
};
9

10
// 中间件2
11
const middleware2 = (req, res, next) => {
12
  console.log('Middleware 2');
13
  next();
14
};
15

16
// 应用中间件链
17
app.get('/api/users', middleware1, middleware2, (req, res) => {
18
  res.json([{ id: 1, name: 'John' }]);
19
});

3.3 错误处理#

同步错误：

1
app.get('/api/error', (req, res) => {
2
  throw new Error('Sync error');
3
});

异步错误：

1
// 方法1：使用try-catch
2
app.get('/api/async-error', async (req, res, next) => {
3
  try {
4
    const result = await someAsyncOperation();
5
    res.json(result);
6
  } catch (error) {
7
    next(error);
8
  }
9
});
10

11
// 方法2：直接传递错误
12
app.get('/api/async-error', async (req, res, next) => {
13
  const result = await someAsyncOperation().catch(next);
14
  res.json(result);
15
});

自定义错误类：

1
class AppError extends Error {
2
  constructor(message, statusCode) {
3
    super(message);
4
    this.statusCode = statusCode;
5
    this.status = `${statusCode}`.startsWith('4') ? 'fail' : 'error';
6
    this.isOperational = true;
7

8
    Error.captureStackTrace(this, this.constructor);
9
  }
10
}
11

12
// 使用自定义错误
13
app.get('/api/error', (req, res, next) => {
14
  next(new AppError('Not found', 404));
15
});
16

17
// 错误处理中间件
18
app.use((err, req, res, next) => {
19
  err.statusCode = err.statusCode || 500;
20
  err.status = err.status || 'error';
21

22
  res.status(err.statusCode).json({
23
    status: err.status,
24
    message: err.message
25
  });
26
});

3.4 环境变量#

使用dotenv：

1
npm install dotenv

创建.env文件：

1
NODE_ENV=development
2
PORT=3000
3
DATABASE_URL=mongodb://localhost:27017/myapp
4
JWT_SECRET=your-secret-key

使用环境变量：

1
require('dotenv').config();
2

3
const express = require('express');
4
const app = express();
5

6
const port = process.env.PORT || 3000;
7
const databaseUrl = process.env.DATABASE_URL;
8

9
app.listen(port, () => {
10
  console.log(`Server running at http://localhost:${port}`);
11
});

4. 数据库集成#

4.1 MongoDB#

安装Mongoose：

1
npm install mongoose

连接MongoDB：

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

3
mongoose.connect(process.env.DATABASE_URL, {
4
  useNewUrlParser: true,
5
  useUnifiedTopology: true
6
}).then(() => {
7
  console.log('Connected to MongoDB');
8
}).catch((error) => {
9
  console.error('Error connecting to MongoDB:', error);
10
});

创建模型：

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

3
const userSchema = new mongoose.Schema({
4
  name: {
5
    type: String,
6
    required: true
7
  },
8
  email: {
9
    type: String,
10
    required: true,
11
    unique: true
12
  },
13
  password: {
14
    type: String,
15
    required: true
16
  }
17
});
18

19
const User = mongoose.model('User', userSchema);
20

21
module.exports = User;

使用模型：

1
const User = require('./models/User');
2

3
// 创建用户
4
app.post('/api/users', async (req, res) => {
5
  try {
6
    const user = new User(req.body);
7
    await user.save();
8
    res.status(201).json(user);
9
  } catch (error) {
10
    res.status(400).json({ message: error.message });
11
  }
12
});
13

14
// 获取所有用户
15
app.get('/api/users', async (req, res) => {
16
  try {
17
    const users = await User.find();
18
    res.json(users);
19
  } catch (error) {
20
    res.status(500).json({ message: error.message });
21
  }
22
});
23

24
// 获取单个用户
25
app.get('/api/users/:id', async (req, res) => {
26
  try {
27
    const user = await User.findById(req.params.id);
28
    if (!user) {
29
      return res.status(404).json({ message: 'User not found' });
30
    }
31
    res.json(user);
32
  } catch (error) {
33
    res.status(500).json({ message: error.message });
34
  }
35
});
36

37
// 更新用户
38
app.put('/api/users/:id', async (req, res) => {
39
  try {
40
    const user = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
41
    if (!user) {
42
      return res.status(404).json({ message: 'User not found' });
43
    }
44
    res.json(user);
45
  } catch (error) {
46
    res.status(400).json({ message: error.message });
47
  }
48
});
49

50
// 删除用户
51
app.delete('/api/users/:id', async (req, res) => {
52
  try {
53
    const user = await User.findByIdAndDelete(req.params.id);
54
    if (!user) {
55
      return res.status(404).json({ message: 'User not found' });
56
    }
57
    res.status(204).send();
58
  } catch (error) {
59
    res.status(500).json({ message: error.message });
60
  }
61
});

4.2 PostgreSQL#

安装Sequelize：

1
npm install sequelize pg pg-hstore

连接PostgreSQL：

1
const { Sequelize } = require('sequelize');
2

3
const sequelize = new Sequelize(process.env.DATABASE_URL, {
4
  dialect: 'postgres',
5
  logging: false
6
});
7

8
sequelize.authenticate().then(() => {
9
  console.log('Connected to PostgreSQL');
10
}).catch((error) => {
11
  console.error('Error connecting to PostgreSQL:', error);
12
});

创建模型：

1
const { DataTypes } = require('sequelize');
2
const sequelize = require('./sequelize');
3

4
const User = sequelize.define('User', {
5
  id: {
6
    type: DataTypes.INTEGER,
7
    primaryKey: true,
8
    autoIncrement: true
9
  },
10
  name: {
11
    type: DataTypes.STRING,
12
    allowNull: false
13
  },
14
  email: {
15
    type: DataTypes.STRING,
16
    allowNull: false,
17
    unique: true
18
  },
19
  password: {
20
    type: DataTypes.STRING,
21
    allowNull: false
22
  }
23
});
24

25
module.exports = User;

使用模型：

1
const User = require('./models/User');
2

3
// 创建用户
4
app.post('/api/users', async (req, res) => {
5
  try {
6
    const user = await User.create(req.body);
7
    res.status(201).json(user);
8
  } catch (error) {
9
    res.status(400).json({ message: error.message });
10
  }
11
});
12

13
// 获取所有用户
14
app.get('/api/users', async (req, res) => {
15
  try {
16
    const users = await User.findAll();
17
    res.json(users);
18
  } catch (error) {
19
    res.status(500).json({ message: error.message });
20
  }
21
});
22

23
// 获取单个用户
24
app.get('/api/users/:id', async (req, res) => {
25
  try {
26
    const user = await User.findByPk(req.params.id);
27
    if (!user) {
28
      return res.status(404).json({ message: 'User not found' });
29
    }
30
    res.json(user);
31
  } catch (error) {
32
    res.status(500).json({ message: error.message });
33
  }
34
});
35

36
// 更新用户
37
app.put('/api/users/:id', async (req, res) => {
38
  try {
39
    const user = await User.findByPk(req.params.id);
40
    if (!user) {
41
      return res.status(404).json({ message: 'User not found' });
42
    }
43
    await user.update(req.body);
44
    res.json(user);
45
  } catch (error) {
46
    res.status(400).json({ message: error.message });
47
  }
48
});
49

50
// 删除用户
51
app.delete('/api/users/:id', async (req, res) => {
52
  try {
53
    const user = await User.findByPk(req.params.id);
54
    if (!user) {
55
      return res.status(404).json({ message: 'User not found' });
56
    }
57
    await user.destroy();
58
    res.status(204).send();
59
  } catch (error) {
60
    res.status(500).json({ message: error.message });
61
  }
62
});

4.3 MySQL#

安装Sequelize：

1
npm install sequelize mysql2

连接MySQL：

1
const { Sequelize } = require('sequelize');
2

3
const sequelize = new Sequelize(process.env.DATABASE_URL, {
4
  dialect: 'mysql',
5
  logging: false
6
});
7

8
sequelize.authenticate().then(() => {
9
  console.log('Connected to MySQL');
10
}).catch((error) => {
11
  console.error('Error connecting to MySQL:', error);
12
});

创建模型和使用方法与PostgreSQL类似。

5. 认证和授权#

5.1 JWT认证#

安装jsonwebtoken：

1
npm install jsonwebtoken bcryptjs

生成和验证JWT：

1
const jwt = require('jsonwebtoken');
2
const bcrypt = require('bcryptjs');
3

4
// 生成token
5
const generateToken = (userId) => {
6
  return jwt.sign({ id: userId }, process.env.JWT_SECRET, {
7
    expiresIn: '1h'
8
  });
9
};
10

11
// 验证token
12
const verifyToken = (token) => {
13
  return jwt.verify(token, process.env.JWT_SECRET);
14
};
15

16
// 密码加密
17
const hashPassword = async (password) => {
18
  const salt = await bcrypt.genSalt(10);
19
  return await bcrypt.hash(password, salt);
20
};
21

22
// 密码验证
23
const comparePassword = async (password, hashedPassword) => {
24
  return await bcrypt.compare(password, hashedPassword);
25
};

认证流程：

1
const User = require('./models/User');
2
const { generateToken, hashPassword, comparePassword } = require('./utils/auth');
3

4
// 注册
5
app.post('/api/auth/register', async (req, res) => {
6
  try {
7
    const { name, email, password } = req.body;
8

9
    // 检查用户是否存在
10
    const existingUser = await User.findOne({ email });
11
    if (existingUser) {
12
      return res.status(400).json({ message: 'User already exists' });
13
    }
14

15
    // 密码加密
16
    const hashedPassword = await hashPassword(password);
17

18
    // 创建用户
19
    const user = await User.create({ name, email, password: hashedPassword });
20

21
    // 生成token
22
    const token = generateToken(user.id);
23

24
    res.status(201).json({ user, token });
25
  } catch (error) {
26
    res.status(400).json({ message: error.message });
27
  }
28
});
29

30
// 登录
31
app.post('/api/auth/login', async (req, res) => {
32
  try {
33
    const { email, password } = req.body;
34

35
    // 检查用户是否存在
36
    const user = await User.findOne({ email });
37
    if (!user) {
38
      return res.status(401).json({ message: 'Invalid email or password' });
39
    }
40

41
    // 验证密码
42
    const isPasswordValid = await comparePassword(password, user.password);
43
    if (!isPasswordValid) {
44
      return res.status(401).json({ message: 'Invalid email or password' });
45
    }
46

47
    // 生成token
48
    const token = generateToken(user.id);
49

50
    res.json({ user, token });
51
  } catch (error) {
52
    res.status(400).json({ message: error.message });
53
  }
54
});
55

56
// 认证中间件
57
const auth = async (req, res, next) => {
58
  try {
59
    const token = req.headers.authorization?.split(' ')[1];
60
    if (!token) {
61
      return res.status(401).json({ message: 'Access token required' });
62
    }
63

64
    const decoded = verifyToken(token);
65
    const user = await User.findById(decoded.id);
66
    if (!user) {
67
      return res.status(401).json({ message: 'Invalid token' });
68
    }
69

70
    req.user = user;
71
    next();
72
  } catch (error) {
73
    res.status(401).json({ message: 'Invalid token' });
74
  }
75
};
76

77
// 保护路由
78
app.get('/api/profile', auth, (req, res) => {
79
  res.json({ user: req.user });
80
});

5.2 OAuth认证#

安装passport：

1
npm install passport passport-google-oauth20

配置Google OAuth：

1
const passport = require('passport');
2
const GoogleStrategy = require('passport-google-oauth20').Strategy;
3
const User = require('./models/User');
4

5
passport.use(new GoogleStrategy({
6
  clientID: process.env.GOOGLE_CLIENT_ID,
7
  clientSecret: process.env.GOOGLE_CLIENT_SECRET,
8
  callbackURL: '/api/auth/google/callback'
9
}, async (accessToken, refreshToken, profile, done) => {
10
  try {
11
    // 检查用户是否存在
12
    let user = await User.findOne({ googleId: profile.id });
13
    if (!user) {
14
      // 创建新用户
15
      user = await User.create({
16
        googleId: profile.id,
17
        name: profile.displayName,
18
        email: profile.emails[0].value
19
      });
20
    }
21
    done(null, user);
22
  } catch (error) {
23
    done(error, null);
24
  }
25
}));
26

27
passport.serializeUser((user, done) => {
28
  done(null, user.id);
29
});
30

31
passport.deserializeUser(async (id, done) => {
32
  try {
33
    const user = await User.findById(id);
34
    done(null, user);
35
  } catch (error) {
36
    done(error, null);
37
  }
38
});

OAuth路由：

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

3
// 发起OAuth认证
4
app.get('/api/auth/google', passport.authenticate('google', {
5
  scope: ['profile', 'email']
6
}));
7

8
// OAuth回调
9
app.get('/api/auth/google/callback', passport.authenticate('google', {
10
  failureRedirect: '/api/auth/failure'
11
}), (req, res) => {
12
  // 生成token
13
  const token = generateToken(req.user.id);
14
  res.json({ user: req.user, token });
15
});
16

17
// 认证失败
18
app.get('/api/auth/failure', (req, res) => {
19
  res.status(401).json({ message: 'Authentication failed' });
20
});

6. 性能优化#

6.1 数据库优化#

索引： 为频繁查询的字段添加索引。

查询优化：

只查询需要的字段
使用分页
避免N+1查询

连接池： 使用连接池管理数据库连接。

6.2 缓存#

安装redis：

1
npm install redis

使用Redis缓存：

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

3
const redisClient = redis.createClient({
4
  url: process.env.REDIS_URL
5
});
6

7
redisClient.connect().then(() => {
8
  console.log('Connected to Redis');
9
}).catch((error) => {
10
  console.error('Error connecting to Redis:', error);
11
});
12

13
// 缓存中间件
14
const cache = (duration) => {
15
  return async (req, res, next) => {
16
    const key = `cache:${req.originalUrl}`;
17

18
    try {
19
      const cachedData = await redisClient.get(key);
20
      if (cachedData) {
21
        return res.json(JSON.parse(cachedData));
22
      }
23

24
      const originalSend = res.json;
25
      res.json = async (data) => {
26
        await redisClient.set(key, JSON.stringify(data), {
27
          EX: duration
28
        });
29
        originalSend.call(res, data);
30
      };
31

32
      next();
33
    } catch (error) {
34
      next();
35
    }
36
  };
37
};
38

39
// 应用缓存
40
app.get('/api/users', cache(3600), async (req, res) => {
41
  const users = await User.find();
42
  res.json(users);
43
});

6.3 负载均衡#

使用PM2：

1
npm install -g pm2

启动应用：

1
pm run build
2
pm run start:prod

配置PM2：

1
module.exports = {
2
  apps: [
3
    {
4
      name: 'myapp',
5
      script: 'index.js',
6
      instances: 'max',
7
      exec_mode: 'cluster',
8
      env: {
9
        NODE_ENV: 'development'
10
      },
11
      env_production: {
12
        NODE_ENV: 'production'
13
      }
14
    }
15
  ]
16
};

启动PM2：

1
pm run build
2
pm run start:prod

6.4 代码优化#

使用async/await： 异步代码更简洁，更易读。

使用Promise.all： 并行执行多个异步操作。

1
app.get('/api/dashboard', async (req, res) => {
2
  try {
3
    const [users, posts, comments] = await Promise.all([
4
      User.countDocuments(),
5
      Post.countDocuments(),
6
      Comment.countDocuments()
7
    ]);
8

9
    res.json({ users, posts, comments });
10
  } catch (error) {
11
    res.status(500).json({ message: error.message });
12
  }
13
});

避免阻塞操作： 避免在主线程中执行阻塞操作，如文件I/O、网络请求等。

使用流： 对于大文件，使用流处理。

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

4
app.get('/api/download', (req, res) => {
5
  const filePath = path.join(__dirname, 'large-file.txt');
6
  const stream = fs.createReadStream(filePath);
7
  stream.pipe(res);
8
});

7. 测试#

7.1 单元测试#

安装Jest：

1
npm install --save-dev jest

编写单元测试：

1
const { hashPassword, comparePassword } = require('./auth');
2

3
describe('Auth utils', () => {
4
  test('hashPassword should return hashed password', async () => {
5
    const password = 'password123';
6
    const hashedPassword = await hashPassword(password);
7
    expect(hashedPassword).not.toBe(password);
8
  });
9

10
  test('comparePassword should return true for correct password', async () => {
11
    const password = 'password123';
12
    const hashedPassword = await hashPassword(password);
13
    const result = await comparePassword(password, hashedPassword);
14
    expect(result).toBe(true);
15
  });
16

17
  test('comparePassword should return false for incorrect password', async () => {
18
    const password = 'password123';
19
    const wrongPassword = 'wrongpassword';
20
    const hashedPassword = await hashPassword(password);
21
    const result = await comparePassword(wrongPassword, hashedPassword);
22
    expect(result).toBe(false);
23
  });
24
});

运行测试：

1
npm test

7.2 集成测试#

安装supertest：

1
npm install --save-dev supertest

编写集成测试：

1
const request = require('supertest');
2
const app = require('./app');
3

4
describe('API endpoints', () => {
5
  test('GET /api/users should return 200', async () => {
6
    const response = await request(app).get('/api/users');
7
    expect(response.statusCode).toBe(200);
8
    expect(Array.isArray(response.body)).toBe(true);
9
  });
10

11
  test('POST /api/users should return 201', async () => {
12
    const user = { name: 'John', email: 'john@example.com', password: 'password123' };
13
    const response = await request(app).post('/api/users').send(user);
14
    expect(response.statusCode).toBe(201);
15
    expect(response.body.name).toBe(user.name);
16
  });
17
});

运行测试：

1
npm test

8. 部署#

8.1 部署到Heroku#

创建Heroku应用：

1
heroku create myapp

配置环境变量：

1
heroku config:set NODE_ENV=production
2
heroku config:set DATABASE_URL=mongodb://localhost:27017/myapp
3
heroku config:set JWT_SECRET=your-secret-key

部署应用：

1
git push heroku main

8.2 部署到AWS#

使用Elastic Beanstalk：

安装AWS CLI：npm install -g aws-cli
配置AWS CLI：aws configure
创建Elastic Beanstalk应用：eb init
部署应用：eb deploy

8.3 部署到Docker#

创建Dockerfile：

1
FROM node:18-alpine
2

3
WORKDIR /app
4

5
COPY package*.json ./
6

7
RUN npm install --production
8

9
COPY . .
10

11
EXPOSE 3000
12

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

创建docker-compose.yml：

1
version: '3'
2
services:
3
  app:
4
    build: .
5
    ports:
6
      - "3000:3000"
7
    environment:
8
      - NODE_ENV=production
9
      - DATABASE_URL=mongodb://mongo:27017/myapp
10
      - JWT_SECRET=your-secret-key
11
    depends_on:
12
      - mongo
13
  mongo:
14
    image: mongo:4.4
15
    ports:
16
      - "27017:27017"
17
    volumes:
18
      - mongo-data:/data/db
19
volumes:
20
  mongo-data:

构建和运行容器：

1
docker-compose up -d

9. 最佳实践#

9.1 项目结构#

1
myapp/
2
├── src/
3
│   ├── config/
4
│   │   └── database.js
5
│   ├── controllers/
6
│   │   └── userController.js
7
│   ├── middlewares/
8
│   │   ├── auth.js
9
│   │   └── errorHandler.js
10
│   ├── models/
11
│   │   └── User.js
12
│   ├── routes/
13
│   │   └── userRoutes.js
14
│   ├── utils/
15
│   │   └── auth.js
16
│   └── app.js
17
├── index.js
18
├── package.json
19
└── .env

9.2 代码风格#

使用ESLint和Prettier：

1
npm install --save-dev eslint prettier eslint-config-prettier eslint-plugin-prettier

配置ESLint：

1
module.exports = {
2
  env: {
3
    node: true,
4
    commonjs: true,
5
    es2021: true,
6
    jest: true
7
  },
8
  extends: [
9
    'eslint:recommended',
10
    'prettier'
11
  ],
12
  parserOptions: {
13
    ecmaVersion: 12
14
  },
15
  plugins: ['prettier'],
16
  rules: {
17
    'prettier/prettier': 'error'
18
  }
19
};

配置Prettier：

1
module.exports = {
2
  singleQuote: true,
3
  trailingComma: 'es5',
4
  tabWidth: 2,
5
  semi: true
6
};

9.3 错误处理#

统一错误处理：

1
const errorHandler = (err, req, res, next) => {
2
  err.statusCode = err.statusCode || 500;
3
  err.status = err.status || 'error';
4

5
  res.status(err.statusCode).json({
6
    status: err.status,
7
    message: err.message,
8
    stack: process.env.NODE_ENV === 'development' ? err.stack : undefined
9
  });
10
};
11

12
module.exports = errorHandler;
13

14
// app.js
15
const errorHandler = require('./middlewares/errorHandler');
16

17
app.use(errorHandler);

9.4 日志#

安装winston：

1
npm install winston

配置日志：

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

3
const logger = winston.createLogger({
4
  level: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
5
  format: winston.format.combine(
6
    winston.format.timestamp(),
7
    winston.format.json()
8
  ),
9
  transports: [
10
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
11
    new winston.transports.File({ filename: 'combined.log' })
12
  ]
13
});
14

15
if (process.env.NODE_ENV !== 'production') {
16
  logger.add(new winston.transports.Console({
17
    format: winston.format.simple()
18
  }));
19
}
20

21
module.exports = logger;
22

23
// 使用日志
24
const logger = require('./logger');
25

26
app.get('/api/users', async (req, res) => {
27
  try {
28
    const users = await User.find();
29
    logger.info('Fetched users');
30
    res.json(users);
31
  } catch (error) {
32
    logger.error('Error fetching users:', error);
33
    res.status(500).json({ message: 'Internal server error' });
34
  }
35
});

9.5 安全#

安装helmet和cors：

1
npm install helmet cors

使用helmet和cors：

1
const helmet = require('helmet');
2
const cors = require('cors');
3

4
app.use(helmet());
5
app.use(cors());
6

7
// 防止XSS攻击
8
app.use((req, res, next) => {
9
  res.setHeader('X-XSS-Protection', '1; mode=block');
10
  next();
11
});
12

13
// 防止CSRF攻击
14
const csrf = require('csurf');
15
const csrfProtection = csrf({ cookie: true });
16
app.use(csrfProtection);
17

18
app.get('/api/csrf-token', (req, res) => {
19
  res.json({ csrfToken: req.csrfToken() });
20
});

10. 总结#

Node.js和Express为我们提供了一种强大、灵活的方式来构建后端应用。通过本文介绍的各种技术和最佳实践，你可以：

构建高性能、可维护的后端应用
集成各种数据库
实现认证和授权
优化应用性能
编写测试
部署应用到各种平台

希望本文对你有所帮助，祝你编码愉快！

私のブログ