Express implementa o modelo de desenvolvimento MVC

Código da camada do controlador

var mongoose = require("mongoose");

var docModel = require("../models/doc.server.model");

module.exports = {
    create: function(req, res, next) {

        // var docEntity = new docModel(req.body);
        var docEntity = new docModel({
            title: 'aaa',
            type: 'dd',
            ext: '.jpg',
            size: 1024,
            Content: 'dsf ',
            created: Date.now(),
            creater: 'dsfadf '

        });
        console.log(docEntity);
        docModel.create(docEntity, function(err) {
            if (err) return next(err);

            return res.json(docEntity);
        });


    },
    getList: function(req, res, next) {

        var pagesize = parseInt(req.query.pagesize, 10) || 10;
        var pagestart = parseInt(req.query.pagestart, 10) || 1;
        console.log(pagesize + "  " + pagestart);
        docModel.find()
            .skip((pagestart - 1) + pagestart)
            .limit(pagesize).exec(function(err, results) {
                if (err) return next(err);
                if (!results) return next(new Error('doc not  found'));

                return res.json(results);
                //return res.json({id:1,name:"dddd"});
            });
    },
    getById: function(req, res, next) {
        //if (!did) return next(new Error('did not found'));
        console.log( req.params.did);
        docModel.findOne({
                _id: req.params.did
            })
            .exec(function(err, results) {
                if (err) return next(err);
                if (!results) return next(new Error('doc not  found'));

                return res.json(results);
            });
    }
};

Código da camada do modelo, que define o tipo de dados

var mongoose = require("mongoose");


var docSchema = new mongoose.Schema({
    title: String,
    pid: {
        type: mongoose.Schema.Types.ObjectId,
        index: true
    },
    uid: {
        type: mongoose.Schema.Types.ObjectId,
        index: true
    },
    type: {
        type: Number, //1标识文档，2标识图片，3标识视频，4标识其他
        index: true,
        default: 0
    },
    ext: String,
    size: {
        type: Number, //文件大小，文件夹为0
        default: 0
    },
    content: Buffer,
    docurl: String,
    status: {
        type: Number, //0标识为正常，1标识分享
        default: 0
    },
    isflag: {
        type: Number, //0标识为正常，1标识删除
        default: 0
    },
    created: {
        type: Date,
        default: Date.now
    },
    creater: {
        name: String,
        uid: mongoose.Schema.Types.ObjectId
    },
    updated: {
        type: Date,
        default: Date.now
    },
    updater: {
        name: String,
        uid: mongoose.Schema.Types.ObjectId
    }

});

var docModel = mongoose.model("docs", docSchema);
module.exports = docModel;

Código na rota

var express = require('express');
var docRouter = express.Router();
var  docController=require('../controllers/doc.server.controller');

docRouter.get('/getList',docController.getList);
docRouter.get('/create',docController.create);
docRouter.get('/getById/:did',docController.getById);
module.exports = docRouter;

Reimpresso de: https://www.cnblogs.com/ficohu/p/5608996.html

Este é todo o mvc para o processo de solicitação!

Existe outro modo, transferido do pequeno livro: https://www.jianshu.com/p/418355c316dc

app.js

var express = require('express');
var app = express();
var bodyParse = require('body-parser');
var config = require('./config');

var port = process.env.PORT || 3000;

var db = require('./db');

app.set('views', __dirname + '/views');
app.set('view engine', 'jade');

app.use('/public', express.static(__dirname + '/public'));
app.use(bodyParse.json());
app.use(bodyParse.urlencoded({extended: true}));
app.use(require('./controllers'));

db.connect(config.db);

app.listen(port, function() {
    console.log('listen to port:' + port);
})

As 24 linhas são obtidas por meio de require ('express'), expresse o require('express')valor de retorno real é uma função de fábrica para aplicativos de produção.
A linha 25 obtém uma instância do aplicativo (equivalente a uma nova instância do aplicativo) chamando app ().
As linhas 26 e 27 introduzem dependências e arquivos externos, respectivamente.
As linhas 29 e 31 respectivamente definem portas e importam arquivos externos.
- Se estiver executando diretamente node app.js, o Node usará a porta 3000;
- Se PORT=4444 node index.js, o Node ouvirá na porta 4444
A linha 33 diz ao express que desta vez colocamos o modelo no viewsdiretório.
A linha 34 informa ao expresso qual modelo de jade estamos usando neste momento.
A linha 36 é a hospedagem expressa de arquivos estáticos. Contanto que o caminho solicitado seja \publico mesmo, insira a pasta 'pública'.
As linhas 38 e 39 analisam os parâmetros de solicitação para req.bodyatributos.
A linha 40 é a controllerspasta de carregamento , e a introdução real é controllerso index.jsarquivo sob

Esta é a pasta onde você definirá todas as rotas que seu aplicativo servirá. Seus controladores irão lidar com solicitações da web, servir seus modelos ao usuário e interagir com seus modelos para processar e recuperar dados. É a cola que conecta e controla seu aplicativo da web.

O texto acima é uma introdução à controllerspasta, para resumir: controllersdefina o roteador (rota) em

Depois que o servidor é inicializado, a rota é carregada, desde que haja na rota comments, commentsa lógica de processamento será seguida e as demais permanecerão as mesmas.
Para a conexão ao banco de dados é feita a linha 42. Uma vez que o programa é chamado ao ser iniciado require('mongoose'), após cada chamada subsequente require('mongoose'), o que se obtém é o primeiro mongooseobjeto carregado . A razão aqui é: cache de módulo .
A linha 44 escuta uma porta específica, mas deve ser maior do que isso 1024.

Abaixo está o controllercódigo

var express = require('express');
var router = express.Router();

router.use('/comments', require('./comments'));
router.use('/users', require('./users'));

router.get('/', function(req, res){
    res.render('index');
});

module.exports = router;

Pegue o caminho da solicitação como /comments/allexemplo:

Correspondência no índicerouter.use('/comments', require('./comments'));
E a comments seguinte rota é correspondida no arquivo, chamando assim a seguinte lógica.

router.get('/all', function(req, res){
    Comment.userList(function(err, docs) {
        res.render('comments', {comments: docs});
    }); 
});

A camada do modelo define o tipo de dados.

Exemplo simples: https://gitee.com/liuweig/expressMVC

O Express tem duas maneiras de adicionar middleware

app.use adicionar middleware comum
app [método] Adicionar middleware de roteamento

Quando você usa router.use, é equivalente a adicionar middleware comum, e um objeto Layer (o objeto que salva as informações de função de middleware) é adicionado à pilha de roteador;
quando você usa router.all (*), é equivalente para adicionar um middleware de rota, o objeto Layer adicionado à pilha de roteadores armazena rotas ou ponteiros contendo middleware de roteamento, e o middleware de roteamento real será adicionado à pilha de rotas.

tal como:

A camada armazenada é a rota na caixa vermelha

Express implementa o modelo de desenvolvimento MVC

Acho que você gosta