Apis en diferentes lenguajes y frameworks en la plataforma Java

Estoy haciendo una aplicación con n microservicios en n tipos de tecnologías y lenguajes todos en la plataforma Java. 

Los de n tipos de tecnologías es mentiroso solo 2 framework use por ahora Spring boot y micronaut y a decir verdad use un 80% de spring boot pero quiero escribir un post tipo draft, por las dudas si me canso y nunca termino. 

Por ende, vamos a ver como me fue con Spring boot y diferentes lenguajes y luego hablo de micronaut. 

Java: Bueno, esta es la tupla más utilizada y creo que ustedes saben que anda muy bien. No sé si puedo agregar algo más que no sepan. 

Kotlin: Me encanto, por varias razones me parece mejor que java. Kotlin es un lenguaje, muy bueno y muy compatible con java lo que lo hace una opción super fácil de usar y no se sufre nada con la compatibilidad con spring boot. 

Groovy: Igual que Java, no encuentro una buena razón para elegir este lenguaje, esta bueno, pero el tipado dinamico, no ofrece mayor ventaja y si lo usamos con tipando estático, es similar a java o kotlin. 

Scala: Un infierno de incompatibilidad, no le recomiendo utilizar spring boot con scala, tenes que estar siempre cambiando tipos, de tipos de Scala a Java y de Java a Scala. No es una opción práctica...

Clojure: Otro infierno, no solo por los tipos, sino tambien por la generación de clases con anotaciones. Muy trabajoso, al final cuando te funciona una Api, no te acordas para que la querías. 

Micronaut lo utilice muy poco con Groovy y Java y me fue muy bien, casi casi puedo decir que me gusta más que spring boot. Y ahora sigo con Micronaut y Quarkus. 

Top de lenguajes en la JVM

Buscando que lenguajes están en el top 5 de más usados me encontré con esto en la wikipedia : 

As of April 2022, according to the TIOBE Index^[1] of the top 100 programming languages, the top JVM languages are:

• Java (#3), a statically-typed object-oriented language
• Kotlin (#27), a statically-typed language from JetBrains, the developers of IntelliJ IDEA^[2] and Google's preferred language for Android
• Groovy (#32), a dynamic programming language (also with static typing) and scripting language^[2]
• Scala (#36), a statically-typed object-oriented and functional programming language^[3]
• Clojure (#49), a dynamic, and functional dialect of the Lisp programming language^[2]

Lo que me sorprendio no fue la información sino que la wikipedia este tan actualizada. 

Otra cosa que me llamo la atención es que groovy le gane a scala o a clojure, pense que era diferente.

Y bueno, eso es todo, no me critiquen porque pegue algo en ingles en un blog en español, es de la wikipedia, no voy andar cambiando la fuente.  

Dejo link : https://en.wikipedia.org/wiki/List_of_JVM_languages

Libros gratuitos de Java code geeks

 

Get schooled by Java Code Geeks

Download IT Guides!   JavaFX Programming Cookbook JavaFX 2.0 and later is implemented as a native Java library, and applications using JavaFX are written in native Java code. JavaFX Script has been scrapped by Oracle, but development is...     Java Servlet Tutorial A servlet can almost be thought of as an applet that runs on the server side-without a face. Java servlets make many Web applications possible. Java...     Groovy Programming Cookbook Groovy 1.0 was released on January 2, 2007, and Groovy 2.0 in July, 2012. Since version 2, Groovy can also be compiled statically, offering type inference and performance very close to...     Gradle Build Automation Handbook Gradle was designed for multi-project builds which can grow to be quite large, and supports incremental builds by intelligently determining which parts of the build tree are up-to-date,...

Haciendo test con Spock

Si deseas hacer tus test más legibles y acordes a la metodologia BDD, spock es para vos. 

Spock es un framework de test y especificación para aplicaciones Java y Groovy. Lo que lo hace destacar entre la multitud de framework de test es su hermoso y altamente expresivo lenguaje de especificaciones. Gracias a que corre sobre JUnit, Spock es compatible con la mayoría de los IDE, herramientas de compilación y servidores de integración continua. Spock está inspirado en JUnit, jMock, RSpec, Groovy, Scala, Vulcans y otros frameworks y lenguajes.

La idea de spock es que hay diferentes bloques donde uno puede definir el setup del test, el estimulo y la respuesta esperada : 

Bueno, nada mejor que un ejemplo para mostrar la propuesta de este framework: 

def "two plus two should equal four"() {

    given:

        int left = 2

        int right = 2

    when:

        int result = left + right

    then:

        result == 4

}

def "Should be able to remove from list"() {

    given:

        def list = [1, 2, 3, 4]

    when:

        list.remove(0)

    then:

        list == [2, 3, 4]

}

Dejo link: https://spockframework.org/

Libros gratuitos

 

Download IT Guides!   JAXB Tutorial The first specification of JAXB was done in March 2003 and the work process is tracked in the Java Specification Request 31. In this specification request you can find a lot of...     JavaFX Programming Cookbook JavaFX 2.0 and later is implemented as a native Java library, and applications using JavaFX are written in native Java code. JavaFX Script has been scrapped by Oracle, but development is...     Java Servlet Tutorial A servlet can almost be thought of as an applet that runs on the server side-without a face. Java servlets make many Web applications possible. Java...     Groovy Programming Cookbook Groovy 1.0 was released on January 2, 2007, and Groovy 2.0 in July, 2012. Since version 2, Groovy can also be compiled statically, offering type inference and performance very close to...

Libros de Java code geeks

 

Download IT Guides!   Groovy Programming Cookbook Groovy 1.0 was released on January 2, 2007, and Groovy 2.0 in July, 2012. Since version 2, Groovy can also be compiled statically, offering type inference and performance very close to...     Gradle Build Automation Handbook Gradle was designed for multi-project builds which can grow to be quite large, and supports incremental builds by intelligently determining which parts of the build tree are up-to-date,...     Apache Solr Cookbook Providing distributed search and index replication, Solr is designed for scalability and fault tolerance. Solr is the second-most popular enterprise search engine after Elasticsearch. ...     Apache Maven Cookbook An XML file describes the software project being built, its dependencies on other external modules and components, the build order, directories, and required plug-ins. It comes with...

Web API en Groovy, Spring boot y H2

Vamos a hacer una web API con Groovy, Spring boot y H2 (como dice el título)

Primero vamos a bajar nuestro proyecto de https://start.spring.io/ bien no sé como indicar lo que hay que seleccionar. Pero creo que es bastante fácil, groovy, h2, etc. Voy a utilizar maven y dejo el link al final del repositorio y pueden ver el pom. 

Para comenzar vamos a hacer nuestras entidades : 

@Entity
@Table(name = 'Demos')
class Demo {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Integer id

    @Column
    String unTexto

    @Column
    Boolean isUnCampoBool

    @Column
    LocalDate unaFecha

    @OneToMany(cascade = CascadeType.ALL)
    List<DemoItem> items = new ArrayList<>()

}

y

@Entity
@Table(name = 'DemoItems')
class DemoItem {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    Integer id

    @Column
    String unTexto
}

Luego el repositorio : 

@Repository
interface DemoRepository extends JpaRepository<Demo, Integer> {}

Ahora el servicio con su implementación: 

interface DemoService {

    List<Demo> findAll()

    Optional<Demo> findById(Integer todoId)

    Demo insert(Demo demo)

    Demo update(Demo demo)

    Optional<Demo> delete(Integer id)

}

@Service
class DemoServiceImpl implements DemoService {

    @Autowired
    DemoRepository repository

    @Override
    List<Demo> findAll() {
        return repository.findAll()
    }

    @Override
    Optional<Demo> findById(Integer id) {
        return repository.findById(id)
    }

    @Override
    Demo insert(Demo demo) {
        return repository.save(demo)
    }

    @Override
    Demo update(Demo demo) {
        return repository.save(demo)
    }

    @Override
    Optional<Demo> delete(Integer id) {
        Optional<Demo> demo = repository.findById(id)
        if (demo.isPresent()) {
            repository.delete(demo.get())
        }
        return demo
    }
}

Y por ultimo el controller : 

@RestController
@RequestMapping('demo')
class DemoController {

    @Autowired
    DemoService service

    @GetMapping
    List<Demo> findAll(){
        service.findAll()
    }

    @PostMapping
    Demo save(@RequestBody Demo demo){
        service.insert(demo)
    }

    @PutMapping
    Demo update(@RequestBody Demo demo){
        service.update(demo)
    }

    @DeleteMapping('/{id}')
    delete(@PathVariable Integer id){
        Optional<Demo> demo = service.delete(id)
        if (!demo.isPresent()) {
            throw new NotFoundException<Demo>(id)
        }
        return demo.get()
    }

    @GetMapping('/{id}')
    Demo getById(@PathVariable Integer id){
        Optional<Demo> demo = service.findById(id)
        if (!demo.isPresent()) {
            throw new NotFoundException<Demo>(id)
        }
        return demo.get()
    }

}

Y el controller lanza una excepción cuando no encuntra elementos que es esta : 

@ResponseStatus(code = HttpStatus.NOT_FOUND, reason = "not found")
class NotFoundException<T> extends RuntimeException {

    private Long id

    NotFoundException() {}

    NotFoundException(Long id) {
        this.id = id
    }

    @Override
    String getMessage() {
        return T + " not found"
    }
}

Y listo!!!

Dejo el repositorio Github : https://github.com/emanuelpeg/GroovyWebAPI

Libros Gratuitos de Java Code Geeks

 

Download IT Guides!   Java Servlet Tutorial A servlet can almost be thought of as an applet that runs on the server side-without a face. Java servlets make many Web applications possible. Java...     Groovy Programming Cookbook Groovy 1.0 was released on January 2, 2007, and Groovy 2.0 in July, 2012. Since version 2, Groovy can also be compiled statically, offering type inference and performance very close to...     Gradle Build Automation Handbook Gradle was designed for multi-project builds which can grow to be quite large, and supports incremental builds by intelligently determining which parts of the build tree are up-to-date,...     Apache Solr Cookbook Providing distributed search and index replication, Solr is designed for scalability and fault tolerance. Solr is the second-most popular enterprise search engine after Elasticsearch. ...

Por qué GraalVM?

Lo único malo que veo en GraslVM es el marketing que están llevando. Dado que GraalVM es un proyecto paraguas donde hay varios proyectos. Entre los que tenemos una maquina virtual más rápida, la capacidad de compilar nuestras aplicaciones de forma nativa o diferentes plataformas o ejecutar varios lenguajes. 

Lo que hace que cuando hablemos de GraalVM, estemos hablando de cosas diferentes, todo a la vez. 

GraalVM es un maquina virtual java de alto rendimiento que proporciona mejoras significativas en el rendimiento y la eficiencia de la aplicación, lo que es ideal para microservicios. Está diseñado para aplicaciones escritas en Java, JavaScript, lenguajes basados ​​en LLVM como C y C++, y otros lenguajes dinámicos. Elimina el aislamiento entre lenguajes de programación y habilita la interoperabilidad en un tiempo de ejecución compartido. Puede ejecutarse de forma independiente o en el contexto de OpenJDK, Node.js u Oracle Database.

Para las aplicaciones Java existentes, GraalVM puede proporcionar beneficios al ejecutarlas más rápido, brindar extensibilidad a través de lenguajes de secuencias de comandos o crear imágenes nativas compiladas.

GraalVM se puede ejecutar en el contexto de OpenJDK para hacer que las aplicaciones Java se ejecuten más rápido con una nueva tecnología de compilación jit. GraalVM se hace cargo de la compilación del byte code de Java en código de máquina. En particular, para otros lenguajes basados ​​en JVM como Scala, esta configuración puede lograr beneficios, como por ejemplo, lo experimentó Twitter al ejecutar GraalVM en producción.

GraalVM permite ejecutar JavaScript, R, Python, Ruby, LLVM IR y Web Assembly en el contexto de aplicaciones Java. Ofrece la capacidad de exponer las estructuras de datos de Java a esos lenguajes con filtros de acceso de host detallados. La integración es independiente del lenguaje, es decir, una integración para JavaScript también se puede utilizar en un punto posterior para ejecutar cualquier otro lenguaje basado en GraalVM. Los mecanismos de proxy permiten simular objetos dinámicos de estructuras de datos Java y exponerlos a los scripts integrados. 

La ejecución de su aplicación dentro de una máquina virtual Java conlleva costos de inicio y de espacio. GraalVM tiene una función para crear imágenes nativas para aplicaciones existentes basadas en JVM. El proceso de generación de imágenes emplea análisis estático para encontrar cualquier código accesible desde el método principal de Java y luego realiza una compilación completa con anticipación (AOT). El binario nativo resultante contiene todo el programa en forma de código máquina para su ejecución inmediata. Se puede vincular con otros programas nativos y, opcionalmente, puede incluir el compilador GraalVM para soporte de compilación complementaria Just-In-Time (JIT) para ejecutar cualquier lenguaje basado en GraalVM con alto rendimiento. Para obtener un rendimiento adicional, se pueden crear imágenes nativas con optimizaciones guiadas por perfiles recopiladas en una ejecución anterior de la aplicación. Vea un ejemplo de cómo crear imágenes nativas aquí.

GraalVM puede ejecutarse en el contexto de Node.js reemplazando V8 con GraalVM para ejecutar JavaScript. Los principales beneficios de hacerlo es habilitar aplicaciones políglotas (por ejemplo, usar bibliotecas Java, R o Python), ejecutar Node.js con configuraciones de montón grandes y recolectores de basura de Java, o usar la interoperabilidad de GraalVM para definir estructuras de datos en C / C ++ y utilícelos desde JavaScript.

GraalVM permite el uso de bibliotecas Java existentes o frameworks Java (como Spark o Flink) directamente desde Node.js. Además, se puede usar, por ejemplo, R o Python para ciencia de datos o trazar directamente desde una aplicación JavaScript.

El motor de JavaScript V8 incluido en la distribución estándar de Node.js está optimizado para las configuraciones del navegador y diseñado para funcionar de manera efectiva en escenarios de almacenamiento pequeño. Habilitamos la ejecución de Node.js con la gestión de montón de la JVM, lo que abre la posibilidad de configuraciones de montón grandes y configuraciones adecuadas de recolección de basura. El tamaño máximo de pila configurable es de 32 Gb con punteros comprimidos de 32 bits, y se admiten terabytes de pila en la configuración de puntero de 64 bits.

GraalVM permite una combinación eficiente de código nativo (por ejemplo, escrito en C / C ++) y JavaScript. Se puede acceder directamente a las estructuras de datos nativas y el compilador puede integrarse a través de cualquier límite. Esto puede ser beneficioso en un escenario donde las estructuras de datos eficientes se administran y asignan en C mientras que otras partes de la aplicación están escritas en Node.js. 

Ruby, R, Python, WebAssembly son experimentales en el ecosistema GraalVM y no se recomiendan para uso de producción en este momento, pero estamos trabajando activamente en la estabilidad y el soporte para todos los módulos para esos lenguajes. En este momento, podemos ejecutar aplicaciones más simples de Ruby, R y Python, pero no tenemos la misma compatibilidad total que proporcionamos para las aplicaciones Java y Node.js. WebAssembly actualmente implementa la especificación WebAssembly MVP (producto mínimo viable) y es el lenguaje más reciente en el entorno GraalVM.

Además de los beneficios estándar de GraalVM, como la interoperabilidad de idiomas (por ejemplo, usar Java o JavaScript desde esas aplicaciones), GraalVM puede lograr altas velocidades de 10 veces o más para esos idiomas. Nos complace ayudarlo a hacer que las aplicaciones Ruby y R existentes funcionen con GraalVM, pero todavía no podemos garantizar la compatibilidad inmediata para estos idiomas.

GraalVM está diseñado para integrarse y se puede ejecutar en bases de datos. El prototipo de Oracle Database Multilingual Engine (MLE) está disponible. Permite a los usuarios de Oracle Database ejecutar JavaScript, utilizando browserify para ejecutar módulos Node.js y escribir extensiones en Python.

GraalVM Native Image, actualmente disponible como tecnología de pioneros, funciona con muchos marcos de microservicios Java diferentes. Varios proyectos ya han aceptado esta tecnología como plataforma para sus aplicaciones: Quarkus, Micronaut, Helidon. Para estos marcos, las imágenes nativas de GraalVM reducen significativamente los requisitos de memoria en tiempo de ejecución en comparación con la ejecución en HotSpot. Creemos que la tecnología GraalVM Native Image puede convertirse en la mejor manera de implementar aplicaciones nativas en la nube.

Fomentamos el desarrollo de incrustaciones de GraalVM similares a nuestras propias integraciones en Oracle Database, OpenJDK o Node.js. Junto con socios de colaboración de investigación, ya exploramos ideas de incrustación en Spark o Flink. Encuentre una descripción sobre cómo incrustar GraalVM en su aplicación nativa o basada en JVM existente aquí.

GraalVM es un ecosistema abierto e invitamos a los sistemas de terceros a participar conectando sus propios lenguajes de programación, herramientas o plataformas.

El marco de implementación de Truffle Language permite ejecutar lenguajes de programación de manera eficiente en GraalVM. Simplifica la implementación del lenguaje al derivar automáticamente código de alto rendimiento de los intérpretes. Puede encontrar detalles sobre el enfoque en este artículo de investigación.

Implementar su propio lenguaje usando GraalVM no solo le dará un alto rendimiento. Más importante aún, permite que su lenguaje se conecte con las herramientas enriquecidas proporcionadas por el ecosistema GraalVM. Además, permite que su lenguaje se ejecute en el contexto de cualquier incrustación de GraalVM.

Se Desarrollao un lenguaje de demostración llamado "SimpleLanguage" para mostrar el uso del marco de implementación del lenguaje de GraalVM. 

GraalVM proporciona un marco para crear herramientas independientes del lenguaje como depuradores, perfiladores u otras instrumentaciones. GraalVM proporciona una forma estandarizada de expresar y ejecutar código de programa que permite la investigación en varios idiomas y el desarrollo de herramientas que se desarrollan una vez y luego se pueden aplicar a cualquier idioma.

Dejo link: 

https://www.graalvm.org/docs/why-graal/