Comment se connecter au backend avec nodejs

En tant qu'outil de développement pour la mise en œuvre d'un environnement d'exécution JavaScript côté serveur, Node.js a progressivement été largement utilisé. Node.js fournit un moyen d'écrire des applications réseau de manière événementielle, permettant aux développeurs de configurer facilement des serveurs et de créer des applications Web.

Dans de nombreuses applications Web, la connexion des utilisateurs est un élément très important. Les administrateurs doivent se connecter au système de gestion backend pour gérer les données et les activités. Par conséquent, dans Node.js, il est nécessaire d'implémenter une authentification de connexion de base. Ce processus nécessite une série d'opérations telles que l'authentification de l'identité de l'utilisateur et la gestion des rappels.

Cet article présentera certaines méthodes d'authentification de connexion courantes dans Node.js, notamment l'utilisation d'un middleware, la gestion de session et l'utilisation du jeton Web JSON (JWT) pour implémenter l'authentification par jeton.

Utilisation du Middleware

Dans Node.js, le middleware est un concept important qui gère les requêtes HTTP et permet de modifier la réponse ainsi que la décision de transmettre la requête au middleware suivant. Par conséquent, la mise en œuvre de la fonction de connexion peut également être réalisée via un middleware.

Le plus grand avantage de l'utilisation d'un middleware est qu'il peut améliorer la lisibilité et la maintenabilité du code. Dans le même temps, cela peut également réduire les modules de code répétés.

Exemple de code :

const express = require('express');
const app = express();
const port = 3000;

//中间件
app.use(express.urlencoded({extended: false}));
app.use(express.json());

//登录页面
app.get('/login', function(req, res) {
  res.sendFile(__dirname + '/login.html');
});

//登录验证
app.post('/login', function(req, res){
  const username = req.body.username;
  const password = req.body.password;

  if(username === 'admin' && password === '123456'){
    // 验证成功，则可以将用户信息存储到session中
    req.session.userinfo = req.body;
    res.send('登录成功');
  }else{
    res.send('用户名或密码错误！');
  }
});

app.listen(port, function(){
  console.log(`Server is running on port ${port}`);
});

Dans le code ci-dessus, nous utilisons le middleware express pour gérer les requêtes et les réponses HTTP, et le middleware express-session pour la gestion des sessions utilisateur . express中间件来处理HTTP请求和响应，并使用express-session中间件对用户会话进行管理。

使用session会话管理

在Web开发实践中，session是指在服务器端存储信息的一种机制。它以key-value的形式存储，key是sessionID，而value是一个JSON格式的对象，可以存储用户的身份信息、权限信息等。

Node.js中实现基本的会话管理需要使用express-session中间件。在使用express-session中间件时，需要设置一个参数secret用于签名，这样可以保证session的安全性。同时，需要设置resave参数和saveUnitialized参数为false，这可以避免session的重写和保存未初始化的session。

代码示例：

const express = require('express');
const app = express();
const session = require('express-session');
const port = 3000;

//使用express-session中间件
app.use(session({
  secret: 'sessiontest',
  resave: false,
  saveUnitialized: false,
  cookie: {
    maxAge: 1000 * 60 * 30
  }
}));

// 登录页面
app.get('/login', function(req, res) {
  res.sendFile(__dirname + '/login.html');
});

//登录验证
app.post('/login', function(req, res){
  const username = req.body.username;
  const password = req.body.password;

  if(username === 'admin' && password === '123456'){
    // 验证成功，则可以将用户信息存储到session中
    req.session.userinfo = req.body;
    res.send('登录成功');
  }else{
    res.send('用户名或密码错误！');
  }
});

//后台页面
app.get('/admin', function(req, res){
    // 验证session中是否存储了用户信息
    const userinfo = req.session.userinfo;
    if(userinfo && userinfo.username){
        res.sendFile(__dirname + '/admin.html');
    }else{
        //如果未存储，则重定向到登录页面
        res.redirect('/login');
    }
});

app.listen(port, function(){
  console.log(`Server is running on port ${port}`);
});

使用JSON Web Token（JWT）实现token认证

除了使用session来管理用户登录状态之外，还可以使用JSON Web Token（JWT）实现token认证。JWT是一种轻量、安全、灵活的身份验证协议。在该协议中，服务器生成一个包含用户信息的token，然后将该token返回给客户端。后续的请求都需要在HTTP头中携带该token。

使用JWT的好处在于它不需要在服务器上存储用户信息，而是将用户信息编码到token中，这样就减轻了服务器的存储压力。同时，由于token包含了用户信息，因此可以在客户端和服务器端之间轻易地传递用户身份信息。

要使用JWT，需要使用jsonwebtoken库来实现查询操作，该库可以在node.js中工作和浏览器中工作。在使用jsonwebtoken

Utiliser la gestion de session

Dans la pratique du développement Web, la session fait référence à un mécanisme de stockage d'informations côté serveur. Elle est stockée sous forme de clé-valeur. La clé est l'ID de session et la valeur est un objet au format JSON, qui peut stocker les informations d'identité de l'utilisateur, les informations d'autorisation, etc.

Pour implémenter la gestion de session de base dans Node.js, vous devez utiliser le middleware express-session. Lorsque vous utilisez le middleware express-session, vous devez définir un paramètre secret pour la signature, qui peut garantir la sécurité de la session. Dans le même temps, vous devez définir le paramètre resave et le paramètre saveUnitialized sur false, ce qui peut éviter la réécriture de session et l'enregistrement de sessions non initialisées. 🎜🎜Exemple de code : 🎜

const express = require('express');
const jwt = require('jsonwebtoken');
const app = express();
const port = 3000;

//生成Token
app.post('/login', function(req, res){
  const username = req.body.username;
  const password = req.body.password;

  if(username === 'admin' && password === '123456'){
    const userinfo = {
      name: username
    }
    //在jsonwebtoken中生成Token
    jwt.sign(userinfo, 'secretkey', {expiresIn: '10min'}, function(err, token){
      if(err) throw err;
      res.json({
        token: token
      });
    })
  }else{
    res.send('用户名或密码错误！');
  }
});

// 验证Token
app.get('/admin', verifyToken, function(req, res){
  res.sendFile(__dirname + '/admin.html');
});

//中间件，用于验证Token
function verifyToken(req, res, next){
  //从请求头中获取Token
  const bearerHeader = req.hearders['authorization'];
  if(typeof bearerHeader !== 'undefined'){
    const bearerToken = bearerHeader.split(' ')[1];
    // 在jsonwebtoken中验证Token
    jwt.verify(bearerToken, 'secretkey', function(err, data){
      if(err) res.sendStatus(403);
      req.userinfo = data;
      next();
    });
  }else{
    res.sendStatus(403);
  }
};

app.listen(port, function(){
  console.log(`Server is running on port ${port}`);
});

🎜Utilisez JSON Web Token (JWT) pour implémenter l'authentification par jeton🎜🎜En plus d'utiliser la session pour gérer l'état de connexion des utilisateurs, vous pouvez également utiliser JSON Web Token (JWT) pour implémenter l'authentification par jeton. JWT est un protocole d'authentification léger, sécurisé et flexible. Dans ce protocole, le serveur génère un jeton contenant les informations utilisateur, puis renvoie le jeton au client. Les requêtes suivantes doivent porter le jeton dans l'en-tête HTTP. 🎜🎜L'avantage d'utiliser JWT est qu'il n'a pas besoin de stocker les informations utilisateur sur le serveur, mais encode les informations utilisateur dans le jeton, ce qui réduit la pression de stockage sur le serveur. Dans le même temps, puisque le jeton contient des informations sur l'utilisateur, les informations sur l'identité de l'utilisateur peuvent être facilement transférées entre le client et le serveur. 🎜🎜Pour utiliser JWT, vous devez utiliser la bibliothèque jsonwebtoken pour implémenter les opérations de requête. Cette bibliothèque peut fonctionner dans node.js et dans le navigateur. Lorsque vous utilisez jsonwebtoken, vous devez définir une clé et une période de validité pour garantir que le jeton généré peut être authentifié et accepté. 🎜🎜Exemple de code : 🎜rrreee🎜Grâce à la méthode ci-dessus, nous pouvons implémenter la fonction d'authentification de connexion de base dans Node.js. Différentes solutions peuvent être sélectionnées en fonction des besoins spécifiques de l'entreprise. Dans le même temps, vous devez également prêter attention à la sécurité et à la stabilité de la connexion pour garantir qu’aucune faille ne se produira et que les données des utilisateurs ne seront endommagées. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!