Convertir HTML a XPS
El lenguaje de marcado de hipertexto (HTML) es un lenguaje de marcado estándar para la creación de páginas web. Permite la creación y estructura de secciones, párrafos y enlaces utilizando elementos/etiquetas HTML. Y en caso de que se utilicen algunas fuentes personalizadas en un archivo HTML o se haga referencia a cualquier objeto dinámico que requiera una conexión activa a la máquina/servidor de origen, existe la posibilidad de comprometer la fidelidad del documento. Por otro lado, en XML Paper Specification (XPS), los elementos de la página se definen independientemente de un sistema operativo, una impresora o una aplicación de visualización en particular. Entonces, un enfoque inteligente es convertir HTML a formato XPS.
API de conversión de HTML
Aspose.HTML Cloud SDK para Java es una API ligera basada en arquitectura REST que brinda las capacidades para crear, manipular y convertir archivos HTML a PDF, DOCX, TIFF, JPEG , etc. También admite la conversión de HTML a XPS. Entonces, primero, debemos agregar los siguientes detalles en pom.xml del proyecto de tipo de compilación Maven para incluir el SDK en nuestro proyecto Java.
<repositories>
<repository>
<id>aspose-cloud</id>
<name>artifact.aspose-cloud-releases</name>
<url>https://artifact.aspose.cloud/repo</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-html-cloud</artifactId>
<version>20.7.0</version>
<scope>compile</scope>
</dependency>
</dependencies>
Después de la instalación, el siguiente paso es una suscripción gratuita a nuestros servicios en la nube a través de Aspose.Cloud Dashboard usando GitHub o cuenta de Google. O simplemente cree una nueva cuenta y obtenga los detalles de sus Credenciales de cliente.
Convertir HTML a XPS en Java
Siga las instrucciones que se especifican a continuación para desarrollar un convertidor de HTML a XPS.
- En primer lugar, necesitamos especificar detalles contra los métodos Configuration.setAPPSID y Configuration.setAPIKEY
- En segundo lugar, establecemos los detalles para setBasePath(..), setAuthPath(..) y especificamos setUserAgent(…) como WebKit
- En tercer lugar, para nuestra propia ayuda, vamos a configurar setDebug(..) como verdadero
- Ahora crea un objeto de la clase ConversionApi
- Especifique los detalles del margen y el nombre de la información del archivo resultante
- Finalmente, llame al método GetConvertDocumentToXps(…) que requiere ingresar el nombre HTML, las dimensiones y los detalles del margen como argumentos
// para obtener más ejemplos, visite https://github.com/aspose-html-cloud/aspose-html-cloud-java
try
{
// Obtenga ClientID y ClientSecret de https://dashboard.aspose.cloud/
String clientId = "bbf94a2c-6d7e-4020-b4d2-b9809741374e";
String clientSecret = "1c9379bb7d701c26cc87e741a29987bb";
// detalles para la invocación de API
com.aspose.html.Configuration.setAPP_SID(clientId);
com.aspose.html.Configuration.setAPI_KEY(clientSecret);
com.aspose.html.Configuration.setBasePath("https://api.aspose.cloud/v3.0");
com.aspose.html.Configuration.setAuthPath("https://api.aspose.cloud/connect/token");
com.aspose.html.Configuration.setUserAgent("WebKit");
com.aspose.html.Configuration.setDebug(true);
// Crear un objeto de Aspose.HTML Cloud API
com.aspose.html.api.ConversionApi htmlApi = new ApiClient().createService(ConversionApi.class);
// El documento html del almacenamiento en la nube
String name = "list.html";
// formato de imagen resultante
String outFormat = "PNG";
Integer width = 800; // Resulting image width.
Integer height = 1000; // Resulting image height.
Integer leftMargin = 10; // Left resulting image margin.
Integer rightMargin = 10; // Right resulting image margin.
Integer topMargin = 10; // Top resulting image margin.
Integer bottomMargin = 10; // Bottom resulting image margin.
Integer resolution = 300; // Resolution of resulting image.
String folder = null; // The folder in the storage. Should exist.
String storage = "Internal"; // Name of the storage. null
// Invocar la API para la conversión de HTML a XPS
retrofit2.Call<okhttp3.ResponseBody> call = htmlApi.GetConvertDocumentToXps(name, width, height, leftMargin, rightMargin, topMargin, bottomMargin, folder, storage);
System.out.println("HTML to XPS conversion sucessfull !");
}catch(Exception ex)
{
System.out.println(ex);
}
El código anterior devuelve el resultado en el flujo de respuesta, por lo que, para guardar la salida en una unidad local, podemos considerar usar el siguiente método personalizado.
/*
* Método que toma ResponseBody y el nombre del archivo resultante como argumentos
*/
public static void checkAndSave(retrofit2.Call<okhttp3.ResponseBody> call, String fileName) throws IOException
{
// Envíe sincrónicamente la solicitud y devuelva su respuesta.
retrofit2.Response<okhttp3.ResponseBody> res = call.execute();
// El cuerpo de respuesta deserializado de una respuesta exitosa
okhttp3.ResponseBody answer = res.body();
//Guardar en el directorio de prueba
boolean result = saveToDisc(answer, fileName);
// validar que el valor del resultado sea verdadero (paso opcional)
Assert.assertTrue(result);
}
/*
*
* Llame a este método para guardar el contenido de la respuesta como archivo en la unidad local
*
*/
public static boolean saveToDisc(okhttp3.ResponseBody body, String fileName)
{
// crear un objeto de archivo que indique la ubicación del archivo resultante
File savedFile = new File("c:\\Downloads\\"+fileName);
try (InputStream inputStream = body.byteStream();
OutputStream outputStream = new FileOutputStream(savedFile))
{
byte[] fileReader = new byte[4096];
long fileSizeDownloaded = 0;
while (true) {
int read = inputStream.read(fileReader);
if (read == -1) break;
// guardar la secuencia de archivos en la unidad local
outputStream.write(fileReader, 0, read);
fileSizeDownloaded += read;
}
// borrar la instancia de flujo de salida
outputStream.flush();
// devolver verdadero como archivo guardado con éxito
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
} // saveToDisc ends here
Imagen 1: - Vista previa de HTML a XPS
Los archivos de muestra utilizados en el ejemplo anterior se pueden descargar desde list.html y resultantFile.xps.
HTML a XPS usando comandos cURL
También se puede acceder a las API REST a través de los comandos cURL, por lo que en esta sección aprenderemos los pasos sobre cómo realizar la conversión de HTML a XPS con el comando cURL. Ahora, como requisito previo, primero debemos generar un token web JSON (JWT) en función de sus credenciales de cliente individuales. Ejecute el siguiente comando para generar el token JWT.
curl -v "https://api.aspose.cloud/connect/token" \
-X POST \
-d "grant_type=client_credentials&client_id=bbf94a2c-6d7e-4020-b4d2-b9809741374e&client_secret=1c9379bb7d701c26cc87e741a29987bb" \
-H "Content-Type: application/x-www-form-urlencoded" \
-H "Accept: application/json"
Ahora que tenemos el token JWT, ejecute el siguiente comando en la terminal para realizar la conversión de HTML a XPS.
curl -v -X GET "https://api.aspose.cloud/html/list.html/convert/xps" \
-H "accept: multipart/form-data" \
-H "authorization: Bearer <JWT Token>" \
-o final.xps
Conclusión
Este artículo ha explicado los detalles para convertir HTML a XPS utilizando la API REST. Hemos aprendido los pasos para convertir HTML a XPS utilizando fragmentos de código Java, así como a través de comandos cURL. Además, tenga en cuenta que la Documentación del Producto es una excelente fuente para conocer las increíbles capacidades que ofrece la API. Además, si encuentra algún problema al utilizar la API, no dude en ponerse en contacto con el Foro gratuito de soporte de productos.
Artículos relacionados
También recomendamos visitar los siguientes blogs para obtener más detalles sobre: