如何使用local-passport启动多用户REST服务器并验证用户属性

我来一步步教你怎么用Passport-Local搭建支持多用户的REST服务器，并且用appkey+password做身份验证——这是我实际项目里常用的方案，亲测好用：

1. 初始化项目并安装依赖 #

首先创建项目目录，初始化npm，然后安装核心依赖：

mkdir passport-local-rest && cd passport-local-rest
npm init -y
npm install express passport passport-local bcryptjs jsonwebtoken mongoose

• express: 搭建REST服务器的基础框架
• passport & passport-local: 处理本地身份验证逻辑
• bcryptjs: 安全加密用户密码，避免明文存储风险
• jsonwebtoken: 生成JWT令牌，用于后续API请求的身份校验
• mongoose: 操作MongoDB数据库（如果用其他数据库，比如MySQL，可以换成sequelize等工具）

2. 定义用户数据模型 #

我们需要一个用户模型来存储唯一的appkey和加密后的密码。在models/User.js中编写：

const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');

const userSchema = new mongoose.Schema({
  appkey: {
    type: String,
    required: true,
    unique: true, // 确保appkey全局唯一
    trim: true
  },
  password: {
    type: String,
    required: true,
    minlength: 6 // 设置密码最小长度，提升安全性
  }
});

// 保存用户前自动加密密码
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  // 盐值设为12，平衡加密强度和性能
  this.password = await bcrypt.hash(this.password, 12);
  next();
});

// 定义密码验证方法，供后续Passport调用
userSchema.methods.correctPassword = async function(candidatePassword) {
  return await bcrypt.compare(candidatePassword, this.password);
};

module.exports = mongoose.model('User', userSchema);

3. 配置Passport-Local验证策略 #

默认Passport-Local用username作为用户标识字段，我们需要改成appkey。在config/passport.js中配置：

const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const User = require('../models/User');

// 自定义本地验证策略
passport.use(new LocalStrategy({
  usernameField: 'appkey' // 替换默认的username字段为appkey
}, async (appkey, password, done) => {
  try {
    // 根据appkey查找用户
    const user = await User.findOne({ appkey });
    if (!user) {
      return done(null, false, { message: '无效的AppKey' });
    }
    // 验证密码是否匹配
    const isMatch = await user.correctPassword(password);
    if (!isMatch) {
      return done(null, false, { message: '密码错误' });
    }
    // 验证通过，返回用户信息
    return done(null, user);
  } catch (err) {
    return done(err);
  }
}));

4. 搭建Express服务器和API路由 #

创建server.js，整合所有配置和业务路由：

const express = require('express');
const mongoose = require('mongoose');
const passport = require('passport');
const jwt = require('jsonwebtoken');
const User = require('./models/User');
require('./config/passport'); // 加载Passport配置

const app = express();
const PORT = process.env.PORT || 3000;
// 生产环境务必将密钥存入环境变量，不要硬编码！
const JWT_SECRET = process.env.JWT_SECRET || 'your-strong-secret-key-here';

// 中间件配置
app.use(express.json()); // 解析JSON格式的请求体
app.use(passport.initialize()); // 初始化Passport

// 连接MongoDB数据库
mongoose.connect('mongodb://localhost:27017/passport-rest', {
  useNewUrlParser: true,
  useUnifiedTopology: true
})
.then(() => console.log('数据库连接成功'))
.catch(err => console.error('数据库连接失败:', err));

// 1. 用户注册API
app.post('/api/signup', async (req, res) => {
  try {
    const { appkey, password } = req.body;
    // 检查appkey是否已被注册
    const existingUser = await User.findOne({ appkey });
    if (existingUser) {
      return res.status(400).json({ message: '该AppKey已被使用' });
    }
    // 创建新用户（密码会自动加密）
    const user = await User.create({ appkey, password });
    res.status(201).json({ message: '用户创建成功', appkey: user.appkey });
  } catch (err) {
    res.status(500).json({ message: '服务器错误', error: err.message });
  }
});

// 2. 用户登录API，返回JWT令牌
app.post('/api/login', passport.authenticate('local', { session: false }), (req, res) => {
  // 生成有效期7天的JWT令牌
  const token = jwt.sign(
    { id: req.user._id, appkey: req.user.appkey },
    JWT_SECRET,
    { expiresIn: '7d' }
  );
  res.json({
    message: '登录成功',
    token,
    user: { appkey: req.user.appkey }
  });
});

// 3. JWT验证中间件，用于保护需要登录才能访问的API
const protect = (req, res, next) => {
  let token;
  // 从请求头的Authorization字段提取Bearer令牌
  if (req.headers.authorization && req.headers.authorization.startsWith('Bearer')) {
    token = req.headers.authorization.split(' ')[1];
  }
  if (!token) {
    return res.status(401).json({ message: '未授权，请先登录' });
  }
  // 验证令牌有效性
  try {
    const decoded = jwt.verify(token, JWT_SECRET);
    req.user = decoded; // 将解码后的用户信息挂载到req对象
    next();
  } catch (err) {
    res.status(401).json({ message: '令牌无效或已过期' });
  }
};

// 受保护的API示例
app.get('/api/protected', protect, (req, res) => {
  res.json({
    message: '成功访问受保护资源',
    currentUser: req.user.appkey
  });
});

// 启动服务器
app.listen(PORT, () => {
  console.log(`服务器运行在 http://localhost:${PORT}`);
});

5. 测试API接口 #

你可以用Postman或curl测试接口：

• 注册用户：POST请求http://localhost:3000/api/signup，请求体JSON：

  {
    "appkey": "test_user_01",
    "password": "your-secure-password"
  }
  

• 登录获取令牌：POST请求http://localhost:3000/api/login，请求体同上，会返回JWT令牌。
• 访问受保护接口：GET请求http://localhost:3000/api/protected，请求头添加Authorization: Bearer <你的JWT令牌>，即可成功访问。

关键注意事项 #

• 生产环境安全：JWT密钥必须存入环境变量，禁止硬编码；建议启用HTTPS协议传输数据；可以根据需求调整密码加密的盐值和JWT有效期。
• 错误处理：实际项目中可以完善错误捕获逻辑，返回更友好的错误信息，方便前端处理。
• 数据库适配：如果不用MongoDB，只需替换用户模型的实现（比如用MySQL的话，改用sequelize定义模型，查询逻辑换成SQL语句即可）。

内容的提问来源于stack exchange，提问作者T_murder