nodejs implements mvc

Node.js is an open source, cross-platform JavaScript runtime environment. It enables us to write server-side applications using JavaScript. It's easy to develop high-performance server-side applications using Node.js. In this article, we'll cover how to implement an MVC architecture using Node.js.

1. What is MVC?

MVC is the abbreviation of Model-View-Controller. It is a design pattern that organizes code in a way that separates the application and makes the application easy to maintain and extend.

• Model: Contains all application data and related business logic.
• View: User interface, which obtains data from the Model and presents it to the user.
• Controller: handles the interaction between the user interface and business logic and returns the results to the user interface. It can act as a middleware such as routing, middleware and controller.

MVC makes the code very modular, making it easy to refactor and maintain different parts of the application. In Node.js, we can use various frameworks to build MVC applications. In this article, we will discuss how to implement MVC architecture using Express framework.

2. How to implement MVC using Express framework?

Express is a popular framework for Node.js that provides tools and middleware for quickly building web applications. We can implement MVC using Express framework.

First, we need to install the Express framework. Use the following command in the command line:

npm install express --save

Next, we need to install the template engine. In this article, we will use EJS as the template engine. Use the following command on the command line:

npm install ejs --save

Here is a basic directory structure:

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

We divide the application into three components: controller, model, and view.

3. Controller

In the controller folder, we will define our controller logic. For example, we can have a file called userController.js which will handle user related requests.

In the userController.js file, we can export different objects and methods to use them in the application. Here is an example:

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;

In the above code, we define an object named UserController and export two methods: index and show. These methods will get the user data and pass it to the EJS template engine for rendering. We can use these methods in our application's routes to handle user requests.

4. Model

In the models folder, we will define the logic of the Model layer. For example, we can have a file called user.js that will define user-related data and business logic.

In the user.js file, we can use Node.js’s ORM (Object Relational Mapping) framework to define the model. Here is an example:

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;

In the above code, we export an object named User and define two methods: getAll and getById. These methods will execute the SQL query and pass the results back to the controller.

5. Views

In the views folder we will define our EJS view files. For example, we could have a file called index.ejs that renders data for all users.

Here is an example:

<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>
<% } %>

In the above code, we will use EJS syntax to render all the users and create the list. We pass user data in the controller and render it in the view.

6. Routes

In the routes folder we will define the routes for our application. In the app.js file we will configure our middleware. Here is an example:

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}.`);
});

In the above code, we have defined two routes: one to render data for all users and another to render data for a single user. We also configured middleware that allows us to use the EJS template engine and consume static files. Finally, we started the server.

7. Summary

In this article, we implemented the MVC architecture using the Express framework. We divide the application into three components: controller, model, and view. We also used the Node.js ORM framework to define the models and the EJS template engine to render the views. Finally, we use routing to handle user requests and pass data back to controllers and views.

The MVC architecture of Node.js helps greatly simplify the maintenance and scaling of applications. In addition, the Express framework provides many useful tools and middleware that can help us build web applications faster.

The above is the detailed content of nodejs implements mvc. For more information, please follow other related articles on the PHP Chinese website!