Archivo de la categoría: Tutoriales

try-with-resources en Kotlin

Una de las grandes novedades que nos trajo Java 7 fue el soporte para try-with-resources, que nos permitía definir bloques que, utilizando un recurso que implementara la interfaz “AutoCloseable“, cerraban éste implícitamente sin tener que preocuparnos de llamar a su método “close()“. Por ejemplo:

try (BufferedReader br = new BufferedReader(new FileReader(path))) {
   return br.readLine();
}

Kotlin provee una solución equivalente para los objetos del tipo “Closeable“, que es la función “use“:

BufferedReader(FileReader("dsf")).use {
    it.readLine()
}

Sin embargo, parece que los creadores de Kotlin se han olvidado de las clases AutoCloseable, tales como los PreparedStatement de JDBC. Para solucionarlo, he creado una función trywr, fácilmente integrable en cualquier código

package info.macias.kotlin
inline fun <T:AutoCloseable,R> trywr(closeable: T, block: (T) -> R): R {
    try {
        return block(closeable);
    } finally {
        closeable.close()
    }
}

Un ejemplo de uso sencillo:

import info.macias.kotlin.trywr
fun countEvents(): Long {
    return trywr(connection.prepareStatement("SELECT COUNT(*) FROM event")) {
        var rs = it.executeQuery()
        rs.next()
        rs.getLong(1)
    }
}

No obstante, me comentan en Stackoverflow que aunque la solución es sencilla y hará su función, no reproducirá exactamente el comportamiento estándar de Java.

Integrando Kotlin en aplicaciones web

Java, pese a las impresionantes mejoras que trae en su versión 8, siempre me ha parecido un lenguaje un poco verboso y con algunas incomodidades con respecto a C#.

Lenguajes como Python, Ruby o ECMAScript son cómodos y ágiles, pero no me gustan para proyectos de cierta envergadura puesto que, siendo tan despistado como soy, prefiero lenguajes con tipado estático que me muestren los errores en tiempo de compilación y ahorrarme tener que buscarlos con el depurador.

Groovy es un gran lenguaje, aunque un tanto lento. A la filosofía Scala no me he acabado de acostumbrar, y siempre acabo haciendo programas con la misma estructura que si de un programa Java se tratara. Además, he tenido algunos problemas tratando de integrar Scala con librerías Java.

A pesar de las críticas que programadores “new age” lanzan por una cuestión de moda, me gusta la Máquina Virtual de Java y el impresionante número de librerías y frameworks maduros que posee. No cambiaría para irme a Rails o Node, a pesar de sus muchas otras ventajas. Quizás la cambiaría para irme a .NET si éste finalmente llega a ser completamente multiplataforma (otro sacrilegio, no solo para programadores “new age”  si no también para aquellos que asocian automáticamente Microsoft con malvado y malo).

Durante estas vacaciones he tenido tiempo de probar por encima Kotlin, y la verdad es que las primeras impresiones han sido buenas. Principalmente, me ha gustado, entre otras:

  • Es estáticamente tipado
  • Le quita verbosidad a Java
  • Getters y setters directamente definidos en los atributos, y no como métodos (al estilo de C# o Groovy)
  • Null safety
  • Sobrecarga de operadores al estilo de C++
  • Data classes
  • Lo extremadamente bien que se integra con las librerías existentes de Java
  • El soporte de Jetbrains le da en su IDE, incluida la funcionalidad de traducir automáticamente código Java a Kotlin

Como demostración (y para mi utilidad propia en aplicaciones futuras), he creado este pequeño proyecto web que integra Kotlin con algunas librerías para el desarrollo web, tales como Struts 2 y Tiles para la gestión del Modelo Vista Controlador, Shiro para la gestión de la seguridad, y Jersey para la implementación de servicios REST.

El enlace en cuestión, con sus respectivas instrucciones de puesta en marcha: https://github.com/mariomac/kwebbt

 

EasyRPC: crea fácilmente servicios RPC en puro Java

Acabo de publicar una versión inicial de EasyRPC en GitHub.  EasyRPC es una librería que automáticamente crea servicios y clientes web en tiempo de ejecución para Java.

Las características que destaco son:

  • Fácil de adoptar y usar. Descarga las librerías y úsalas directamente en el código para crear servicios web como cualquier otra clase Java, sin necesidad de lidiar con las complejidades de la serialización y el envío de datos.
  • Comunicación a través de HTTP y AMQP 1.0. Extensible a otros protocolos de comunicación.
  • Serialización a través de JSON-RPC 2.0. Extensible a otras especificaciones (SOAP, ProtoBuf…)

Todo ello, insistiendo, programando simples clases Java de la misma manera en que se programarían para ser ejecutadas en local.

A continuación se muestra un ejemplo de uso:

Programación del servidor

Paso 1: crea una interfaz con los métodos de tu servicio.

public interface IFace {
    int add(int a, int b);
    String concat(String s1, String s2);
    int[] doubleArray(int[] arr);
}

Paso 2: implementa la el servicio como una clase Java corriente que se fuera a ejecutar en local.

public class Implementation implements IFace {
    @Override
    public int add(int a, int b) {
        return a+b;
    }
    @Override
    public String concat(String s1, String s2) {
        return s1+s2;
    }
    @Override
    public int[] doubleArray(int[] arr) {
        for(int i = 0 ; i < arr.length ; i++) {
            arr[i] = arr[i] * 2;
        }
        return arr;
    }
}

Paso 3: instancia el servidor, especificando el protocolo de comunicación y el tipo de serialización.

Ejemplo 1: JSON-RPC 2.0 a través de HTTP

RpcServer server = new RpcServer(
            new HttpService(8080,"/rpc"),
            new JSONCallee());

Ejemplo 2: JSON-RPC 2.0 a través de AMQP 1.0:

RpcServer server= new RpcServer(
      new AmqpService(
              new URI("amqp://localhost:5672"),
              "rpcQueue"),
      new JSONCallee());

Paso 4: registra  el servicio a través de la clase que lo implementa, e inicia el servidor.

server.addEndpoint(new Implementation());
server.start();

Uso del cliente

Paso 1: obtén la interfaz IFace que describe el servicio a ejecutar. Ésta debe ser proporcionada por el proveedor, compartiendo, por ejemplo, el código fuente o un archivo JAR.

Paso 2: instancia el generador de clientes. En el ejemplo, habilita la comunicación a través de HTTP y la serialización a través de JSON-RPC 2.0.

ClientFactory clFact =
     new ClientFactory(
             new HttpClient(
                     "server.address.com",
                     8080, "/rpc"),
     new JSONCaller());

Paso 3: instancia el cliente.

IFace ws = (IFace) clFact.instantiate(IFace.class);

Paso 4: usa el servicio:

int result = ws.add(2,3);
String completo = ws.concat("Hola", " mundo!");

Tu blog gratis en la nube con OpenShift

OpenShift es una Plataforma como Servicio (Platform as a Service, PaaS) muy chula que provee la empresa Red Hat, que además proporciona tres “small gears” gratuitos al cualquier usuario (un “gear” es la unidad de capacidad de OpenShift).

Quien quiera un blog personal que reciba pocas visitas puede aprovecharse de este servicio para tener en cuestión de minutos un blog en WordPress totalmente operativo y configurable, sin las limitaciones de los blogs gratuitos que ofrece wordpress.com, sin publicidad de terceros y sin que le cueste ni un céntimo.

En este tutorial, aprenderás a:

  • Crear un blog en WordPress con OpenShift
  • Instalar el paquete de idioma español para WordPress en Openshift
  • Configurar WordPress, OpenShift y tu gestor de dominios para usar tu propio dominio

Seguir leyendo Tu blog gratis en la nube con OpenShift