style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Hello World!!! Kotlin

Introduccion

Este es el inicio de una pequenia serie de posts donde tratare de mostrar una alternativa a Spring y a JEE para la creacion de Servicios, desde la perspectiva del middleware.

Para ello hare uso de una herramienta no tan conocida, pero que ha estado ahi desde hace mucho tiempo (gratuita tambien), facilitando la integracion de sistemas empresariales, esta herramienta es Apache Camel. Apache Camel es en resumen un framework que implementa los Patrones de Integracion Empresariales EIP por sus siglas en ingles, o sea pautas a seguir para facilitar la integracion de Sistemas.

Herramientas de desarrollo

Para poder realizar la primera practica estas son las herramientas que debemos tener instaladas en nuestra maquina:

  • Intellij Community Edition
  • Java SE 9 integrado en el PATH de nuestra maquina de desarrollo
  • Gradle integrado en el PATH de nuestra maquina de desarrollo

Crear el proyecto con Intellij

Primero abrimos IntelliJ y seleccionamos la opcion Create New Project

Seleccionamos Gradle en el menu de la izquierda y marcamos Java y Kotlin(Java) en Additional Libraries and Frameworks

Configuramos el groupId, artifactid y la version del projecto

Le indicamos a IntelliJ que use nuestra distribucion de gradle para que no agregue los wrappers y especificamos la ubicacion de GRADLE_HOME

Finalmente seleccionamos la ubicacion del Projecto

Configurando dependencias

Una vez con nuestro projecto creado, vamos a configurar las dependencias del mismo, en el archivo build.gradle, actualizamos la seccion buildscript para agregar las versiones de camel y log4j

buildscript {
    ext.kotlin_version = '1.2.10'
    ext.camel_version = '2.19.4'
    ext.log_version = '2.10.0'

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

En la seccion de dependencias agregamos las que usaremos en el Hello World

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile "org.apache.camel:camel-core:$camel_version"
    compile "org.apache.camel:camel-jetty:$camel_version"
    compile "org.apache.logging.log4j:log4j-api:$log_version"
    compile "org.apache.logging.log4j:log4j-core:$log_version"
    compile "org.apache.logging.log4j:log4j-slf4j-impl:$log_version"
    compile group: 'javax.activation', name: 'activation', version: '1.1'
    compile group: 'javax.xml.bind', name: 'jaxb-api', version: '2.1'
}

Nota: cuando guardemos el archivo IntelliJ nos va a pedir actualizar Gradle, entonces seleccionamos update Changes, si no lo haces y no elegiste actualizar dependencias automaticamente, Intellij no sincronizara las dependencias y el linter marcara muchos errores.

La primera Ruta

En Camel las rutas son la descripcion del proceso que vamos a relizar, definen los puntos de entrada y salida asi como las decisiones mas importantes del flujo de datos, hay varias maneras de escribir rutas usando un Lenguage de Dominio Espcecificio DSL en ingles, existen varios entre ellos Spring, Java y en un futuro Kotlin.

A mi en lo personal no me gusta Spring, soy de la vieja escuela del JEE: y el DSL de Kotlin todavia no esta disponible a la fecha de este post, pero Kotlin es Java a fin de cuentas y podemos usar el DSL de java en este pequenio projecto.

Para continuar creamos un nuevo Kotlin Java/Class en nuestra carpeta src->main->Java, de nombre RouteHello y con el siguiente contenido:

import org.apache.camel.builder.RouteBuilder

class RouteHello: RouteBuilder() {

    override fun configure() {
        from("jetty:http://{{host}}:{{port}}/index")
                .transform(constant("Hello from Kotlin"))
    }

}

Como se puede observar es un endpoint para jetty (como ring en clojure) usando la propiedad "host" en el puerto "port" y lo que sea que llegue por ahi sera transformado a una constante "Hello from Kotlin", los endpoints http regresan el ultimo valor que tenga la ruta como respuesta. Por lo que al hacer una peticion a http://host:port/index nos debera regresar el contenido "Hello from Kotlin".

Creando las propiedades del proyecto

Es necesario crear dos archivos properties, uno para log4j2 y otro para las configuraciones de las rutas como "host" y "port" agregamos uno archivo properties llamado camel.properties y otro log42.properties ambos en src->main->resources con los siguientes contenidos:

camel.properties:

port=9000
host=0.0.0.0

log4j2.properties:

appender.out.type = Console
appender.out.name = out
appender.out.layout.type = PatternLayout
appender.out.layout.pattern = [%30.30t] %-30.30c{1} %-5p %m%n
rootLogger.level = INFO
rootLogger.appenderRef.out.ref = out

Creando el contexto de Camel

Por ultimo creamos el archivo main de nuestra pequenia aplicacion, selecionamos new Kotlin File/Class dando clic secundario en la carpeta src->main->Java, y le damos por nombre Main con el siguiente contenido:

import org.apache.camel.CamelContext
import org.apache.camel.impl.DefaultCamelContext
import org.apache.camel.impl.SimpleRegistry

import org.apache.camel.component.properties.PropertiesComponent

fun main(args: Array<String>) {
    val simpleRegistry = SimpleRegistry()
    val context :CamelContext = DefaultCamelContext(simpleRegistry)

    val props  =  PropertiesComponent()
    props.setLocation("classpath:camel.properties")
    context.addComponent("properties", props)

context.addRoutes(RouteHello())

    context.start()
}

El codigo crea una instancia de CamelContext algo parecido al contexto de Spring en donde todas la rutas viven y se ejecutan, despues agregamos las configuraciones al proyecto, para que se puedan usar las propiedades en las rutas y finalmente creamos la ruta helloRoute agregandola al contexto de camel.

Ejecutando el projecto

En el archivo src->main->Java->Main.kt damos clic secundario y seleccionamos la opcion "run MainKt", la consola debera mostrar algo como esto:

[                          main] Server                         INFO  jetty-9.3.14.v20161028
[                          main] ContextHandler                 INFO  Started o.e.j.s.ServletContextHandler@ae7950d{/,null,AVAILABLE}
[                          main] AbstractConnector              INFO  Started ServerConnector@7baf6acf{HTTP/1.1,[http/1.1]}{0.0.0.0:9000}
[                          main] Server                         INFO  Started @2298ms
[                          main] DefaultCamelContext            INFO  Route: route1 started and consuming from: jetty:http://0.0.0.0:9000/index
[                          main] DefaultCamelContext            INFO  Total 1 routes, of which 1 are started.
[                          main] DefaultCamelContext            INFO  Apache Camel 2.19.4 (CamelContext: camel-1) started in 0.598 seconds

Ahora podemos abrir nuestro navegador favorito para desarrollo y navegar a la ruta http://0.0.0.0:9000/index obteniendo el resultado esperado

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">