Montar en el carro de internet

Montar en el carro de internet

Montar en el carro de internet : Multi-millones de consejos para hacer su vida mas facil.

el Envio de grandes paginas de HTML ya no es un problema ahora que podemos enviar las paginas comprimido !

Despues de dos semanas de no parar de programacion, la aplicacion web esta listo y probado. Todo esta bien y las sonrisas en sus caras de nuestros clientes recordarles que en una extraña forma de 'Jaws'. Excepto por una cosa. Alguien en la parte de atras timidamente le pregunta si algo se podia hacer para acelerar que la pagina de resultado de busqueda que contiene mucho texto. En ese instante usted sabe que usted deberia haber traido una copia completa de la aplicacion con la que en lugar de demostrar que por encima de 33,6 kb linea de modem en el trabajo.

Pero no todo esta perdido. No son formas de reducir la cantidad de datos que usted necesita para enviar al cliente, y no estoy hablando de transmitir menos informacion, sino mas bien sobre el envio de datos comprimidos. Suena interesante? Sigue leyendo y aprende como.

Frivola assumptionsSince en este articulo se describe la funcionalidad y tecnicas que le añaden a la complejidad de una aplicacion web, se supone que ya sabes como crear una aplicacion web, especificamente una dll ISAPI, asi como una aplicacion de este tipo de obras. Como tal, voy a saltar algunos detalles pero ten por seguro que voy a presentar con todas las opciones y el codigo necesario especificamente para las tecnicas que vamos a implementar aqui.

Con esto en mente, vamos a exprimir un poco mas de jugo de su buen ol' linea de Internet.

¿Como es la magia de hacer?¿Como es posible que usted puede pedir? Usted probablemente ha en uno u otro momento de descargar un archivo comprimido, solo para encontrar que su navegador de alguna manera se interpreta los datos como una pagina web o un texto y se muestra en su pantalla en todo su esplendor. No es una bonita imagen para decir lo menos. Si se va a comprimir los datos antes de enviarlos al cliente, no se vera tan extraño? No del todo, solo asegurese de que el cliente sabe que se debe manejar de manera diferente.

El secreto esta oculto, tanto dentro de los datos que el cliente envia al servidor web y dentro de los datos que el servidor web responde con. Se llama la Codificacion del Contenido. En resumen, usted puede codificar los datos de la aplicacion se devuelve al cliente, y la unica precaucion que usted necesita tomar es asegurarse de que el cliente sepa como manejar los datos en la codificacion de formato que usted elija. Esto a su vez es sencillo, ya que el cliente te dice lo de los formatos que puede manejar cuando se envia la solicitud al servidor.

Asi que lo que todo se reduce a es que usted necesita tomar los siguientes pasos si desea codificar los datos que se devuelven al cliente:

1. Comprobar si el cliente puede manejar el tipo de codificacion que desea utilizar
2. Codificar los datos en el formato elegido
3. Devolver el recien datos codificados y decirle al cliente que formato que se ha codificado en

¿en Que formato debo utilizar?Estamos interesados en la compresion de los datos que se devuelven al cliente. Hay un tipo de codificacion especificamente para este proposito, y su nombre es 'desinflar'. El algoritmo de compresion utilizado en la desinflar el tipo de codificacion se corresponde con el algoritmo de la biblioteca de compresion zLib implementa. Usted puede leer mas acerca de esta biblioteca de aqui: http://www.cdrom.com/pub/infozip/zlib o compruebe el rfc describe el algoritmo y es el formato binario de aqui: http://www.funet.fi/pub/doc/rfc/rfc1950.txt.

a Pesar de que usted podria pensar que usted ya tiene los archivos necesarios para el uso de la biblioteca de compresion zLib - no! Al menos no exactamente. Aunque el Delphi CD de instalacion que viene con una copia de la biblioteca de compresion zLib en la forma de precompilado objeto de archivos y algunos archivos de importacion, se esconden los detalles que necesitamos para usar. Mas sobre esto mas adelante, pero por ahora vamos?s baste decir que necesitamos una mejor interfaz para la biblioteca y para los que me han elegido para el suministro de usted con mi propia zLib importacion de unidad y un enlace a la descarga del precompilado dll: http://www.winimage.com/zLibDll/.

Como para el 'desinflar' tipo de codificacion solo Microsoft Internet Explorer aparece para manejar y de nuevo solo las versiones posteriores (la version 4 y hasta las manijas de que, cualquier cosa por debajo de eso es seguro). Esto no es un gran problema, sin embargo, desde otros navegadores como Netscape, no dicen que puede manejar la compresion tipo de codificacion. En este caso nuestra aplicacion web simplemente no volver con datos comprimidos. La unica diferencia seria de un poco mas de tiempo para descargar los datos al cliente. Esto no es peor que lo que tenemos hoy, asi que creo que podemos vivir con eso.

Ok, tengo los archivos, ¿y ahora que?Ahora es el momento de bajar a los detalles escabrosos. Vamos a bajar a un buen comienzo con la creacion de un nuevo proyecto ISAPI en Delphi 5 y a ver a donde nos lleva. Se debe añadir el descargado de importacion de la unidad para este proyecto. La dll que acaba de descargar, se puede poner tanto en la C:/Winnt/System32 directorio (o en su directorio correspondiente) o en el mismo directorio de la aplicacion web.

Despues de crear el nuevo proyecto que vamos a añadir algunas lineas de accion para, literalmente. Agregar una accion para el modulo web y crear un controlador de eventos vacio. De la accion la accion predeterminada como bien ya que esto es solo una aplicacion de demostracion para probar nuestra nueva forma de devolucion de los datos.

ahora Tenemos un vacio de accion de controlador de eventos para que?s añadir un poco de codigo para hacer de ella lo que necesitamos. Te voy a mostrar todo el controlador de eventos primero y luego voy a ir a traves de los detalles.

procedimiento TWebModule1.WebModule1WebActionItem1Action(Sender: TObject Solicitud: TWebRequest Respuesta: TWebResponse var
Handled: Boolean)
var
PlaintextStream : TStream
CompressedStream : TStream
begin
si ( ClientAcceptsDeflate( Peticion)
begin
// 1. En primer lugar, crear temporal de la secuencia con los datos para volver
PlaintextStream := TStringStream.Crear ('Este texto es comprimido' )
prueba
// 2. En segundo lugar, crear temporal de la secuencia para nuestros datos comprimidos
CompressedStream := TMemoryStream.Crear
prueba
// 3. Ahora comprimir el flujo de...
zLibCompressStream( PlaintextStream, CompressedStream )

// ... y volver
CompressedStream.Posicion := 0
Respuesta.ContentStream := CompressedStream
excepto
FreeAndNil( CompressedStream )
aumentar
fin // trate, a excepcion de - evitar fugas de memoria
finalmente
// 4. Finalmente ordenar objeto temporal
FreeAndNil( PlaintextStream )
fin // intentar, finalmente, destruir texto simple objeto stream
Respuesta.ContentType := 'text/plain'
Respuesta.ContentEncoding := 'desinflar'
Respuesta.Codigo de estado := 200
Manejar := True
fin// si el cliente acepta datos comprimidos
else begin
Respuesta.Contenido := 'No se comprimen'
Respuesta.ContentType := 'text/plain'
Respuesta.Codigo de estado := 200
Manejar := True
fin // si el cliente no acepta datos comprimidos
fin // procedimiento TWebModule1.WebModule1ActionItem1Action

La principal si-declaracion de aqui se determina si o no el cliente puede manejar los datos comprimidos y, a continuacion, envia comprimido o sin comprimir datos para el cliente en consecuencia. Los datos sin comprimir se maneja como siempre han manejado datos en una aplicacion web, asi que no vamos a discutir que mas. En lugar de eso nos vamos a concentrar en el si-entonces parte de la si-instruccion que se encarga de datos comprimidos. Usted probablemente ha notado que estamos usando dos nuevos procedimientos/funciones de aqui, es decir, ClientAcceptsDeflate y zLibCompressStream. Voy a ir a traves de esos mas adelante en este articulo.

Suponiendo que tenemos un procedimiento que toma una secuencia de entrada, comprime los datos de esta corriente sostiene y escribe los datos comprimidos a un stream de salida, se puede describir el codigo que se muestra arriba como esto:

1. crear Primero un temporal secuencia que contiene lo que queremos devolver al cliente
2. Segundo, comprimir los datos y poner los datos comprimidos a una nueva corriente
3. Esta nueva corriente, la celebracion de nuestros datos comprimidos, simplemente volver a la cliente
4. Finalmente, hemos de poner en orden nuestros objetos temporales

Usted puede encontrar la coincidencia de los puntos de esta lista en el numero de comentarios de la anterior controlador de eventos. Es bastante basico codigo, y deberia ser, ya que hemos escondido en los detalles escabrosos en dos funciones, del que hablaremos a continuacion.

Una cosa a tener en cuenta es que una vez que se le asigna el ContentStream de la propiedad del objeto de Respuesta para nuestro flujo de la respuesta-bject toma posesion de la secuencia. Una vez que la respuesta de los datos ha sido enviado al cliente el stream sera liberado para nosotros, asi que debemos asegurarnos de no querer libre de nosotros mismos. En el caso de una excepcion, sin embargo hago la suposicion de que la cesion se salio de control y por lo tanto libre hasta el arroyo antes de propagar la excepcion mas arriba.

Parlez-vous français?Para determinar si el cliente sabe como manejar los datos comprimidos tenemos que echar un vistazo a los datos que nos envia en primer lugar. Un tipico solicitud en la web se parece a esto (solicitud falsa, de modo que los detalles puede no ser 100% correcto):

GET /index.html HTTP/1.0
Aceptar-Tipos: */*
Accept-Encoding: gzip, deflate
User-Agent: Mozilla 4.0 (Microsoft Internet Explorer 5.0 Compatible NT)

Lo que nos interesa es la linea que va de la Accept-Encoding: gzip, deflate. Nos dice cuales son los tipos de codificacion, el cliente es capaz de aceptar, y en este caso se puede aceptar datos que esta codificado en el formato gzip, asi como el formato deflate. El segundo es el que necesitamos, asi que vamos a ver como obtener ese conocimiento desde dentro de nuestra aplicacion web. La funcion se parece a esto:

La funcion que tenemos que escribir se parece a esto:

funcion ClientAcceptsDeflate( const de Solicitud: TWebRequest ): Boolean
var
EncodingTypes : cadena
begin
// Obtener y dar nuevo formato a la lista de tipos de codificacion de la solicitud
EncodingTypes := Solicitud.GetFieldByName( 'HTTP_ACCEPT_ENCODING' )
EncodingTypes := Mayusculas( StringReplace( EncodingTypes, ',', '/', [ rfReplaceAll ] ) )
EncodingTypes := '/' StringReplace( EncodingTypes, ' ', ', [ rfReplaceAll ] ) '/'

// Devolver la bandera
Resultado := ( Pos( '/DESINFLAR/', EncodingTypes ) > 0 )
fin // funcion ClientAcceptsDeflate

En resumen puedo volver a formatear los valores de gzip, deflate en /GZIP/DESINFLAR/ y, a continuacion, comprobar para ver si la cadena de /DESINFLAR/ se encuentra dentro de ella. Si usted esta interesado en saber que otros campos se pueden encontrar en la peticion, entonces le sugiero que eche un vistazo a http://msdn.microsoft.com/library/psdk/iisref/isre504l.htm y el uso de la ALL_HTTP variable para comprobar que variables el cliente manda.

Naturellement, parlons!Despues de que se ha determinado que el cliente puede realmente manejar datos comprimidos todo lo que tenemos que hacer es producir, en realidad, los datos comprimidos y aqui es donde la magia entra.

Como se indico anteriormente, vamos a utilizar la biblioteca de compresion zLib para hacer la realidad la compresion. El codigo consiste en los siguientes pasos:

1. Establecer topes para la alimentacion de datos para el motor, asi como la aceptacion de los datos comprimidos de ella
2. Inicializar la compresion del motor
3. Alimentacion de texto sin formato de datos en el bufer de entrada de la secuencia de entrada
4. Comprimir el bufer de entrada para el bufer de salida
5. Escribir datos desde el bufer de salida para el flujo de salida
6. Repita los pasos 3 a 5 hasta que no hay mas datos en el flujo de entrada y tampones han sido vaciados
7. Cierre de compresion del motor

Vamos a profundizar en los detalles y ver lo que tenemos que lidiar con:

procedimiento zLibCompressStream( const de Origen, de Destino: TStream )
var
z_s : z_stream
rc : Integer
// 1. Los buferes de entrada y salida de
SourceBuffer : array[ 0..BufferSize-1 ] de Byte
DestinationBuffer : array[ 0..BufferSize-1 ] de Byte
begin
// 2. Preparar el zLib registro de datos
z_init_zstream( z_s )
z_s.next_in := @SourceBuffer
z_s.next_out := @DestinationBuffer
z_s.avail_out := BufferSize

// 2. Inicializar la compresion del motor
deflateInit2( z_s, Z_BEST_COMPRESSION, Z_DEFLATED, -15, 9, Z_DEFAULT_STRATEGY )

// Ahora comprimir la corriente
prueba
repetir
// 3. A ver si llegamos a alimentar a mas de datos para la compresion del motor
si ( z_s.avail_in = 0 ) y ( de Origen.La Posicion De < Origen.Tamaño ) entonces
begin
z_s.next_in := @SourceBuffer
z_s.avail_in := Fuente.Leer( SourceBuffer, Buffersize )
fin // si los datos de entrada completamente agotada

// 4. Comprimir los datos
si ( z_s.avail_in = 0 ) entonces
rc := deflate( z_s, Z_FINISH )
persona
rc := deflate( z_s, Z_STREAM_END )

// 5. Comprobar si tenemos datos comprimidos para escribir en el destino
si ( z_s.avail_out = 0 ) o ( rc = Z_STREAM_END ) entonces
begin
Destino.WriteBuffer( DestinationBuffer, BufferSize - z_s.avail_out )
z_s.avail_out := BufferSize
z_s.next_out := @DestinationBuffer
fin // si tienes los datos disponibles para la grabacion de

// 6. Repita hasta que los buferes agotado
hasta ( rc <> Z_OK ) o ( ( rc = Z_STREAM_END ) y ( z_s.avail_out = BufferSize ) y ( z_s.avail_in = 0 ) )
finalmente
// 7. Limpiar el motor de datos
deflateEnd( z_s )
fin // try finalmente - limpiar despues de que el motor de
fin // procedimiento zLibCompressStream

Como antes, se puede coincidir con los puntos de esta lista con el numero de comentarios de arriba. La razon por la que no podia utilizar la zLib codigo que?s incluido con Delphi es que oculta el deflateInit2 rutina y los parametros necesarios en el interior de la parte de la implementacion de la unidad asi como a no exponer todo el codigo necesario.

con el fin De producir datos comprimidos en forma que el navegador puede manejar, tenemos que comprimir los datos con ningun registro de encabezado. El registro de encabezado es un pequeño registro de la informacion que se escribe en el inicio de los datos comprimidos y ayuda a que el motor de descompresion sepa la cantidad de datos que sigue. Podemos optar por no escribir este registro de encabezado por el paso de un valor negativo para el wBitSize parametro para la deflateInit2 procedimiento. Desde el desinfle estandar que los navegadores se adhieren a, no espera ni sabe como manejar este encabezado, tenemos que filtrar. Ya no podiamos llamar a deflateInit2 directamente con el zLib codigo que viene con Delphi hemos tenido que recurrir a un completo archivo dll copia de la biblioteca de compresion.

La compresion del motor es capaz de comprimir los datos desde el bufer de entrada y escribir en el bufer de salida. Cuando el bufer de salida esta llena, nuestro codigo necesario vaciar este bufer y escribir los datos en el destino, en nuestro caso de un arroyo. Cuando se ha conseguido comprimir todos los datos de los buffers de entrada, nuestro codigo necesita para llenar el buffer de nuevo con los datos tanto como sea posible. La compresion del motor se encarga del resto.

Prueba de itAfter la compilacion de la aplicacion web (vease la parte inferior del articulo, para que una copia del proyecto de ejemplo que se implementa en este articulo), lo ideal seria probar con un navegador que se encarga de datos comprimidos y con uno que no. Usted puede utilizar Internet Explorer 4/5 como la antigua y Netscape 4.06 como el ultimo. El navegador que se encarga de la compresion debe mostrar el texto 'Este texto es comprimido' y el otro 'comprimido' para su verificacion.

el Promedio de la relacion de compresion en el contenido de texto base es de aproximadamente 5-6 veces (15-20% del tamaño original) por lo que el efecto debe ser claramente perceptible en las grandes paginas web.

ajuste surja, eso es todo. Con el codigo y la informacion contenida en este articulo ahora usted deberia ser capaz de tratar con datos comprimidos a partir de su aplicacion web. Aunque hemos creado una dll ISAPI en este articulo, la teoria y el codigo debe seguir siendo el mismo tambien para CGI y NSAPI aplicaciones.

me he tomado la libertad de crear una unidad con las dos funciones descritas anteriormente, asi como una copia del ejemplo que se producen en este articulo. Usted puede descargar los archivos de la lista de abajo. Si hay sugerencias o cosas que te gustaria hacer un comentario sobre que puedo ser alcanzado en [email protected].

los Archivos para descargar:

• zLib dll (de los autores del sitio web)
• Importar de la unidad para zLib.dll
• Ejemplo de proyecto (incluyendo la unidad con las dos funciones, asi como la importacion de la unidad)
• Solo la unidad con las dos funciones escribimos

Hay un par de notas de acabado a tener en cuenta:

• La compresion del motor no determinar si los datos se presta facilmente a la compresion o no antes de que empiece a masticar. Esto significa que es posible alimentar de datos a traves de el que no puede ser comprimido y puede incluso aumentar de tamaño en su lugar. Para el texto y paginas web esto no es un problema, sin embargo, pero me gustaria hacer algunas pruebas antes de alimentar a los archivos jpeg o gif en ella.
• La compresion se realiza en el lado del servidor antes de que se envie por lo que si el cliente esta tratando de descargar una gran pagina web, a continuacion, esencialmente la aplicacion web se carga toda la pagina en la memoria, lo comprime y lo envia. Si el consumo de memoria en el lado del servidor es un problema, a continuacion, me permito sugerir la aplicacion de la compresion de codigo en un TStream clase derivada que se comprime cuando se leen de la misma. De esa manera la compresion se realiza sobre la marcha, como la que se envian los datos y puede ser alimentado directamente del disco a traves de la biblioteca de compresion para el cliente. Clases para hacer esto estan disponibles en mi pagina de inicio en el paquete llamado StreamFilter.