Lenguajes JVM

Otros lenguajes para la JVM (Groovy, Scala, Clojure, etc)

Como andar de metiche con Camel

Introduccion

Este es el ultimo post de la serie :(.

Bueno aunque no a todos nos gusta que nos estén supervisando y que nos digan a cada instante que haces, como vas, que paso, etc. En las aplicaciones es todo lo contrario, monitorear una aplicación ya no es mas un addon o un extra en las aplicaciones modernas (solía serlo por ahi del 2007): sino que se debe tener como indispensable.

A veces es requerido trabajo extra para implementarlo, otras veces solo instalar una aplicacion y muchas otras un dolor de cabeza, porque nunca se pensó que se debía monitorear.

Bueno sea el caso que sea, ahora vamos a revisar como monitorear nuestra aplicación creo yo de una forma simple.

Prerequesitos

Hawtio

Kotlin, Undertow como proxy

Introduccion

Las tecnologias del front están creciendo como la espuma y bien sabemos que el front ya no es solamente hacer validaciones o hacer marquesinas, ahora se desarrollan aplicaciones enteras con el concepto de Single Page Applications, dejando a Java solo en el Middleware o en Android. Y después de Kotlin ya ni en Android :P. Seamos sinceros al comparar una aplicación hecha con React o con Angular contra una aplicación en JSF, se nota el porque casi todas las grandes compañías del mundo voltearon a ver a Nodejs (que es mucho muy bueno) y a tecnologías puramente de Front.

Dejando atrás las discusiones sobre si Tomcat o Spring Batch o EJB o Nodejs, que ademas de nunca acabar, no dejan de ser servidores que entregan archivos HTML, JS, CSS y otros (pdf, imagenes, txt, csv, xls, xml), que pueden estar hechos como tu quieras (React, Angular, Aurelia, Vue, Jquery). Por lo que un servidor http siempre esta involucrado; muchas soluciones actuales dejan totalmente el Front en Nodejs y los servicios en Java, otros combinan Nginx con Nodejs y Java; mientras otros solo Java o solo Nodejs.

Kotlin, Camel y MyBatis

Introducción

Ya con nuestro servicio en forma de mock, podemos empezar a extenderlo un poco mas e incluir mas endpoints. En ese sentido agregaremos consultas a una base de datos, usando MySQL; no sera una tabla muy grande, pero servirá para ejemplificar el proceso. El mapeador de objetos java a SQL sera MyBatis, voy a hacer enojar a muchos tal vez, pero considero que JPA es de los frameworks mas obscuros del mundo Java :D, no se enojen; a mi no me gusta, no significa que no sea util para alguien.

Vamos a obtener los datos de la base para las operaciones que ya creamos, getAll y getByID, asimismo agregaremos una operación mas para insertar Preguntas en la base.

Prerequisitos

Ahora si tenemos mas pre-requisitos:

  • MySQL instalado en donde sea pero que tengamos acceso a una base
  • El conector jdbc-mysql en el repo local de maven
  • El proyecto hasta el POST anterior

La Base de Datos

La base por ahora solo sera una tabla QUESTION, con la estructura siguiente:

CREATE TABLE IF NOT EXISTS `questions`.`QUESTION` (

Kotlin, Camel y CXF

Mock del primer servicio

Una vez que tenemos la base del proyecto, podemos agregar nuestro primer servicio REST usaremos la referencia JAX-RS 2 con la implementacion Apache CXF.

Nuestro primer servicio sera un endpoint de preguntas, con dos operaciones la primera consultar una lista de preguntas, de momento escritas en el mismo codigo, y la segunda de esa lista de preguntas obtener una en particular por su codigo.

Prerequisitos

De momento el unico requerimiento previo es tener nuestro proyecto como lo dejamos en el primer post.

Mensajes de Camel

Apache camel al igual que EJB estan basados en los principios de lo que ahora conocemos como microservicios antes de que incluso se llamaran asi, pequenias aplicaciones que al sumarse todas dan como resultado un proceso complejo, cada microservicio se comunica con otros para resolver la tarea en especifica que tiene asignada.

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

Kotlin, parte 3: Métodos de extensión y sobrecarga de operadores

Kotlin permite la sobrecarga de operadores, como Scala y C++, pero de manera controlada, como Groovy. Es decir, no se pueden definir operadores de manera arbitraria como en Scala, donde se puede definir un método ~->, pero sí se pueden tener métodos que se puedan invocar con operadores como +, -, *, [] etc.

Es curioso que siendo un lenguaje con tipado estático, no se fueron por el camino "limpio" para implementar esto, que era definir interfaces para los operadores (por ejemplo, Summable, o Plus, Minus, etc), sino que lo implementaron de igual manera que en Groovy, sólo que pues en Groovy funciona porque es un lenguaje dinámico. Esto presenta dos problemas: primero, que hay que saberse muy bien cuáles son los operadores que se pueden sobreescribir, junto con los nombres de los métodos correspondientes, los cuales no siempre son obvios a la hora de estar implementado uno (Para usar / ¿es divided, quotient, div o qué?) y el otro, que es más difícil saber si una clase tiene operadores sobrecargados o no, ya que hay que revisar los métodos que implementa, en vez de simplemente revisar las interfaces que implementa, y honestamente es más fácil simplemente hacer prueba y error (a ver si funciona si le pongo un +).

Kotlin, parte 2: (not so) typesafe null y otras monerías

Una característica importante de Kotlin es que maneja seguridad en nulos. Esto es algo que varios lenguajes han estado implementando últimamente, porque ahorra muchos dolores de cabeza.

Normalmente, una variable de cualquier tipo que sea objeto, acepta null. En Kotlin no es así; para que una variable acepte null, se necesita especificar de esa forma. Esto no compila:

var x:String = "hola"
x = null

Porque x ha sido definida como de tipo String, y no acepta nulos. Para que acepte nulos, se tiene que definir así:

var x:String? = "hola"
x = null

Los tipos opcionales se pueden usar en parámetros de funciones, tipos de retorno y declaraciones locales.

Cuando se tiene un valor que puede ser null, no se puede usar de manera directa. Hay que verificar que el objeto exista; esto se puede lograr de varias formas:

var x:String? = "hola"
if (x != null) {
  //Aquí dentro, x ya se considera String
  println(x.length)
}
val largo = x?.length //largo será tipo `Int?`
//Se puede usar el operador "Elvis" con tipos opcionales
println(x ?: "no hay x")

Kotlin: El nuevo lenguaje del emperador (1 de 3)

Hace unas semanas, Google anunció con bombo y platillo que ya soportan oficialmente Kotlin en Android. Para mucha gente, esta fue la primera vez que escucharon algo acerca del lenguaje y, como era de esperarse, a partir de ese momento han salido supuestos expertos en Kotlin hasta debajo de las piedras, ofreciendo seminarios y cursos y demás.

Yo llevo unos años siguiéndole la pista a Kotlin medio de lejos, por mi trabajo en Ceylon; así que creo que es un buen momento para contarles mi opinión al respecto. No les voy a decir si deben usar Kotlin o no; escribo esto porque estoy seguro que muchos lo van a probar y probablemente lo empiecen a usar en proyectos reales, pero tal vez por razones muy simples como la sintaxis o que si no tiene punto y coma o, simplemente, porque no es Java (esta es la razón más popular por la que recibió tan cálida bienvenida en el mundo de Android).

Construyendo proyectos con Gradle (instalación con SDKMAN!)


En el post pasado hablé sobre SDKMAN! , una herramienta que nos permite instalar lenguajes de programación como Ceylon, Java, Groovy, etc. Tambien nos permite instalar herramientas como Gradle, la cual nos permite construir y administrar proyectos.

Antes de empezar deberías dar un vistazo al anterior post .

Tan sencillo como teclear desde la terminal (cmd o linux shell) lo siguiente:
$sdk install gradle

Comprobar la versión instalada:
$gradle --version
$gradle -v

Debería salir algo como esto:

------------------------------------------------------------
Gradle 3.5
------------------------------------------------------------

Build time: 2017-04-10 13:37:25 UTC

JDBI como alternativa a JDBC, JPA, Hibernate ...

Para todos aquellos que estén cansados de usar siempre lo mismo (JDBC, JPA, Hibernate, etc.) cuando trabajan con base de datos en sus aplicaciones pueden optar por usar JDBI, una librería que promete facilitarnos la existencia. Su página oficial dice:

JDBI is a SQL convenience library for Java. It attempts to expose relational database access in idiommatic Java, using collections, beans, and so on, while maintaining the same level of detail as JDBC. It exposes two different style APIs, a fluent style and a sql object style

No me dejaran mentir al decir que cuando se trabaja con aplicaciones demasiado robustas los desarrolladores sufrimos al trabajar con extensos archivos confusos y difíciles de mantener. Peor aún cuando el equipo original de trabajo "olvido" documentar el proyecto.

Distribuir contenido