Espero que todos possam continuar lendo minha série de artigos. Este também é o maior incentivo e apoio para mim. Vamos progredir juntos, fazer amigos através da literatura e ajudar um ao outro. Ok, vamos direto para o tópico de hoje.
O que é "Connect" e como entender o middleware? Vejamos o artigo de hoje com perguntas.
Como entender "middleware"?
Meu entendimento é que o middleware é algo semelhante a um filtro, uma maneira de lidar com solicitações e respostas entre o cliente e o aplicativo.
Se um processo de processamento HTTP for comparado ao tratamento de esgoto, o middleware será como camadas de filtros. Cada middleware reescreve a solicitação ou (e) dados de resposta durante o processamento HTTP,
Estado, implementa funções específicas.
O que é "Connect"?
Podemos pensar no Connect como uma coleção de um monte de middleware. Para cada solicitação, o Connect usará a camada de middleware para filtrar a solicitação, cada um dos quais pode obter a solicitação HTTP.
TJ Holowaychuk disse sobre o Connect que existem dois tipos de middleware. Um deles é um filtro:
Os filtros lidam com solicitações, mas não respondem às solicitações (pense em logs do servidor).
O segundo tipo é um provedor, que responde à solicitação. Você pode usar vários middleware de acordo com suas necessidades. A solicitação HTTP responderá à solicitação por meio de cada middleware até um dos middleware.
2. Introdução ao middleware integrado do Connect
A seguir, são descritos vários middleware e exemplos principais:
(1), CookieParser -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Os cookies também podem ser criptografados via req.secret.
A cópia do código é a seguinte:
var connect = requer ('./ lib/connect');
var app = Connect ()
.Use (Connect.CookieParser ('Secret String')))
.Use (função (req, res, próximo) {
req.cookies.website = "Oi, eu sou Bigbear!" ;
res.nd (json.stringify (req.cookies));
}). Ouça (8888);
(2), sessão
Descrição: Middleware de gerenciamento de sessão
Dependência: Cookieparser
Parâmetros: Opções
Opções:
Chave: Nome dos cookies, o valor padrão é conectado.sid
Loja: instância de armazenamento de sessão
Segredo: criptografia de cookies de sessão
Cookie: Configuração de cookies da sessão, o valor padrão é {path: '/', httponly: true, maxage: null}
Proxy: um proxy reverso para cookies seguros, implementados através do X-forwarded-proto
Opção de biscoito:
Cookie.maxage: O valor padrão é nulo, indicando que o cookie é excluído quando o navegador está fechado.
A cópia do código é a seguinte:
var connect = requer ('./ lib/connect');
var app = Connect ()
.Use (Connect.logger ('Dev')))
.Use (Connect.CookieParser ())
.Use (Connect.Session ({secret: '123', cookie: {maxage: 60000}})))
.Use (função (req, res, próximo) {
if (req.session.pv) {
Res.Setheader ('Content-Type', 'Text/Html');
res.Write ('Views:' + req.session.pv);
res.nd ();
req.session.pv ++;
}outro{
req.session.pv = 1;
res. end ('refresh');
}
})
.Listen (8888);
À medida que o cliente atualiza continuamente a página "PV" e o número de manutenção no lado do servidor "sessão" continuará aumentando.
"
A cópia do código é a seguinte:
var connect = requer ('Connect');
var app = Connect ()
.Use (Connect.BodyParser ())
.Use (função (req, res) {
res.nd ('req.body =>' + json.stringify (req.body));
})
.Listen (8888);
Terceiro, vamos dar um exemplo de comparação e ver os benefícios do uso do middleware.
A cópia do código é a seguinte:
/*
* Processamento de arquivos estático implementado usando Connect
*/
var connect = requer ('Connect');
Connect (Connect.static (__ Dirname + '/public')).Listen(//listen
8888,
function () {
console.log ('Connect iniciado na porta 8888');
}
);
/*
* Implementação usando API nativo do nó
*/
var http = requer ('http');
http.createServer (
função (req, res) {
var url = requer ('url');
var fs = requer ('fs');
var pathname = __dirname + '/public' + url.parse (req.url) .pathname;
// Leia arquivos locais
fs.readfile (
nome do caminho,
função (err, dados) {
// Manuseio de exceção
if (err) {
Res.Writehead (500);
res. end ('500');
}
outro {
res.nd (dados);
}
}
);
}
) .Listen (// Ouça
8888,
function () {
console.log ('servidor http iniciado na porta 8888');
}
);
Embora a API nativa do nó já tenha gasto tantas linhas de código, ela ainda deixa muitos aspectos de um simples servidor de arquivos estáticos que não foram processados.
Por exemplo: 404 e outras exceções não são processadas, não há verificação básica de segurança do caminho do arquivo (na verdade, podemos acessar todo o sistema de arquivos do SO), manuseio global de exceções, etc.
Ao mesmo tempo, o Connect já lidou com todos esses problemas.
Quatro, vamos resumir
(1) Entenda o processamento de streaming de middleware.
A cópia do código é a seguinte:
var app = Connect ();
App.use (Connect.staticCache ());
App.use (Connect.static (__ Dirname + '/public'));
App.use (Connect.CookieParser ());
App.use (Connect.Session ());
App.use (Connect.Query ());
App.use (Connect.BodyParser ());
App.use (Connect.csrf ());
App.use (function (req, res, próximo) {
// middleware
});
App.Listen (8888);
(2) Diferenciação entre métodos de implementação nativa e implementações de middleware.
(3) Através dos exemplos acima do middleware, podemos entender os cenários de usos e uso e nos referir a documentos relevantes para dominar o uso básico de outro middleware.