22. Ejercicio práctico – Versión 11
Todavía es común que los servicios web envíen su respuesta en forma de documento XML en lugar de un documento JSON:
- el documento JSON es más pequeño, pero se necesitan instrucciones para entenderlo;
- el documento XML es más extenso, pero se explica por sí mismo. Se entiende de inmediato.
Modificamos la aplicación cliente/servidor de la versión 10 para que el servidor envíe ahora un documento XML como respuesta a sus clientes. Con ello, ponemos en práctica el capítulo anterior.
22.1. El servidor

Esta arquitectura se implementará con los siguientes archivos:
| scripts-web/tax/version-11
├── Data
│ ├── .htaccess
│ ├── config-server.json
│ └── logs.txt
├── Utilities
│ ├── XmlUtilities.php
│ └── testXml.php
└── tax-server.php
|
22.1.1. La clase [XmlUtilities]
El curso de PHP 7 agregaba a la clase [getXmlForArrayOfAttributes], un método [Utilities] que generaba el documento XML a partir de un arreglo. Nuestro servidor ya usa la clase [Utilities] de la versión 5 (para la clase [Database]): creamos una nueva clase [XmlUtilities]:
| <?php
declare(strict_types=1);
// espacio de nombres
namespace Application;
// funciones utilitarias para el formato XML: la clase no se puede instanciar ni derivar
final class XmlUtilities
{
// constructor privado: la clase no puede instanciarse
private function __construct()
{
}
// devuelve el documento XML de un arreglo [$data]: el elemento raíz se llama [$root]
// las claves del arreglo se convierten en nombres de elementos, los valores en su contenido
public static function arrayToXml(array $data, string $root): string
{
// un documento XML vacío (nueva API DOM de PHP 8.4)
$document = \Dom\XMLDocument::createEmpty();
// el documento tendrá sangría
$document->formatOutput = true;
// el elemento raíz y sus descendientes
$document->append(self::element($document, $root, $data));
// el texto XML del documento
return $document->saveXml();
}
// devuelve el elemento XML [<$name>$value</$name>]
private static function element(\Dom\XMLDocument $document, string $name, mixed $value): \Dom\Element
{
$element = $document->createElement($name);
if (is_array($value)) {
// un arreglo: cada elemento del arreglo se convierte en un elemento hijo (llamada recursiva)
foreach ($value as $key => $subValue) {
// los elementos de una lista (claves 0, 1, 2...) se llaman [item]
$element->append(self::element($document, is_int($key) ? "item" : $key, $subValue));
}
} else {
// un valor simple se convierte en el texto del elemento (DOM codifica los caracteres <, >, &)
$element->textContent = match (true) {
is_bool($value) => $value ? "true" : "false",
default => (string) $value,
};
}
return $element;
}
}
|
Comentarios
- línea 9: al igual que la clase [Utilities] de la versión 5, esta clase solo tiene métodos estáticos. Es [final] y su constructor es privado: no se puede derivar de ella ni instanciarla;
- línea 18: el método estático [arrayToXml] devuelve el documento XML a partir del arreglo [$data] pasado como parámetro. El segundo parámetro es el nombre del elemento raíz del documento;
- línea 21: usamos la nueva API DOM de PHP 8.4, presentada en el capítulo anterior. El método estático [createEmpty] crea un documento XML vacío. El script de PHP 7 usaba [SimpleXML], que también puede generar un documento, pero no tan bien: había que codificar uno mismo los caracteres especiales del texto con la función [htmlspecialchars];
- línea 23: el documento resultante estará indentado, lo que lo hace más legible;
- línea 25: el elemento raíz del documento, creado por el método [element], se agrega al documento;
- línea 27: el método [saveXml] genera el texto XML del documento;
- línea 31: el método privado [element] devuelve el elemento XML con el nombre [$name], que representa el valor [$value];
- línea 33: el método [createElement] del documento crea el elemento;
- Líneas 34–38: si el valor es un arreglo, cada uno de sus elementos se convierte en un elemento hijo, creado mediante una llamada recursiva al método [element]. Las claves del arreglo se convierten en los nombres de los elementos hijos. Las claves de una lista son los enteros 0, 1, 2..., que no pueden ser nombres de elementos XML: por eso estos elementos se llaman [item]. El script de PHP 7 los designaba como [i0], [i1], [i2]...;
- líneas 40–45: de lo contrario, el valor se convierte en el texto del elemento, asignado a su propiedad [textContent]. Los caracteres [<], [>], y [&] del texto son codificados por DOM ([<], [>], [&]). Los booleanos se escriben como [true] y [false]; los demás valores se convierten en cadenas. La expresión [match (true)] selecciona la primera rama cuya condición es verdadera.
Escribimos el siguiente script de prueba, [testXml.php]:
| <?php
// respeto estricto de los tipos declarados de los parámetros y resultados de las funciones
declare(strict_types=1);
// dependencia
require_once __DIR__ . "/XmlUtilities.php";
use Application\XmlUtilities;
// un arreglo asociativo
$array = [
"lastName" => "amédée",
"firstName" => "sylvain",
"age" => 40,
"children" => [
["lastName" => "amédée", "firstName" => "béatrice", "age" => 6],
["lastName" => "amédée", "firstName" => "bertrand", "age" => 4],
],
"remark" => "<married> & happy",
];
// la respuesta es un documento XML
header("Content-Type: application/xml; charset=utf-8");
print XmlUtilities::arrayToXml($array, "person");
|
- líneas 12–21: un arreglo asociativo que contiene una lista y un texto con caracteres especiales de XML;
- línea 23: la función [header] establece el encabezado HTTP [Content-Type] de la respuesta: es un documento XML;
- línea 24: el documento XML del arreglo, con elemento raíz [person], se envía al cliente.
Solicitemos la URL [http://localhost/php8-oct-2026/scripts-web/tax/version-11/Utilities/testXml.php] con [curl]:
| > curl http://localhost/php8-oct-2026/scripts-web/tax/version-11/Utilities/testXml.php
<?xml version="1.0" encoding="UTF-8"?>
<person>
<lastName>amédée</lastName>
<firstName>sylvain</firstName>
<age>40</age>
<children>
<item>
<lastName>amédée</lastName>
<firstName>béatrice</firstName>
<age>6</age>
</item>
<item>
<lastName>amédée</lastName>
<firstName>bertrand</firstName>
<age>4</age>
</item>
</children>
<remark><married> & happy</remark>
</person>
|
- líneas 7–18: la lista [children] y sus dos elementos [item];
- línea 19: los caracteres [<], [>], y [&] han sido codificados.
Un navegador muestra el mismo documento en forma de árbol:

Observe que [Chrome] decodificó el texto del elemento [remark].
22.1.2. El script del lado del servidor
El script del lado del servidor [tax-server.php] debe modificarse, junto con su archivo de configuración [config-server.json]:
| {
"databaseFilename": "../version-08/Data/database-mysql.json",
"dependencies": [
"../../../scripts-console/tax/version-05/Entities/TaxException.php",
"../../../scripts-console/tax/version-05/Entities/TaxAdminData.php",
"../../../scripts-console/tax/version-05/Entities/Database.php",
"../../../scripts-console/tax/version-05/Utilities/Utilities.php",
"../version-08/Dao/InterfaceServerDao.php",
"../version-08/Dao/ServerDao.php",
"../version-09/Dao/ServerDaoWithSession.php",
"../version-08/Business/InterfaceServerBusiness.php",
"../version-08/Business/ServerBusiness.php",
"../version-09/Utilities/Logger.php",
"../version-09/Utilities/SendAdminMail.php",
"Utilities/XmlUtilities.php"
],
|
- Línea 15: se incluye la nueva clase [XmlUtilities]. El resto de la configuración es igual al de la versión 10.
Los cambios en el script del servidor son los siguientes:
| }
// envío de la respuesta HTTP al cliente
// $result: el arreglo que se enviará, en forma del documento XML <response>...</response>
// $statusCode: el estado HTTP de la respuesta
// $headers: encabezados HTTP que se agregarán a la respuesta
// $logger: el registro de la aplicación (null si no se pudo crear)
// $redis: el cliente Redis (null si aún no se ha creado)
function sendResponse(
array $result,
int $statusCode,
array $headers = [],
?Logger $logger = null,
?RedisClient $redis = null
): void {
// la respuesta XML
$response = new Response(XmlUtilities::arrayToXml($result, "response"), $statusCode, $headers);
$response->headers->set("Content-Type", "application/xml; charset=utf-8");
// envío
$response->send();
// registro en JSON, más conciso que XML
$logger?->write(json_encode(
["response" => $result],
JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION
));
// cierre de la conexión con el servidor Redis
$redis?->disconnect();
}
|
Comentarios
- La clase [JsonResponse] ya no se usa: la respuesta es una simple respuesta [Response];
- Línea 212: la respuesta del servidor es ahora el documento XML, con elemento raíz [response] a partir del arreglo [$result];
- línea 213: se indica que la respuesta es un documento XML codificado en UTF-8;
- líneas 217–220: la respuesta se registra como JSON, que es más conciso que XML.
El resto del script permanece sin cambios. Como todas las respuestas pasan por la función [sendResponse], basta con modificar esta función para que todas las respuestas —incluidas las respuestas de error— sean documentos XML.
Prueba
Solicitemos la URL [http://localhost/php8-oct-2026/scripts-web/tax/version-11/tax-server.php?married=yes&children=2&salary=60000], y [curl]:
| > curl -i -u admin:admin "http://localhost/php8-oct-2026/scripts-web/tax/version-11/tax-server.php?married=yes&children=2&salary=60000"
HTTP/1.0 200 OK
Date: Fri, 02 Oct 2026 12:29:50 GMT
Server: Apache/2.4.58 (Ubuntu)
X-Powered-By: PHP/8.5.11
Cache-Control: max-age=0, private, must-revalidate
Set-Cookie: PHPSESSID=cdcb082d1342f5b0a273f76a30f92fc6; path=/
Cache-Control: no-cache, private
Vary: Accept-Encoding
Connection: close
Content-Type: application/xml; charset=utf-8
<?xml version="1.0" encoding="UTF-8"?>
<response>
<tax>3375</tax>
<surcharge>0</surcharge>
<discount>0</discount>
<reduction>0</reduction>
<rate>0.14</rate>
</response>
|
- línea 7: la cookie de sesión enviada por el servidor en la primera solicitud;
- línea 11: el tipo de documento enviado;
- Líneas 13–20: el documento XML de la respuesta.
En un navegador, después de la autenticación, se obtiene el siguiente resultado:

Las respuestas de error también son documentos XML. Una solicitud con parámetros incorrectos:
| > curl -u admin:admin "http://localhost/php8-oct-2026/scripts-web/tax/version-11/tax-server.php?married=x&children=2"
<?xml version="1.0" encoding="UTF-8"?>
<response>
<errors>
<item>GET method required with only the parameters [married, children, salary]</item>
<item>invalid married parameter [x]</item>
<item>missing salary parameter</item>
</errors>
</response>
|
Una solicitud de un usuario desconocido:
| > curl -u x:x "http://localhost/php8-oct-2026/scripts-web/tax/version-11/tax-server.php"
<?xml version="1.0" encoding="UTF-8"?>
<response>
<error>Authentication failed [x]</error>
</response>
|
22.2. El cliente
Nos centramos ahora en el lado cliente de la aplicación.

Esta arquitectura se implementará con los siguientes archivos:
| scripts-console/tax/version-11
├── Dao
│ └── ClientDao.php
├── Data
│ ├── config-client-ko.json
│ ├── config-client.json
│ ├── errors.json
│ ├── results.json
│ └── taxpayersdata.json
├── Main
│ └── MainTaxClient.php
└── Tests
└── ClientBusinessTest.php
|
En la nueva versión, los únicos cambios son:
- el archivo de configuración [config-client.json];
- la capa [dao] del cliente.
El archivo de configuración [config-client.json] queda así:
| {
"urlServer": "http://localhost/php8-oct-2026/scripts-web/tax/version-11/tax-server.php",
"user": {
"login": "admin",
"passwd": "admin"
},
"httpClientOptions": {
"verify_peer": false,
"verify_host": false
},
"taxPayersDataFilename": "Data/taxpayersdata.json",
"resultsFilename": "Data/results.json",
"errorsFilename": "Data/errors.json",
"dependencies": [
"../version-05/Entities/TaxException.php",
"../version-05/Entities/TaxPayerData.php",
"../version-05/Utilities/Utilities.php",
"../version-05/Dao/TraitDao.php",
"../version-08/Dao/InterfaceClientDao.php",
"Dao/ClientDao.php",
"../version-08/Business/InterfaceClientBusiness.php",
"../version-08/Business/ClientBusiness.php"
]
}
|
- línea 2: la URL del servidor de la versión 11;
- línea 20: la nueva capa [dao] del cliente.
22.2.1. La capa [dao]
La clase [ClientDao] de la versión 9 se modifica para tener en cuenta el nuevo formato de respuesta. Se usa [SimpleXML] para procesar esta respuesta:
| try {
// hacemos la solicitud al servidor
$response = $this->httpClient->request("GET", $this->urlServer, $options);
// el estado, los encabezados y el documento XML de la respuesta, incluso en caso de error (parámetro false)
$statusCode = $response->getStatusCode();
$headers = $response->getHeaders(false);
$content = $response->getContent(false);
} catch (ExceptionInterface $ex) {
// no se pudo contactar al servidor
throw new TaxException("Error communicating with the server ({$ex->getMessage()})", 40, $ex);
}
// registros
// print "$content\n";
// el servidor envía el documento XML <response>...</response>
// las opciones LIBXML_NOERROR y LIBXML_NOWARNING evitan las advertencias de PHP si el XML es inválido
$xml = simplexml_load_string($content, options: LIBXML_NOERROR | LIBXML_NOWARNING);
if ($xml === false || $xml->getName() !== "response") {
throw new TaxException("Invalid server response [$content]", 41);
}
// ¿error?
if ($statusCode !== 200) {
// lanzamos una excepción cuyo mensaje es la respuesta del servidor, convertida a JSON (más conciso),
// completada con su estado HTTP
$serverResponse = json_decode(json_encode($xml, JSON_THROW_ON_ERROR), true, flags: JSON_THROW_ON_ERROR);
$message = json_encode(
["HTTP status" => $statusCode] + $serverResponse,
JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR
);
throw new TaxException($message, 42);
}
// recuperamos la cookie de sesión si aún no se conoce
if ($this->sessionCookie === null) {
foreach ($headers["set-cookie"] ?? [] as $cookie) {
if (preg_match('/^PHPSESSID=(.+?);/', $cookie, $fields) === 1) {
$this->sessionCookie = "PHPSESSID=$fields[1]";
}
}
}
// devolvemos la respuesta: el arreglo [tax, surcharge, discount, reduction, rate]
// en el documento XML, todos los valores son textos: los convertimos a su tipo
return [
"tax" => (int) $xml->tax,
"surcharge" => (int) $xml->surcharge,
"discount" => (int) $xml->discount,
"reduction" => (int) $xml->reduction,
"rate" => (float) $xml->rate,
];
}
}
|
Comentarios
- línea 63: se lee la respuesta del servidor. Es un documento XML [<response>…</response>];
- línea 72: la función [simplexml_load_string] analiza el documento XML recibido y devuelve un objeto [SimpleXMLElement] que representa su elemento raíz, o [false] si el documento no es un documento XML válido. De forma predeterminada, la biblioteca [libxml] que usa [SimpleXML] también informa los errores del documento como advertencias de PHP: las opciones [LIBXML_NOERROR] y [LIBXML_NOWARNING] las suprimen. Se pasan mediante el argumento con nombre [options], lo que evita tener que escribir el parámetro [class_name] que lo precede en la firma de la función;
- línea 73: el método [getName] devuelve el nombre del elemento raíz, que debe ser [response];
- Líneas 77–85: en caso de error, el mensaje de la excepción será la cadena JSON de la respuesta del servidor y no la cadena XML recibida, porque la cadena JSON es más concisa. Para obtener el arreglo asociativo de la respuesta XML, usamos un truco clásico: la función [json_encode] puede convertir un objeto [SimpleXMLElement] en JSON, y [json_decode] convierte luego este JSON en un arreglo. Así, el mensaje de la excepción tiene el mismo formato que en las versiones anteriores;
- líneas 97–103: se devuelve el arreglo de resultados. Se accede a los elementos hijos del elemento [response] como propiedades del objeto [$xml] ([$xml->tax]). En un documento XML, todos los valores son texto: a diferencia de JSON, XML no distingue entre enteros, números reales y cadenas de caracteres. Por lo tanto, cada valor se convierte al tipo que espera la capa [business] mediante los operadores [(int)] y [(float)] . El cliente de PHP 7 devolvía los valores como cadenas.
Prueba
Si ejecuta el cliente en un entorno correctamente configurado (base de datos, autenticación, logs, Redis), obtiene los resultados habituales:
| > php MainTaxClient.php
The results have been saved in the file [Data/results.json]
Done
|
Revise los archivos de la carpeta [taxpayersdata.json, results.json, errors.json]: el archivo [results.json] es idéntico al de las versiones anteriores. En el lado del servidor, los logs son los siguientes:
| 01/10/26 18:12:15.370 : ---new request
01/10/26 18:12:15.370 : Authentication in progress…
01/10/26 18:12:15.370 : Authentication successful [admin]
01/10/26 18:12:15.370 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>55555]
01/10/26 18:12:15.371 : tax data taken from the database
01/10/26 18:12:15.373 : {"response":{"tax":2814,"surcharge":0,"discount":0,"reduction":0,"rate":0.14}}
01/10/26 18:12:15.376 : ---new request
01/10/26 18:12:15.376 : Authentication taken from the session…
01/10/26 18:12:15.376 : valid parameters ['married'=>yes, 'children'=>2, 'salary'=>50000]
01/10/26 18:12:15.377 : tax data taken from Redis
01/10/26 18:12:15.377 : {"response":{"tax":1384,"surcharge":0,"discount":384,"reduction":347,"rate":0.14}}
…
|
Con el archivo de configuración [config-client-ko.json] (usuario desconocido), la salida es:
| > php MainTaxClient.php config-client-ko.json
Error no. 42: {"HTTP status":401,"error":"Authentication failed [x]"}
Done
|
El mensaje de error tiene el mismo formato que en las versiones anteriores, aunque el servidor respondió con un documento llamado XML.
22.2.2. [PHPUnit] Pruebas
La prueba [Tests/ClientBusinessTest.php] corresponde a la versión 10, mientras que el entorno de pruebas es el del cliente de la versión 11. Los resultados son los siguientes:
| > php vendor/bin/phpunit scripts-console/tax/version-11/Tests --testdox
PHPUnit 12.5.37 by Sebastian Bergmann and contributors.
Runtime: PHP 8.5.11
Configuration: .../php8-oct-2026/phpunit.xml
........... 11 / 11 (100%)
Time: 00:00.073, Memory: 16.00 MB
Client Business (Application\Tests\ClientBusiness)
✔ Calculate tax with data set "couple, 2 children, 55555"
✔ Calculate tax with data set "couple, 2 children, 50000"
✔ Calculate tax with data set "couple, 3 children, 50000"
✔ Calculate tax with data set "single, 2 children, 100000"
✔ Calculate tax with data set "single, 3 children, 100000"
✔ Calculate tax with data set "couple, 3 children, 100000"
✔ Calculate tax with data set "couple, 5 children, 100000"
✔ Calculate tax with data set "single, 0 children, 100000"
✔ Calculate tax with data set "couple, 2 children, 30000"
✔ Calculate tax with data set "single, 0 children, 200000"
✔ Calculate tax with data set "couple, 3 children, 200000"
OK (11 tests, 22 assertions)
|
Las pruebas pasan con la validación [assertSame]: los valores devueltos por la capa [dao] son efectivamente de los tipos esperados, gracias a las conversiones realizadas después de leer el documento XML.