Array de bytes y la clase java.nio.ByteBuffer
Un buffer es una secuencia finita de elementos -en este caso, tipos primitivos-. La clase abstracta java.nio.Buffer y sus respectivas subclases concretas (java.nio.ByteBuffer, java.nio.IntBuffer, java.nio.FloatBuffer, etc.) sirven como contenedores para datos de tipos primitivos. Estos buffers forman parte de la API NIO junto a las classes Channel, Selector, entre otras.
Estas clases, en particular java.nio.ByteBuffer, son de especial utilidad en aplicaciones en las cuales tenemos que generar array de bytes y que no justifica usar frameworks demasiado refinados para dicha tarea.
Un java.nio.Buffer tiene algunas propiedades escenciales:
- Capacidad: la cantidad de elementos máxima del buffer. Siempre tiene un valor positivo, y no cambia durante la vida del objeto. Debe ser conocido al momento de inicializar el buffer.
- Límite: según la documentación de
java.nio.Buffer, el límite es “el índice del primer elemento que no debería ser leído ni escrito”. Es un valor entre la posición y la capacidad del buffer. La idea es utilizarlo como marcador para que, luego de terminada la escritura hacia el buffer, sepamos hasta donde lo podemos leer para obtener el array generado. - Posición: la posición actual dentro del bufffer. Es el índice del próximo elemento a leer o escribir.
Funcionalidades básicas
Todas estas funcionalidades están muy detalladas en los javadocs de las clases, pero es interesante repasar las más útiles:
- Operaciones de escritura: la API provee las distintas variantes de operaciones
put, permitiendo agregar bytes y tipos más grandes como serint,long,float, arrays de bytes o incluso el contenido de otro ByteBuffer. Para los tipos de datos que ocupen más de un byte, se considerará la codificación (endianness) seteado utilizando el métodoorder(). Tenemos métodosputpara agregar bytes en posiciones relativas (en la posición actual) o absolutas (en una posición determinada) - Operaciones de lectura: al igual que con las operaciones
put, las operacionesgetpermiten recuperar datos del buffer. Tenemos operaciones para recuperar diferentes tipos de datos (siempre teniendo en cuenta la codificación -endianness- cuando los tipos de datos son multi-byte), para recuperarlos desde la posición actual o desde una posición determinada. También podemos cargar un array de bytes con una sección del buffer. clear(): prepara el buffer para una nueva secuencia de operaciones de escritura, seteando el límite con igual valor que la capacidad, y la posición actual en cero.flip(): prepara el buffer para una secuencia de lecturas, seteando el límite igual a la posición actual, y la posición a cero. Más allá de la capacidad máxima del buffer, permite hacer operaciones sobre la porción que utilizamos anteriormente.rewind(): prepara el buffer para una relectura de la información que contiene, seteando la posición en cero sin cambiar el valor del límite.mark()/reset():mark()setea la marca del buffer en la posición actual. al invocarreset(), cambiamos de posición en el buffer a la última invocación demark().slice(): crea un nuevoByteBuffera partir de la posición actual y hasta el fin del array. Los buffers comparten el array subyacente, por lo que un cambio en los datos se verá reflejado en ambos.array(): retorna el buffer en forma de array.- Chaining (encadenamiento) de invocaciones: los métodos que no deben retornar valores al invocarlos, retornan una referencia a sí mismo, de manera de poder encadenar invocaciones al buffer. El encadenamiento no aporta nuevas funcionalidades, simplemente mejora la usabilidad.
Ejemplo de uso
Imaginemos que necesitamos generar un array de bytes para enviar a un sistema externo, que contiene la siguiente información:
| Campo | Tipo de dato | Largo | Formato |
|---|---|---|---|
| Largo del mensaje | short | 4 | Little Endian |
| Id | long | 8 | Big Endian |
| Largo del nombre | short | 4 | Little Endian |
| Nombre | String | Máximo 30 | - |
| Edad | byte | 1 | - |
| Salario | int | 4 | Big Endian |
Debemos codificar el largo total del mensaje y el largo del nombre como little-endian (es decir, el byte menos significativo va en la primer posición, y el byte más significativo va en la última) en lugar de big-endian -a veces también llamado network order, por ser la codificación definida en el protocolo IP-.
Aprovecharemos las funcionalidades de la clase ByteBuffer para resolver este problema. En particular, ByteBuffer nos permite setear la representación de los enteros de varios bytes en el array, utilizando el método order(ByteOrder bo). Una solución que resuelve la generación del array podría ser la siguiente:
package com.josearrarte.demo;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class ByteBufferDemo {
private static final int SIZEOF_BYTE = 1;
private static final int SIZEOF_SHORT = 2;
private static final int SIZEOF_INT = 4;
private static final int SIZEOF_LONG = 8;
public static void main(String[] args) {
byte[] byteArray = buildByteArray(12345678L, "Pedro Picapiedra", (byte)46, 25000);
String hexString = getHexString(byteArray);
System.out.println(hexString);
}
private static byte[] buildByteArray(long id, String name, byte age, int salary) {
int capacity = 2 * SIZEOF_SHORT + // largos
SIZEOF_LONG + // id
name.length() + // nombre
SIZEOF_BYTE + // edad
SIZEOF_INT; // salario
ByteBuffer buffer = ByteBuffer.allocate(capacity);
// largo de datos
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putShort((short)capacity);
// id
buffer.order(ByteOrder.BIG_ENDIAN);
buffer.putLong(id);
// largo del campo nombre
buffer.order(ByteOrder.LITTLE_ENDIAN).putShort((short)name.length());
// nombre
buffer.order(ByteOrder.BIG_ENDIAN).put(name.getBytes());
// edad
buffer.put(age).putInt(salary);
return buffer.array();
}
private static String getHexString(byte[] array) {
final char[] chars = { '0', '1', '2', '3', '4',
'5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F' };
StringBuilder strBuilder = new StringBuilder();
for (int i = 0; i < array.length; i++) {
byte b = array[i];
byte lowNibble = (byte) (b & 0x0F);
byte highNibble = (byte) ((b & 0xF0) >>> 4);
strBuilder.append(chars[highNibble]);
strBuilder.append(chars[lowNibble]);
strBuilder.append(' ');
}
return strBuilder.toString();
}
}
La salida del programa es:
21 00 00 00 00 00 00 BC 61 4E 10 00 50 65 64 72 6F 20 50 69 63 61 70 69 65 64 72 61 2E 00 00 61 A8
Podemos desglosar la salida para cada dato:
- Largo de datos:
21 00(33) - Id:
00 00 00 00 00 BC 61 4E(12345678) - Largo del campo de nombre:
10 00(16) - Nombre:
50 65 64 72 6F 20 50 69 63 61 70 69 65 64 72 61(“Pedro Picapiedra”) - Edad:
2E(46) - Salario:
00 00 61 A8(25000)
Notemos la facilidad ByteBuffer que nos da a la hora de tener que intercambiar los formatos de enteros y de mezclar distintos tipos primitivos en un mismo array. No tuvimos necesidad de ir calculando las posiciones dentro del array, ni calcular la representación de enteros en formato little-endian o big-endian.
Referencias
API de java.nio.ByteBuffer
API de java.nio.Buffer
http://en.wikipedia.org/wiki/Endianness
http://en.wikipedia.org/wiki/New_I/O
