Nodejs implémente la connexion Android

Dans le développement d'applications mobiles, la connexion des utilisateurs est l'une des fonctions essentielles. Dans les clients Android, la vérification de la connexion en demandant l'interface du serveur est une méthode d'implémentation courante. Côté serveur, un simple service d'interface de vérification de connexion peut être rapidement créé à l'aide de Node.js. Cet article aidera les lecteurs à comprendre comment utiliser Node.js pour implémenter la fonction de connexion Android en présentant des connaissances pertinentes et un exemple de code de Node.js.

1. Introduction à Node.js

Node.js est un environnement d'exécution JavaScript multiplateforme open source. Il est basé sur le modèle d'événements d'E/S asynchrones et piloté par les événements et peut rapidement créer des performances élevées et évolutives. applications réseau. Node.js est basé sur le moteur V8 et implémente un mécanisme de boucle d'événements efficace en encapsulant l'API d'E/S asynchrone fournie par la bibliothèque libuv, ce qui permet à Node.js de bien fonctionner dans la gestion d'un grand nombre de connexions simultanées et de charges de travail élevées. Dans le même temps, Node.js fournit également une multitude de bibliothèques standard et de modules tiers pour permettre aux développeurs de créer rapidement diverses applications Web, applications serveur, outils de ligne de commande et autres applications.

2. Processus de connexion Android

Avant de présenter les détails spécifiques de l'implémentation de Node.js pour implémenter la connexion Android, commençons par trier le processus de base de la connexion Android :

1. L'utilisateur ouvre le client Android, clique sur le bouton de connexion. , et saisit le nom d'utilisateur et le mot de passe, soumettez une demande de connexion.
2. Le client envoie des informations de connexion telles que le nom d'utilisateur et le mot de passe au serveur via une requête HTTP.
3. Après avoir reçu la demande de connexion, le serveur vérifie le nom d'utilisateur et le mot de passe saisis par l'utilisateur. En cas de succès, il renvoie un jeton indiquant une connexion réussie, sinon il renvoie un message d'échec de connexion.
4. Une fois que le client a reçu le jeton de connexion réussie, il l'enregistre localement pour les demandes ultérieures.
5. Le client demande l'interface API qui nécessite une vérification de connexion en portant le jeton. Le serveur détermine si la connexion est valide en vérifiant le jeton. Si elle est valide, les informations de données correspondantes seront renvoyées. Sinon, un message d'erreur indiquant que. la connexion n'est pas valide ou n'est pas connecté sera renvoyé.

Selon le processus ci-dessus, les principales fonctions que nous devons implémenter côté serveur sont : recevoir les demandes de connexion, vérifier les informations de l'utilisateur, générer et renvoyer des jetons, vérifier si le jeton est valide, etc.

3. Implémentation Node.js d'un exemple de connexion Android

Voici un exemple de code pour utiliser Node.js pour implémenter la connexion Android :

1. Interface de demande de connexion (login.js)

const express = require('express');
const bodyParser = require('body-parser');
const jwt = require('jsonwebtoken');
const secretKey = 'mySecretKey'; //Token加密密钥
const app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

//处理登录请求
app.post('/api/login', (req, res) => {
  const { username, password } = req.body;
  //TODO: 用户信息验证
  if (username === 'test' && password === '123456') {
    //生成AccessToken
    const payload = { username };
    const accessToken = jwt.sign(payload, secretKey, { expiresIn: '1h' });
    res.json({ code: 200, msg: '登录成功', accessToken });
  } else {
    res.json({ code: 401, msg: '用户名或密码错误' });
  }
});

const server = app.listen(3000, () => {
  console.log(`Server listening at http://${server.address().address}:${server.address().port}`);
});

2. Middleware de vérification de jeton ( auth.js )

const jwt = require('jsonwebtoken');
const secretKey = 'mySecretKey'; //Token加密密钥

//Token验证中间件
module.exports = (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];
  if (token == null) {
    return res.status(401).json({ code: 401, msg: '未登录或Token已过期' });
  }
  jwt.verify(token, secretKey, (err, user) => {
    if (err) {
      return res.status(403).json({ code: 403, msg: 'Token验证失败' });
    }
    req.user = user;
    next();
  });
};

3. Interface de vérification de connexion (user.js)

const express = require('express');
const auth = require('./auth.js');
const app = express();

app.get('/api/user', auth, (req, res) => {
  const { username } = req.user;
  //TODO: 获取用户信息并返回
  res.json({ code: 200, msg: '获取用户信息成功', data: { username } });
});

const server = app.listen(3000, () => {
  console.log(`Server listening at http://${server.address().address}:${server.address().port}`);
});

Description :

• Dans login.js, nous utilisons le framework Express pour traiter les requêtes HTTP, recevoir les requêtes de connexion via la méthode POST et vérifier les informations de l'utilisateur. Après avoir vérifié avec succès les informations utilisateur, utilisez la bibliothèque jsonwebtoken pour générer un AccessToken et le renvoyer au client sous forme de données JSON.
• Dans auth.js, nous définissons un middleware de vérification de jeton, qui est utilisé pour vérifier si le jeton dans l'en-tête de la requête est valide lors du traitement des requêtes d'interface API qui nécessitent une vérification de connexion. Si le jeton a expiré ou qu'une erreur se produit lors du déchiffrement du jeton, le message d'erreur correspondant sera renvoyé.
• Dans user.js, nous définissons une interface API qui nécessite une vérification de connexion, qui utilise le middleware de vérification de jeton défini ci-dessus. Si la vérification de la connexion réussit, vous pouvez obtenir les informations de l'utilisateur connecté via req.user, puis obtenir les informations utilisateur pertinentes via la section TODO et les renvoyer au client sous forme de données JSON.

4. Comment implémenter la demande de connexion dans le client Android

Dans le client Android, vous pouvez utiliser la bibliothèque de requêtes HTTP pour envoyer des requêtes HTTP à l'interface de connexion. Après avoir reçu le jeton pour une connexion réussie, enregistrez-le dans SharedPreferences pour qu'il puisse être utilisé par d'autres interfaces nécessitant une vérification de connexion. Voici un exemple de code simple permettant d'utiliser la bibliothèque OkHttp3 pour effectuer une demande de connexion :

private void login(String username, String password) {
  OkHttpClient client = new OkHttpClient();
  MediaType JSON = MediaType.parse("application/json; charset=utf-8");
  JSONObject requestBody = new JSONObject();
  try {
    requestBody.put("username", username).put("password", password);
  } catch (JSONException e) {
    e.printStackTrace();
  }
  RequestBody body = RequestBody.create(JSON, requestBody.toString());
  Request request = new Request.Builder()
    .url("http://your-server-host/api/login")
    .post(body)
    .build();
  client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
      e.printStackTrace();
      //TODO: 处理请求失败
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
      try (ResponseBody responseBody = response.body()) {
        String responseStr = responseBody.string();
        JSONObject jsonObject = new JSONObject(responseStr);
        int code = jsonObject.getInt("code");
        if (code == 200) {
          String accessToken = jsonObject.getString("accessToken");
          //将accessToken保存在SharedPreferences中
        } else {
          String msg = jsonObject.getString("msg");
          //TODO: 处理登录失败
        }
      } catch (JSONException e) {
        e.printStackTrace();
      }
    }
  });
}

Instructions :

• Tout d'abord, vous devez introduire la bibliothèque OkHttp3 dans le projet Android et définir les méthodes de demande d'interface pertinentes dans le projet, comme la méthode login() ci-dessus.
• Dans la méthode login(), nous utilisons l'objet OkHttpClient pour créer une requête POST et envoyer des informations de connexion telles que le nom d'utilisateur et le mot de passe au serveur au format de données JSON. Après avoir reçu la réponse du serveur, analysez les données JSON de la réponse et enregistrez le accessToken localement pour une utilisation ultérieure.

5. Résumé

Cet article présente comment utiliser Node.js pour implémenter l'interface de vérification de connexion Android et démontre son processus d'implémentation de base à travers un exemple de code. Dans les projets réels, afin de garantir la sécurité de la connexion, des problèmes tels que le cryptage de la transmission des données, le stockage crypté par mot de passe et la connexion multiterminal doivent également être pris en compte. Grâce à une amélioration et une optimisation continues, un système de vérification de connexion plus complet, sécurisé et efficace peut être créé.

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!