Michele Nasti

Thoughts on what I learn

Realizzare un piccolo motore di Scripting in una webapp Java con Groovy

<a href="https://i2.wp.com/michelenasti.com/uploads/2016/01/2000px-Groovy-logo.svg_.png" rel="attachment wp-att-526"><img class="size-medium wp-image-526 alignleft" src="https://i0.wp.com/michelenasti.com/uploads/2016/01/2000px-Groovy-logo.svg_-300x149.png?fit=300%2C149" alt="2000px-Groovy-logo.svg" srcset="https://i2.wp.com/michelenasti.com/uploads/2016/01/2000px-Groovy-logo.svg_.png?resize=300%2C149 300w, https://i2.wp.com/michelenasti.com/uploads/2016/01/2000px-Groovy-logo.svg_.png?resize=768%2C380 768w, https://i2.wp.com/michelenasti.com/uploads/2016/01/2000px-Groovy-logo.svg_.png?resize=1024%2C507 1024w, https://i2.wp.com/michelenasti.com/uploads/2016/01/2000px-Groovy-logo.svg_.png?resize=700%2C347 700w, https://i2.wp.com/michelenasti.com/uploads/2016/01/2000px-Groovy-logo.svg_.png?w=1840 1840w" sizes="(max-width: 300px) 100vw, 300px" data-recalc-dims="1" /></a>

Alla Webapp a cui stiamo lavorando abbiamo dovuto integrare un motore di scripting per aiutare gli specialisti che dovranno interfacciarsi con gli strumenti di laboratorio.

Nella precedente versione dell'applicazione, realizzata in Visual Basic, questi script erano realizzati in PL/SQL (perchè c'era bisogno di leggere e scrivere dati sul DB)... ma questa scelta ora non è più praticabile perchè noi vogliamo supportare più DB.

Così tra ieri e oggi mi sono messo a cercare un po' di info su quale fosse il miglior linguaggio scriptabile e integrabile con Java, che avesse le seguenti caratteristiche:

  • deve poter accedere al database e “vivere” nella stessa transazione del chiamante
  • deve poter chiamare i servizi Java già creati (solitamente creati come bean spring)
  • i servizi Java devono poter chiamare questi eventuali script
  • devono poter essere sostituiti “on-the-fly”, senza spegnere e accendere il software.

Il management aveva individuato Drools come uno dei possibili tools che il team già conosce, che non risponde però a tutti i requisiti. Il mio compito era di continuare a investigare per trovare altre alternative.

let me google “Java Scripting” for you

Fin dall'inizio ho pensato a Groovy ma da qualche parte ho letto che Spring supporta altri due linguaggi, che ho dovuto scartare:

  • BeanShell. Purtroppo i siti web a riguardo non sono molto aggiornati, e sembra che il progetto sia ospitato su github ora. Il sito ufficiale è in disuso dal 2005, github non viene aggiornato da 4 mesi e comunque c'è stato un solo avanzamento di versione in 10 anni. Ci sono dubbi sulla compatibilità con Java8 e, da una mia prova, non riesce a chiamare bean autowired di spring.
  • JRuby. Ruby è un grande linguaggio e sulla JVM diventa incredibilmente potente, portabile, veloce. Peccato che la sua sintassi sia estremamente complicata per uno scripter alle prime armi.

Così siamo arrivati a Groovy. Andate sul sito web se volete leggere le caratteristiche, ma la cosa che ci importava è che

  • supporta una grande parte della sintassi Java (e si possono chiamare classi Java come String, Integer, Boolean...)
  • è sponsorizzato da SpringSource
  • esiste da una decina d'anni (e aveva le clojures dalla prima versione!)
  • Ad oggi è molto utilizzato come framework per lo sviluppo web, ad esempio col framework Grails.

Il problema delle transazioni l'ho risolto grazie a questo articolo, come potete vedere il data source e il transaction manager vengono definiti in Hibernate e poi passati all'oggetto SQL di Groovy.

La possibilità di Autowirizzare i bean Groovy e di utilizzare i bean Spring è stata un'altra cosa spiegata “abbastanza” bene nel capitolo 34 della guida di Spring.

Show me the code!

Come prima cosa ho creato un'interfaccia <span class="lang:default decode:true crayon-inline">GroovyScripterInterface</span> in JAVA:

/**
* Created by Michele on 20/01/2016.
*/

public interface GroovyScripterInterface {

public void sayHello();
}

e una classe Groovy che la implementa:

import groovy.sql.Sql import org.springframework.beans.factory.annotation.Autowired

/**
* Created by Michele on 20/01/2016.
*/

class GroovyScripter implements GroovyScripterInterface {

@Autowired Sql sql

@Autowired ServizioFarlocco servizioFarlocco

void sayHello() {
printf('\n\n\n\nHello! ' + sql + '\n\n\n\n\n')
servizioFarlocco.mangia()
return
}
}

Groovy tradurrà questo codice groovy in una classe Java, e su queste classi si potrà utilizzare AOP, annotazioni, transazioni, etc.

ServizioFarlocco invece è una classe Java che non fa nulla di chè.

L'oggetto SQL invece è definito nella configurazione di Hibernate, andate a vedere il primo articolo linkato (quello sulle transazioni in groovy).

E infine ecco l'XML in cui sono definiti i due bean (Java e Groovy):

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:lang="http://www.springframework.org/schema/lang"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/lang
http://www.springframework.org/schema/lang/spring-lang.xsd"

>



<context:annotation-config />

<bean id="servizioFarlocco"
class="it.eng.areas.eliot.interoperability.ServizioFarlocco">

</bean>

<lang:groovy
id="groovyScript"
script-source="path/to/GroovyScript.groovy"
refresh-check-delay="5000"
/>


</beans>

Da notare che il parametro <span class="lang:default decode:true crayon-inline ">refresh-check-delay</span> serve a Spring per verificare se il file è stato aggiornato. il valore 5000, espresso in millisecondi, significa “verifica ogni 5 secondi se il file è stato aggiornato”. script-source invece è il path (non il package, per questo ci vogliono gli slash).

Per concludere un bel test JUnit, quindi da Java chiamiamo il bean Groovy (che chiama un altro bean Java) :

@ContextConfiguration(locations = {"file:context/application-context-junit.xml"})
@TransactionConfiguration(defaultRollback = false)
@Transactional
public class GroobyBeanTest extends AbstractTransactionalJUnit4SpringContextTests {

@Autowired
private GroovyScripterInterface groovyScripterInterface;

@Test
public void groovyTest() {
groovyScripterInterface.sayHello();
}

}

Conclusioni

sembra di aver imboccato la strada giusta. Agli "specialisti" del prodotto darò in dote un fantastico linguaggio di scripting con cui potranno fare quello che vogliono. Nel frattempo vi chiedo: avrei potuto seguire altre strade, conoscete altri strumenti per questo compito?