nodejs implémente mvc

Node.js est un environnement d'exécution JavaScript open source et multiplateforme. Il nous permet d'écrire des applications côté serveur en utilisant JavaScript. Il est facile de développer des applications côté serveur hautes performances à l'aide de Node.js. Dans cet article, nous verrons comment implémenter une architecture MVC à l'aide de Node.js.

1. Qu'est-ce que MVC ?

MVC est l'abréviation de Model-View-Controller. Il s'agit d'un modèle de conception qui organise le code de manière à séparer l'application et à la rendre facile à maintenir et à étendre.

• Modèle : contient toutes les données d'application et la logique métier associée.
• Vue : interface utilisateur, qui récupère les données du modèle et les présente à l'utilisateur.
• Contrôleur : gère l'interaction entre l'interface utilisateur et la logique métier et renvoie les résultats à l'interface utilisateur. Il peut agir comme un middleware tel que le routage, le middleware et le contrôleur.

MVC rend le code très modulaire, ce qui facilite la refactorisation et la maintenance de différentes parties de l'application. Dans Node.js, nous pouvons utiliser différents frameworks pour créer des applications MVC. Dans cet article, nous verrons comment implémenter l'architecture MVC à l'aide du framework Express.

2. Comment implémenter MVC à l'aide du framework Express ?

Express est un framework populaire pour Node.js qui fournit des outils et des middlewares pour créer rapidement des applications Web. Nous pouvons implémenter MVC en utilisant le framework Express.

Tout d’abord, nous devons installer le framework Express. Utilisez la commande suivante dans la ligne de commande :

npm install express --save

Ensuite, nous devons installer le moteur de modèle. Dans cet article, nous utiliserons EJS comme moteur de modèle. Utilisez la commande suivante dans la ligne de commande :

npm install ejs --save

Voici une structure de répertoires de base :

- app/
    - controllers/
    - models/
    - views/
- public/
- routes/
- app.js

Nous divisons l'application en trois composants : contrôleur, modèle et vue.

3. Contrôleurs

Dans le dossier contrôleur, nous définirons notre logique de contrôleur. Par exemple, nous pouvons avoir un fichier appelé userController.js qui gérera les requêtes liées aux utilisateurs.

Dans le fichier userController.js, nous pouvons exporter différents objets et méthodes pour les utiliser dans l'application. Voici un exemple :

const User = require('../models/user');

const UserController = {};

UserController.index = (req, res) => {
    // 获取所有用户
    User.getAll((err, users) => {
        if (err) {
            console.log(err);
            return;
        }
        // 渲染视图
        res.render('users/index', { users });
    });
};

UserController.show = (req, res) => {
    // 获取单个用户
    User.getById(req.params.id, (err, user) => {
        if (err) {
            console.log(err);
            return;
        }
        // 渲染视图
        res.render('users/show', { user });
    });
};

module.exports = UserController;

Dans le code ci-dessus, nous définissons un objet appelé UserController et exportons deux méthodes : index et show. Ces méthodes obtiendront les données utilisateur et les transmettront au moteur de modèle EJS pour le rendu. Nous pouvons utiliser ces méthodes dans les routes de notre application pour gérer les demandes des utilisateurs.

4. Modèle

Dans le dossier models, nous définirons la logique de la couche Model. Par exemple, nous pouvons avoir un fichier appelé user.js qui définira les données relatives à l'utilisateur et la logique métier.

Dans le fichier user.js, nous pouvons utiliser le framework ORM (Object Relational Mapping) de Node.js pour définir le modèle. Voici un exemple :

const sql = require('../config/db').pool;

const User = {};

User.getAll = (callback) => {
    sql.query('SELECT * FROM users', (err, users) => {
        if (err) {
            callback(err, null);
            return;
        }
        callback(null, users);
    });
};

User.getById = (id, callback) => {
    sql.query('SELECT * FROM users WHERE id = ?', [id], (err, user) => {
        if (err) {
            callback(err, null);
            return;
        }
        callback(null, user[0]);
    });
};

module.exports = User;

Dans le code ci-dessus, nous exportons un objet nommé User et définissons deux méthodes : getAll et getById. Ces méthodes exécuteront la requête SQL et transmettront les résultats au contrôleur.

5. Vues

Dans le dossier vues, nous définirons nos fichiers de vue EJS. Par exemple, nous pourrions avoir un fichier appelé index.ejs qui restitue les données pour tous les utilisateurs.

Voici un exemple :

<h1>All Users</h1>

<% if (users && users.length > 0) { %>
  <ul>
    <% users.forEach(function(user) { %>
      <li><a href="/users/<%= user.id %>"><%= user.name %></a></li>
    <% }); %>
  </ul>
<% } else { %>
  <p>No users found.</p>
<% } %>

Dans le code ci-dessus, nous utiliserons la syntaxe EJS pour restituer tous les utilisateurs et créer la liste. Nous transmettons les données utilisateur dans le contrôleur et les restituons dans la vue.

6. Routing

Dans le dossier routes, nous définirons les routes pour notre application. Dans le fichier app.js nous allons configurer notre middleware. Voici un exemple :

const express = require('express');
const app = express();
const router = express.Router();
const UserController = require('./app/controllers/userController');

// 路由
router.get('/', UserController.index);
router.get('/users/:id', UserController.show);

// 中间件
app.use(express.static('public'));
app.use(express.urlencoded({ extended: true }));
app.set('view engine', 'ejs');
app.set('views', __dirname + '/app/views');
app.use(router);

// 启动服务器
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server listening on port ${PORT}.`);
});

Dans le code ci-dessus, nous avons défini deux routes : une pour restituer les données pour tous les utilisateurs et une autre pour restituer les données pour un seul utilisateur. Nous avons également configuré un middleware qui nous permet d'utiliser le moteur de modèles EJS et de consommer des fichiers statiques. Enfin, nous avons démarré le serveur.

7. Résumé

Dans cet article, nous avons implémenté l'architecture MVC à l'aide du framework Express. Nous divisons l'application en trois composants : contrôleur, modèle et vue. Nous avons également utilisé le framework ORM Node.js pour définir les modèles et le moteur de modèles EJS pour restituer les vues. Enfin, nous utilisons le routage pour gérer les demandes des utilisateurs et transmettre les données aux contrôleurs et aux vues.

L'architecture MVC de Node.js permet de simplifier considérablement la maintenance et la mise à l'échelle des applications. De plus, le framework Express fournit de nombreux outils et middleware utiles qui peuvent nous aider à créer des applications Web plus rapidement.

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!