Uso de memcached desde Java

Tal vez algunos hayan escuchado de memcached, un software que provee un cache en memoria para cualquier cosa que quieran almacenar de manera temporal. El concepto detrás de este software es muy simple: es como tener un mapa gigante, al cual ustedes le pasan una llave, un valor y una duración o fecha de expiración. El software almacena el valor, que será accesible al pedirlo por la llave bajo la cual fue almacenado; cuando la fecha de expiración pase, el cache ya no devuelve el valor para esa llave, porque ya expiró.

Este software se ha vuelto muy utilizado en varias aplicaciones web por las siguientes razones:

• Es muy fácil de instalar (en Linux/*NIX al menos) y configurar.
• Meter valor al cache y leerlos es bastante rápido, incluso cuando hay varias miles de llaves vigentes.
• Se puede utilizar de manera distribuida, teniendo varias instancias en distintos equipos y ninguna tiene que saber de la existencia de las otras; el cliente es quien hace la distribución de valores a las distintas instancias.
• Hay clientes para varios lenguajes y plataformas: Ruby, C, PHP, y por supuesto Java.

Muchos desarrolladores se han topado con problemas de este tipo: hay valores que se leen de la base de datos, que se obtienen de manera muy específica, y que se tienen que estar leyendo con mucha frecuencia. Cuando la frecuencia de lectura de dichos valores rebasa por mucho la frecuencia con que los mismos valores cambian, conviene usar un cache en memoria. Pero un cache en memoria dentro de la misma aplicación puede aumentar bastante de tamaño y se convierte en un problema de escalabilidad. Con memcached esto se resuelve porque se puede tener un servidor dedicado con bastante memoria (o varios servidores incluso), o bien tener varias instancias repartidas en los equipos disponibles, cada una usando poca memoria (el default es 64MB, pero se pueden configurar para usar 128MB, 256MB o más).

Un ejemplo concreto: en un sitio de comercio electrónico, siempre se tiene el carrito de compras. Este carrito no es otra cosa que una lista de los items que un usuario planea comprar. En una aplicación Java, una solución sencilla es manejar una lista en la sesión de la aplicación. Pero qué pasa si es un sitio donde no se están manejando sesiones porque se tienen demasiados usuarios y entonces se usan puras cookies? Hay que agregar una cookie para el carrito. Pero esa cookie puede crecer bastante si el usuario agrega muchos items al carrito, y aunque sea compacta, ese dato adicional por usuario, cuando son muchos usuarios entrando a un sitio, incrementa mucho el tráfico de red.

Una opción entonces es guardar el carrito en base de datos, con un registro por usuario. Pero entonces hay que hacer un proceso que limpie esa tabla, borrando los carritos que ya tienen mucho tiempo, para evitar que se llene demasiado con datos que ya no se van a utilizar.

Otra opción es usar memcached para almacenar el carrito de cada usuario. Cada carrito se almacena con una llave que es el identificador del usuario, y puede tener un tamaño variable pero generalmente no pasará de un par de kilobytes. De modo que se pueden configurar un par de instancias de memcached para almacenar ahí puros carritos de compras, se les puede poner una duración de un día, que comienza a contarse desde que se almacena el valor por primera vez o cuando se modifica. De este modo, un usuario puede tener "vivo" su carrito si todos los días lo modifica; incluso podemos hacer algo para extender la duración del valor en el cache si es que el usuario regresa diario aunque sea a ver el carrito, sin modificarlo.

Desde Java, una manera sencilla de utilizar memcached es por medio de la biblioteca spymemcached. Su uso es muy simple, sólo hay que crear una instancia de MemcachedClient e indicarle cuáles son las instancias de memcached a las que debe conectarse; con esto tendremos acceso al cache distribuido que ya hemos configurado previamente.

Posteriormente, sólo queda almacenar valores y leerlos, todo por medio del mismo objeto MemcachedClient. La lectura y escritura es de manera similar a un mapa. La escritura se realiza de manera asíncrona, es decir que el método que invocamos, realmente encola una tarea para escribir al memcached, en un threadpool.

Cuando hay varias instancias de memcached disponibles, el cliente determinará en cuál almacenar el valor (y de la misma manera, en cuál instancia buscarlo para obtenerlo), según unos algoritmos definidos por los creadores de memcached, basados en un hashing de la llave.

Se pueden tener varias aplicaciones utilizando el mismo cache, esa es otra de las ventajas: una aplicación puede buscar primero un valor en el cache, al no encontrarlo lo busca en la base de datos y lo pone en el cache, y la segunda aplicación cuando busque en el cache encontrará el valor, ahorrándose una consulta a la base de datos. Pero es importante que todos los clientes de memcached tengan su lista de servidores memcached en el mismo orden, para que almacenen los valores en el mismo lugar; de lo contrario, una aplicación puede almacenar en valor1 en el servidor1 y otra aplicación no lo encontrará porque busca valor1 en el servidor2 (y puede terminar almacenando valor1 en servidor2, duplicando de manera innecesaria los valores en el cache).

Los casos de uso de memcached son muy variados. En general, es muy útil para almacenar valores que se obtienen de base de datos pero que son leídos con mucha frecuencia, por una o varias aplicaciones. Pero algo es muy importante: memcached no es un sustituto de base de datos. Debe utilizarse únicamente para almacenamiento temporal; el caso típico es buscar en el cache un valor, y si no se encuentra, entonces buscar en la base de datos y lo que se obtenga se almacena en memcached, para que ya la próxima vez que se busque, se tenga a la mano en el cache y no haya que buscarlo en base de datos.