¿Son realmente tan importantes las actualizaciones importantes? Antecedentes: Creo que los estudiantes que han usado Node.js para aplicaciones web deben estar preocupados por el problema de que el código recién modificado necesita reiniciar el proceso de Node.js antes de que pueda actualizarse. Los estudiantes que están acostumbrados a usar PHP se sentirán muy incómodos y gritarán que PHP es el mejor lenguaje de programación del mundo. Reiniciar manualmente el proceso no solo es una tarea muy molesta y repetitiva, sino que además no se puede ignorar el tiempo de inicio cuando la escala de la aplicación es un poco mayor. Por supuesto, como Cheng, no importa qué idioma uses, no permitirás que esas cosas te torturen. La forma más directa y común de resolver este tipo de problemas es monitorear las modificaciones del archivo y reiniciar el proceso. Este método también proporciona muchas soluciones maduras, como el supervisor de nodos abandonado, el ahora popular PM2 o el relativamente liviano node-dev. Este artículo proporciona otra idea. Con solo ligeras modificaciones, puede lograr un verdadero código de actualización en caliente sin reinicio y resolver el molesto problema de actualización de código en las aplicaciones web Node.js. Idea general Hablando de actualización en caliente de código, la función de actualización en caliente más famosa del lenguaje Erlang es actualmente. Este lenguaje se caracteriza por una alta concurrencia y programación distribuida, y sus principales escenarios de aplicación son similares al comercio de valores, servidores de juegos y otros campos. Todos estos escenarios requieren que los servicios tengan métodos de operación y mantenimiento durante la operación, y la actualización del código activo es una parte muy importante, por lo que primero podemos comprender brevemente el enfoque de Erlang. Como nunca he usado Erlang, el siguiente contenido son rumores. Si desea tener una comprensión profunda y precisa de las actualizaciones en caliente del código de Erlang, es mejor consultar la documentación oficial. La carga de código de Erlang es administrada por un módulo llamado code_server. Excepto por parte del código necesario al inicio, la mayor parte del código se carga mediante code_server. Cuando code_server descubre que el código del módulo se ha actualizado, recargará el módulo y luego ejecutará nuevas solicitudes con el nuevo módulo, mientras que las solicitudes originales que aún se están ejecutando continuarán ejecutándose con el módulo anterior. Una vez que se carga un módulo nuevo, el módulo antiguo se marcará como antiguo y el módulo nuevo se marcará como actual. En la próxima actualización en caliente, Erlang escaneará y eliminará los módulos antiguos que aún se están ejecutando y luego continuará actualizando los módulos de acuerdo con esta lógica. No todos los códigos en Erlang permiten actualizaciones en caliente y los módulos básicos como el kernel, stdlib y los compiladores no pueden actualizarse de forma predeterminada. Podemos encontrar que hay un módulo similar a code_server en Node.js, que es el sistema requerido, por lo que el método de Erlang también debería probarse en Node.js. Al comprender el método de Erlang, podemos resumir aproximadamente cómo resolver el problema del código. Actualización en caliente en Node.js Puntos clave, como cómo actualizar el código del módulo, cómo usar el nuevo módulo para manejar solicitudes, cómo liberar los recursos del módulo anterior, etc. Luego analizaremos estos puntos uno por uno. Cómo actualizar el código del módulo Para resolver el problema de actualizar el código del módulo, necesitamos leer directamente la implementación del administrador de módulos de Node.js y vincular module.js. Con una simple lectura, puede encontrar que el código central se encuentra en el módulo. _load para que podamos simplificar el código y publicarlo. //Compruebe el caché en busca de archivos referenciados. // 1. Si el módulo ya existe en la caché: devuelve su objeto de exportación. // 2. Si el módulo es nativo: llame a `NativeModule.reuire()` con // el nombre del archivo y devuelva el resultado. // 3. De lo contrario, cree un nuevo módulo para el archivo y guárdelo en la caché. // Luego, deje que cargue el contenido del archivo antes de devolver su // objeto de exportación. módulo. _load = function(solicitud, padre, isMain) { var nombre de archivo = Módulo. _resolveFilename(solicitud, padre); var cachedModule = módulo. _ cache[nombre de archivo]; if (módulo en caché) { devolver exportaciones de módulo en caché } var módulo = nuevo módulo (nombre de archivo, módulo principal);
_ cache[nombre de archivo] = módulo; module.load(nombre de archivo exporta); reuire.cache = Módulo. _ cache Puedes encontrar que su núcleo es un módulo. _cache. Siempre que se borre la memoria caché de este módulo, el administrador del módulo recargará el código más reciente la próxima vez que se recupere. Escriba un pequeño programa para verificar //in.js function clean(module){ var path = re uire . resolve(module re uire cache[path]= null;} setInterval(function(){ clean cache('). / code . js'); var code = reuire('./code . js'); console.log(code);//code .js exports = 'hola mundo'; js y modifica el contenido de code.js al mismo tiempo, puede encontrar que nuestro código se ha actualizado correctamente al último código en la consola. Entonces se resuelve el problema del administrador del módulo que actualiza el código. Veamos cómo hacer que el nuevo módulo se ejecute realmente en la aplicación web. Cómo utilizar el nuevo módulo para procesar solicitudes. Para satisfacer mejor los hábitos de uso de todos, usaremos Express directamente como ejemplo para ampliar este tema. De hecho, utilizando ideas similares, se pueden aplicar la mayoría de las aplicaciones web. En primer lugar, si nuestro servicio es como la DEMO de Express, todo el código está en el mismo módulo, no podemos usar var express = reuire('express ') para cargar en caliente el módulo; / '), function(re, RES) { RES . send(' hola mundo '); app listening(); Para implementar la carga en caliente, como la biblioteca básica que no está permitida en Erlang, necesitamos algo que no puede estar activo Actualice el código base para controlar el proceso de actualización. Además, si vuelve a realizar operaciones como app.listen, no hay mucha diferencia con reiniciar el proceso de Node.js. Por lo tanto, necesitamos algún código inteligente para distinguir el código comercial que se actualiza con frecuencia del código básico que se actualiza con poca frecuencia. // código básico de app.js var express = reuire('express'); var app = express(); var router = reuire('./router.js'); ); // código de servicio router.js var express = re uire(' express '); Router(); //El middleware cargado aquí también puede actualizar automáticamente el enrutador use(express. static(' public '); router. get('/'), function(re, RES){ RES. send(' hola mundo). '); }); module.exports = router; Desafortunadamente, después de dicho procesamiento, aunque el código central se separó con éxito, router.js aún no se puede actualizar. En primer lugar, debido a la falta de un mecanismo que active la actualización, el servicio no tiene forma de saber cuándo actualizar el módulo. En segundo lugar, la operación app.use siempre guardará el módulo router.js antiguo, por lo que incluso si el módulo se actualiza, la solicitud seguirá siendo procesada por el módulo antiguo, no por el módulo nuevo.