jpspan_04.jpg Nos vamos a centrar en la 4ª parte en estudiar el método  displayClient(), por ser el encargado de generar el esquema de código JavaScript necesario para la comunicación.

Cómo hemos indicado JPSpan proporciona al Cliente el código JavaScript necesario para realizar llamadas a la clase en el lado del servidor y hacer que la página pueda gestionar las llamadas en sí.

La función displayCliente(), está en la página /JPSpan/Server.php y es :

/**
* Display the Javascript client and exit
* @return void
* @access public
*/
function displayClient() {
$G = & $this->getGenerator();
require_once JPSPAN . ‘Include.php’;
$I = & JPSpan_Include::instance();
// HACK – this needs to change
$I->loadString(__FILE__,$G->getClient());
$client = $I->getCode();
header(‘Content-Type: application/x-javascript’);
header(‘Content-Length: ‘.strlen($client));
echo $client;

}

Lo importante de dicho método es la generación de la variable $client, es donde está todo el código JavaScript generado por JPSpan en función a los parámetros que le hemos enviado, por ejemplo, indicar que el código de transmisión de los argumentos (variables) sea por ‘php’, ‘xml’ o json’ o Comprimir el código JavaScript mediante la página script.php.

Cómo no es posible visualizar por pantalla la variable $client, vamos a introducir tres líneas nuevas de código php (ver abajo en rojo la incorporación) para grabar dicha variable en un fichero con nombre ‘logclient.txt’ para analizar su contenido en profundidad y es :

/**
* Display the Javascript client and exit
* @return void
* @access public
*/
function displayClient() {
$G = & $this->getGenerator();
require_once JPSPAN . ‘Include.php’;
$I = & JPSpan_Include::instance();
// HACK – this needs to change
$I->loadString(__FILE__,$G->getClient());
$client = $I->getCode();
$t_log_fp   = fopen(‘logclient.txt’, ‘w’);
fwrite($t_log_fp, $client );
fclose($t_log_fp);
header(‘Content-Type: application/x-javascript’);
header(‘Content-Length: ‘.strlen($client));
echo $client;
}

La primera instrucción insertada por nosotros $t_log_fp  = fopen(‘logclient.txt, ‘w’); le indicamos que abra el fichero de modo escritura, si no existe lo crea, y que empiece en el primer registro al indicar la letra ‘w’.

La segunda instrucción  fwrite($t_log_fp, $clientn ); le indicamos que grabe en dicho fichero la variable $client.

La tercera instrucción fclose($t_log_fp); le indicamos que cierre el fichero logclient.txt.

NOTA : Cuando activamos el programa realizado en html con el navegador y llama al programa jpspan_server.php del servidor, grabará en la carpeta  (donde ha sido llamado el programa jpspan_server.php) el fichero logclient.txt con todas las instrucciones javascript necesarias para poder realizar la comunicación.

Podemos ver el fichero una vez generado : FICHERO LOGCLIENT.TXT

Al verlo nos damos cuenta que tiene más de 1200 líneas y un peso de 33 Kb. Es la unión de varios ficheros js que lee el programa para generar en una sola variable  ($client) según la necesidades de comunicación y compresión. Los programas JavaScript que lee están en la ruta /JPSpan/js y son : serialize.js, httpclient.js, json,js , remoteobject.js, recuest.js, otra carpeta que utiliza es  /JPSpan/js/code/php.js , xml.js , json.js y por último la carpeta /JPSpan/js/request/get.js , post.js , rawpost.js.

Una vez leídos y procesados todos los .js necesarios para la comunicación, al final de la varaible $client crea el programa todos los métodos necesarios de la function customer para la interconexión entre los dos programas (Cliente y Servidor).

Ejemplo de la función customer creada por el programa :

function customer() {
var oParent = new JPSpan_RemoteObject();
if ( arguments[0] ) {  oParent.Async(arguments[0]); }
oParent.__serverurl = ‘http://localhost/generic/jpspan_server.php/customer’;
oParent.__remoteClass = ‘ customer’;
oParent.__request = new JPSpan_Request_Post(new JPSpan_Encode_PHP());
oParent.getmydatos = function() { var url = this.__serverurl+’/getmydatos/’;
return this.__call(url,arguments,’getmydatos’);  };
return oParent;  }


Imaginaros que realizo un programa en html que pide un código de una referencia y el programa JPSpan del servidor tiene que devolver la descripción, el Pr. Venta y los descuentos, según lo analizado anteriormente, nos generará una variable $client de más de 1.200 líneas con un peso de 33 Kb, si nuestro programa pide 10 referencias, el programa abra generado más de 12.000 líneas con un peso de 330 Kb.

Vamos es como matar moscas a cañonazos.

Tenemos que solucionar el problema de peso y número de líneas de la variable $client, no puede llegar a sobrepasar más de 12 Kb y no puede tener más de 15 líneas en su conjunto, para que pueda ser competitivo el módulo JPSpan con otros programas similares a él .

Cómo hemos indicado el propio programa JPSpan tiene un compresor de código JavaScript y lo hemos rechazado, porque cada vez que genera el objeto client, tiene que realizar la compresión y eso relentiza un montón todo el proceso de comunicaciones.

Para solucionar el problema de peso y número de líneas tenemos que comprimir los ficheros javascript que lee el programa servidor realizado en php de antemano (Antes de ser leídos por JPSpan). Eso significa comprimir el serialize.js, httpclient.js, remoteobject.js, request.js, php.js, xml.js, json.js, get.js, post.js y rawpost.js.

Para ello, tenemos que ir al mejor compresor de instrucciones javascript que existe en la red y no es otro que el realizado por Yahoo Download YUI Compressor version 2.4.2, en dicha página nos explica el funcionamiento del programa, está realizado en java, pero la verdad es muy bueno.

Aquí les dejo el proceso de compresión de los ficheros xxxxxx.js que los pasa ya comprimidos a xxxxx2.js, por ejemplo el httpclient.js pasa a httpclient2.js ya comprimido.

NOTA : Pasar todos los ficheros xxxxx.js a la carpeta /yuicompressor-2.4-2/build/ y crear un programa .bat con el editor de texto para que realice la compresión de todos ellos.

Programa JPSpan.bat :

java -jar yuicompressor-2.4.2.jar –type js httpclient.js   -o httpclient2.js   
java -jar yuicompressor-2.4.2.jar –type js remoteobject.js -o remoteobject2.js
java -jar yuicompressor-2.4.2.jar –type js request.js      -o request2.js      
java -jaryuicompressor-2.4.2.jar –type js serialize.js    -o serialize2.js    
java -jar yuicompressor-2.4.2.jar  –type js json.js         -o json2.js         
java -jar yuicompressor-2.4.2.jar –type js php.js          -o php2.js          
java -jar yuicompressor-2.4.2.jar –type js xml.js          -o xml2.js         
java -jar yuicompressor-2.4.2.jar –type js get.js          -o get2.js          
java -jar yuicompressor-2.4.2.jar –type js post.js         -o post2.js      
java -jar yuicompressor-2.4.2.jar –type js rawpost.js    -o rawpost2.js 

Una vez comprimido los ficheros aún no podemos renombrarlos y pasarlos a la carpeta JPSpan/js, porque tenemos que incluir en algunos de ellos, el encabezado “include” que el JPSpan necesita en algunos ficheros .js,  y el compresor de yahoo ha eliminado por entender que son comentarios.

En el fichero request2.js incluiremos al principio estas cuatro líneas que están al principio del fichero sin comprimir request.js (Editar el fichero request.js y ver dichas líneas)

/**@
* include ‘httpclient.js’;
* include ‘json.js’;
*/

En el fichero json2.js está repetido dos veces, una en la carpeta /js y otra en la carpeta js/code/ incluiremos al principio estas tres líneas que están al principio del fichero sin comprimir json.js, tiene que estar repetido en las dos carpetas, no borrar ninguno de ellos.

/**@
* include ‘serialize.js’;
*/

En los ficheros php2.js y xml2.js incluiremos al principio estas tres líneas que están al principio del fichero sin comprimir php.js y xml.js (Editar el fichero php.js y xml.js y ver dichas líneas)

/**@
* include ‘serialize.js’;
*/

De los ficheros get2.js, post2.js y rawpost2.js incluiremos estas tres líneas que están al principio del fichero sin comprimir get.js, post.js y rawpost.js de la carpeta js/request/ (Editar el fichero get.js, post.js y rawpost.js y ver dichas líneas)

/**@
* include ‘request.js’;
*/

Una vez introducidos todos los includes borrados por el compresor, guardamos los .js originales sin comprimir y pasamos ya renombrados los xxxxx2.js comprimidos machacando los originales con xxxxx.js.

Y ahora hacemos una prueba con nuestro programa de comunicaciones y vemos si enseña los datos, si los enseña es que todo el proceso de compresión es correcto, si por algún motivo no enseña los datos, es porque te falta algún include en un .js o has borrado algún .js de la carpeta JPSpan/js.

Podemos ver el fichero una vez generado con los .js comprimidos por el programa de yahoo : FICHERO LOGCLIENT2.TXT, el fichero resultante tiene 12 Kb, pero aún tiene muchas líneas unas 30, y es porque al crear la  funcion costumer el programa deja espacios en blanco por cada instrucción añadida a la variable client.

Para solucionar el problema, editamos el programa JPSpan/server/PostOffice.php y al final veremos la function generateHandleCliente y empezamos a eliminar los blancos y unir varias líneas en una sola, el código ya cambiado tiene que quedar más o menos asi:

function gerateHandleClient(& $Code, & $Description) {
ob_start();
?>
function <?php echo $Description->Class; ?>() { var oParent = new JPSpan_RemoteObject();
if ( arguments[0] ) {  oParent.Async(arguments[0]);  } oParent.__serverurl = ‘<?php
echo $this->serverUrl . ‘/’ . $Description->Class; ?>’; oParent.__remoteClass = ‘ <?php echo $Description->Class; ?>’;
<?php
switch ($this->RequestEncoding) {
case ‘xml’:
?>oParent.__request = new JPSpan_Request_RawPost(new JPSpan_Encode_Xml()); <?php
break;
case ‘json’:
?>oParent.__request = new JPSpan_Request_RawPost(new JPSpan_Encode_JSON());<?php
break;
default:
?>oParent.__request = new JPSpan_Request_Post(new JPSpan_Encode_PHP());<?php
}

foreach ( $Description->methods as $method ) {
?>
oParent.<?php echo $method; ?> = function() { var url = this.__serverurl+’/<?php echo $method; ?>/’;
return this.__call(url,arguments,'<?php echo $method; ?>’); }; <?php }?>return oParent; } <?php
$Code->append(ob_get_contents());
ob_end_clean();
}
}

Una vez realizado los cambios en el programa .php, volvemos a realizar otra prueba para ver el resultado de nuestra variable $client en el fichero :  FICHERO LOGCLIENT3.TXT

AHORA SI, LA VARIABLE $CLIENT SÓLO PESA 12 Kb Y TAN SÓLO TIENE 12 LÍNEAS, HEMOS GANADO EN RÁPIDEZ Y PRECISIÓN EN LAS COMUNICACIONES ENTRE EL SERVIDOR Y EL NAVEGADOR.

YA EMPIEZA A SER COMPETITIVO E INTERESANTE EL MÓDULO JPSpan PARA LAS COMUNICACIONES CON AJAX EN NUESTROS PROGRAMAS.

Pero aún no hemos terminado, estamos en el principio de algo grande para todos nosotros a nivel de comunicaciones estilo AJAX con PHP …………

OBSERVACIONES : Una vez realizada todas las pruebas , recordar en comentar las tres instrucciones creadas en la function displayClient(), para que no genere el fichero logclient.txt

function displayClient() {
$G = & $this->getGenerator();
require_once JPSPAN . ‘Include.php’;
$I = & JPSpan_Include::instance();
// HACK – this needs to change
$I->loadString(__FILE__,$G->getClient());
$client = $I->getCode();
// $t_log_fp   = fopen(‘logclient.txt’, ‘w’);
// fwrite($t_log_fp, $client );
// fclose($t_log_fp);
header(‘Content-Type: application/x-javascript’);
header(‘Content-Length: ‘.strlen($client));
echo $client;
}


Saludos de Telepieza

Deja un Comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *