1
客户端发起连接 → 中间件验证 → 连接建立/拒绝 → 触发相应事件

1
io.use((socket, next) => {
2
  // 验证逻辑
3
  if (验证通过) {
4
    next(); // 继续连接流程
5
  } else {
6
    next(new Error("错误信息")); // 拒绝连接并传递错误
7
  }
8
});

1
// ✅ 正确方式：在中间件中传递错误
2
io.use((socket, next) => {
3
  try {
4
    const token = socket.handshake.auth.token;
5
    if (!token) {
6
      // 通过 next 传递错误到客户端
7
      return next(new Error("Authentication error: No token provided"));
8
    }
9

10
    jwt.verify(token, SECRET_KEY);
11
    next(); // 验证通过，继续连接
12
  } catch (err) {
13
    // JWT验证失败
14
    next(new Error("Authentication error: Invalid token"));
15
  }
16
});

1
const socket = io({
2
  auth: {
3
    token: "your_token_here",
4
  },
5
});
6

7
// 连接成功事件
8
socket.on("connect", () => {
9
  console.log("✅ 连接成功");
10
});
11

12
// 连接错误事件 - 接收中间件传递的错误
13
socket.on("connect_error", (error) => {
14
  console.log("❌ 连接失败:", error.message);
15
  // error.message 包含服务端 next(new Error()) 中的错误信息
16
});

1
// 问题：连接已建立，disconnect 不会触发 connect_error
2
io.on("connection", (socket) => {
3
  const token = socket.handshake.auth.token;
4
  if (!token) {
5
    socket.disconnect(true); // 客户端不会收到 connect_error
6
    return;
7
  }
8
});

1
// 解决方案：在连接建立前验证
2
io.use((socket, next) => {
3
  const token = socket.handshake.auth.token;
4
  if (!token) {
5
    next(new Error("No token provided")); // 正确触发 connect_error
6
    return;
7
  }
8
  next(); // 验证通过
9
});

1
// 中间件1：基础验证
2
io.use((socket, next) => {
3
  console.log("中间件1：基础验证");
4
  next();
5
});
6

7
// 中间件2：Token验证
8
io.use((socket, next) => {
9
  console.log("中间件2：Token验证");
10
  const token = socket.handshake.auth.token;
11
  if (!token) {
12
    return next(new Error("Missing token"));
13
  }
14
  next();
15
});
16

17
// 中间件3：权限检查
18
io.use((socket, next) => {
19
  console.log("中间件3：权限检查");
20
  // 其他验证逻辑...
21
  next();
22
});

1
io.use((socket, next) => {
2
  try {
3
    const decoded = jwt.verify(token, SECRET_KEY);
4
    // 将解码后的用户信息挂载到 socket 对象
5
    socket.user = decoded;
6
    next();
7
  } catch (err) {
8
    next(new Error("Invalid token"));
9
  }
10
});
11

12
// 在连接处理器中可以访问 socket.user
13
io.on("connection", (socket) => {
14
  console.log("用户信息:", socket.user); // 可以访问中间件中设置的数据
15
});

1
io.use((socket, next) => {
2
  const token = socket.handshake.auth.token;
3
  if (!token) {
4
    return next(new Error("Authentication required"));
5
  }
6

7
  try {
8
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
9
    socket.userId = decoded.userId;
10
    socket.userRole = decoded.role;
11
    next();
12
  } catch (err) {
13
    next(new Error("Invalid authentication token"));
14
  }
15
});

1
io.use((socket, next) => {
2
  const clientIP = socket.handshake.address;
3
  const allowedIPs = ["127.0.0.1", "192.168.1.0/24"];
4

5
  if (!isIPAllowed(clientIP, allowedIPs)) {
6
    return next(new Error("IP address not allowed"));
7
  }
8
  next();
9
});

1
const connectionAttempts = new Map();
2

3
io.use((socket, next) => {
4
  const clientIP = socket.handshake.address;
5
  const now = Date.now();
6
  const attempts = connectionAttempts.get(clientIP) || [];
7

8
  // 清理1分钟前的记录
9
  const recentAttempts = attempts.filter((time) => now - time < 60000);
10

11
  if (recentAttempts.length >= 10) {
12
    return next(new Error("Too many connection attempts"));
13
  }
14

15
  recentAttempts.push(now);
16
  connectionAttempts.set(clientIP, recentAttempts);
17
  next();
18
});