Soporte datos binarios

Desde la versión 2.18 de Sofia2 añadimos soporte para en envío y recepción de Datos Binarios, automatizando el envío y recepción a través del API Java. Haciendo uso del Wizard de Creación de Ontologías Campo a Campo o el nuevo Modelado Visual de Ontologías podemos seleccionar el nuevo tipo de datos, Binary.

Este tipo de datos, define un Objeto con una estructura definida
“properties”: { 
 “data”: { 
 “type”: “string” }, 
 “media”: {
 “type”: “object”, 
 “required”: [ 
 “name”, 
 “storageArea”, 
 “binaryEncoding”, 
 “mime” ], 
 “properties”: { 
 “name”: { 
 “type”: “string” }, 
 “storageArea”: { 
 “type”: “string”,
 “enum”: [ “SERIALIZED”, “DATABASE”, “URL” ] }, 
 “binaryEncoding”: { 
 “type”: “string”, 
 “enum”: [ “Base64” ] }, 
 “mime”: { 
 “type”: “string”, 
 “enum”: [ “application/pdf”, “image/jpeg” ] }
 } 
 } 
 }, 
 “additionalProperties”: false }
Dividida en dos grandes bloques, data donde enviaremos el fichero serializado y media que contiene la meta-información asociada al fichero, información como el nombre del fichero, el mime-type asociado o el modo de serialización utilizado.
Para facilitar el trabajo con este nuevo tipo de Datos, se ha dotado al API Java de capacidades para automatizar en la medida de lo posible el envío y recepción de este tipo de datos. La clase SSAPMessageGenerator dispone de los siguientes métodos para cumplir este objetivo.
public void addBinary(String fieldName, File binary, Mime mimethrows BinarySizeException
 
Este método al que informamos el nombre del campo, el fichero que queremos añadir y el mime-type se encarga de serializar en Base64 el fichero que le pasamos, debemos observar que puede lanzar la excepción BinarySizeException, esta excepción es lanzada cuando el pool de binarios ocupa más de 1000000 Bytes (El fichero serializado en Base64 ocupa del orden de un 20% más que en formato binario).
NOTA: Pese a que se lance la excepción BinarySizeException el fichero es añadido al pool de ficheros y puede ser procesado para su envío a través de la instancia de la ontología, pero debemos de ser conscientes del coste del envío de ficheros largos y de la limitación que se puede establecer en el servidor para rechazar ontologías con un tamaño  elevado, por defecto el servidor no aceptará ontologías con un tamaño superior a 1500000 Bytes
 
public void removeBinary(String fieldName)
 
Método que permite borrar un binario que hubiésemos añadido al pool de binarios.
public void cleanBinary()
 
Método que permite borrar el pool de binarios, borrando todos los binarios que hubiésemos añadido.
    public String generateJSONBinary()
Método que devuelve la estructura JSON con todos los datos binarios que hubiésemos añadido al pool de binarios, para ser añadido a la instancia de ontología que queremos enviar al SIB.
Los método anteriores nos permiten enviar datos binarios al Sib, el proceso inverso, recuperar datos binarios del SIB cuenta con el método public Map<String, SSAPBinaryMessage> getBinary(String JSON), el cual nos devuelve un Map con clave campo de la instancia de ontología y valor el dato binario y su meta-información asociada.
Vamos a ejemplificar su uso.
//Generamos el objeto de utilidades
SSAPMessageGenerator generator = new SSAPMessageGenerator();
 
La ontología que vamos a utilizar tiene un atributo de tipo Binary que se llama binario, por lo que para añadir un fichero indicamos que queremos añadirlo a este campo, y en este caso al tratarse de un PDF le indicamos que es un mime-type APPLICATION_PDF
try {
//Añado el fichero al pool de binarios.
generator.addBinary(“binario”new File(“/DOC124013.pdf”), Mime.APPLICATION_PDF);
catch (BinarySizeException e1) {
//El fichero ocupa mas de 1000000 Bytes, puedo enviarlo pero no se garantiza el servidor lo rechace
}
 
Generamos el extracto JSON del tipo de dato Binary para luego añadirlo a la instancia de la Ontología.
 
//Generamos el JSON del extracto del tipo de dato Binary
String datos = generator.generateJSONBinary();
 
El resultado de esto es una cadena de texto con el dato binario señalizado y su meta-información, es importante observar que el atributo data ha sido deliberadamente acortado pues el binario serializado tiene una longitud de 32000 caracteres.
 
“binario”:{“data”:”JVBERi0xLjQKJeLjz9MKMSAwIG9iago8PC9UeXBlIC9YT2JqZWN0Ci9Db2xvclNwYWNlIC9EZXZpY2VHcmF5Ci9TdWJ0eXBlIC9JbWFnZQovQml0c1BlckNvbXBvbmVudCA4Ci9XaWR0aCAxMzc…”,”media”:{“binaryEncoding”:”Base64″,”mime”:”application/pdf”,”name”:”DOC124013.pdf”,”storageArea”:”SERIALIZED”}}
Una vez hemos preparado la instancia de la Ontología únicamente queda enviarla al SIB, el siguiente proceso sería el inverso, la lectura de datos binarios proporcionados desde el SIB. Para ello actuamos de la forma habitual, solicitando una instancia de ontología al SIB.
SSAPMessage query = generator.generateQueryMessage(sessionKey“Documentos”“select * from Documentos”, SSAPQueryType.SQLLIKE);
 
Le pedimos al SIB los datos de la Ontología Documentos.
{“data”:”[ 
{ \”_id\” : { \”$oid\” : \”5512ed9d30041343b1b1a4b1\”} , \”contextData\” : { \”session_key\” : \”70c6d177-ad78-446c-977f-64bc572266a1\” , \”user\” : \”sofia\” , \”kp\” : \”KpScanner\” , \”kp_instancia\” : \”ScanerPdf\” , \”timestamp\” : { \”$date\” : \”2015-03-25T18:17:17.002Z\”}} , \”Documentos\” : { \”binario\” : { \”data\” : \”JVBERi0xLjQKJeLjz9MKMSAwIG9iago8PC9UeXBlIC9YT2J…\” , \”media\” : { \”binaryEncoding\” : \”Base64\” , \”mime\” : \”application/pdf\” , \”name\” : \”DOC124016.pdf\” , \”storageArea\” : \”SERIALIZED\”}}}} , 
 
{ \”_id\” : { \”$oid\” : \”5513dbd23004a77721e3da8c\”} , \”contextData\” : { \”session_key\” : \”f2ec1d30-18aa-41a9-83a2-0c9da9e89898\” , \”user\” : \”sofia\” , \”kp\” : \”KpScanner\” , \”kp_instancia\” : \”ScanerPdf\” , \”timestamp\” : { \”$date\” : \”2015-03-26T11:13:37.857Z\”}} , \”Documentos\” : { \”binario\” : { \”data\” : \”JVBERi0xLjQKJeLjz9MKMSAwIG9iago8PC9UeXBlIC9YT2JqZWN0Ci9Db2xvclNwYWNlIC9EZXZpY2VHcmF5Ci9TdWJ0eXBlIC9JbWFnZQovQml0c1BlckNvbXBvbmVudCA4…” , \”media\” : { \”binaryEncoding\” : \”Base64\” , \”mime\” : \”application/pdf\” , \”name\” : \”DOC124013.pdf\” , \”storageArea\” : \”SERIALIZED\”}}}}]”,
 
“error”:null,”errorCode”:null,”ok”:true}
Nos devuelve un Array con las instancias de la ontología Documentos.
ObjectMapper jmapper = new ObjectMapper();
List<Object> dataMap = jmapper.readValue( retorno.getData(), List.class );
Recuperamos cada uno de los elementos del Array y lo procesamos para recuperar los Datos Binarios asociados
for (LinkedHashMap instancia : dataMap){
Map<String, SSAPBinaryMessage> binarios = generator.getBinary(instancia);
Por cada instancia de ontología obtendremos un Map con los objetos binarios asociados a cada tipo de dato Binary, donde la clave de cada elemento será el nombre del atributo binary. Por último los objetos de tipo SSAPBinaryMessage, disponen del método.
 
public byte[] getBinaryData()
El cual nos devuelve el dato binario deserializado en formato byte[].
Soporte datos binarios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s