Espero que todos puedan continuar leyendo mi serie de artículos. Este es también el mayor aliento y apoyo para mí. Hagamos progresar juntos, hacer amigos a través de la literatura y ayudarnos mutuamente. Ok, vamos directamente al tema de hoy.
¿Qué es "Connect" y cómo entender el middleware? Veamos el artículo de hoy con preguntas.
¿Cómo entender "middleware"?
Entiendo que el middleware es algo similar a un filtro, una forma de manejar solicitudes y respuestas entre el cliente y la aplicación.
Si se compara un proceso de procesamiento HTTP con el tratamiento de aguas residuales, el middleware es como capas de filtros. Cada middleware reescribe los datos de solicitud o de respuesta (y) durante el procesamiento HTTP,
Estado, implementa funciones específicas.
¿Qué es "Connect"?
Podemos pensar en Connect como una colección de un montón de middleware. Para cada solicitud, Connect usará la capa de middleware para filtrar la solicitud, cada una de las cuales puede obtener la solicitud HTTP.
TJ Holowaychuk dijo sobre Connect que hay dos tipos de middleware. Uno de ellos es un filtro:
Los filtros manejan solicitudes, pero no responden a las solicitudes (piense en registros del servidor).
El segundo tipo es un proveedor, que responde a la solicitud. Puede usar múltiples middleware de acuerdo con sus necesidades. La solicitud HTTP responderá a la solicitud a través de cada middleware hasta uno de los middleware.
2. Introducción al middleware incorporado de Connect
Los siguientes son varios middleware principales y se describen ejemplos:
(1), CookieParser ---------------------------------------------------------------------------------------------------------------------- Las cookies también se pueden cifrar a través de req.secret.
La copia del código es la siguiente:
var conection = request ('./ lib/conection');
var app = Connect ()
.use (Connect.cookieParser ('Secret String'))
.use (function (req, res, next) {
req.cookies.website = "¡Hola, soy Bigbear!" ;
res.end (json.stringify (req.cookies));
}). Escuchar (8888);
(2), sesión
Descripción: Middleware de administración de sesiones
Dependencia: CookieParser
Parámetros: opciones
Opciones:
Clave: el nombre de las cookies, el valor predeterminado es conectar.
Tienda: instancia de almacenamiento de sesión
Secreto: cifrado de cookies de sesión
Cookie: la configuración de cookies de la sesión, el valor predeterminado es {ruta: '/', httponly: true, maxage: null}
Proxy: un proxy inverso para cookies seguras, implementado a través de X-Forwarded-Proto
Opción de cookie:
cookie.maxage: el valor predeterminado es nulo, lo que indica que la cookie se elimina cuando el navegador está cerrado.
La copia del código es la siguiente:
var conection = request ('./ lib/conection');
var app = Connect ()
.use (conecte.logger ('dev'))
.use (Connect.cookieParser ())
.use (Connect.Session ({Secret: '123', Cookie: {Maxage: 60000}}))
.use (function (req, res, next) {
if (req.session.pv) {
res.setheader ('Content-type', 'text/html');
res.write ('Vistas:' + req.session.pv);
res.end ();
req.session.pv ++;
}demás{
req.session.pv = 1;
res.end ('actualizar');
}
})
.listen (8888);
A medida que el cliente actualice continuamente la página "PV" y el número de mantenimiento en la "Sesión del servidor" continuará aumentando.
(3), BodyParser -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
La copia del código es la siguiente:
var conectar = requirir ('conectar');
var app = Connect ()
.use (conecte.bodyParser ())
.use (function (req, res) {
res.end ('req.body =>' + json.stringify (req.body));
})
.listen (8888);
Tercero, tomemos un ejemplo de comparación y veamos los beneficios del uso de middleware.
La copia del código es la siguiente:
/*
* Procesamiento de archivos estáticos implementado usando Connect
*/
var conectar = requirir ('conectar');
Connect (Connect.static (__ dirname + '/public')).listen(//listen
8888,
función() {
console.log ('conectar iniciado en el puerto 8888');
}
);
/*
* Implementación utilizando la API nativa de nodo
*/
var http = require ('http');
http.createServer (
función (req, res) {
var url = require ('url');
var fs = require ('fs');
var rathName = __Dirname + '/public' + url.parse (req.url) .pathname;
// Leer archivos locales
fs.Readfile (
ruta,
función (err, data) {
// Manejo de excepciones
if (err) {
Res.Writehead (500);
res.end ('500');
}
demás {
res.end (datos);
}
}
);
}
) .listen (// escucha
8888,
función() {
console.log ('servidor HTTP iniciado en el puerto 8888');
}
);
Aunque la API nativa del nodo ya ha gastado tantas líneas de código, todavía deja muchos aspectos de un servidor de archivos estático simple que no se ha procesado.
Por ejemplo: 404 y otras excepciones no se procesan, no hay verificación de seguridad de ruta de archivo básica (de hecho, podemos acceder a todo el sistema de archivos del sistema operativo), manejo de excepciones globales, etc.
Al mismo tiempo, Connect ya ha manejado todos estos problemas.
Cuatro, resumamos
(1) Comprender el procesamiento de transmisión de middleware.
La copia del código es la siguiente:
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, next) {
// middleware
});
App.Listen (8888);
(2) Diferenciación entre los métodos de implementación nativos y las implementaciones de middleware.
(3) A través de los ejemplos anteriores de middleware, podemos comprender los escenarios de usos y de uso y consultar documentos relevantes para dominar el uso básico de otro middleware.