Tutoriel sur les nouveautés du langage 8 : Type Annotations et Nashorn

Nous avons vu dans les deux précédents articles (lambda et timedate) des fonctionnalités très utiles. Regardons à présent les bonnes idées pour rendre Java encore plus typé via les annotations de type et la prouesse technique de la Nashorn, le moteur JavaScript intégré dans le JDK. Non, vous ne rêvez pas, malgré son âge avancé, Java continue encore de nous surprendre.

Pour cet article, le JDK 8 build b94 a été utilisée. Le dernier build peut être téléchargé depuis jdk8.java.net. L'intégralité des sources est disponible via Github.

Les Annotations de type sont probablement l'une des fonctionnalités faisant le plus débat, mais aussi qui intéresse le moins de monde et ceci alors que la JSR 308, a reçu le prix de la JSR la plus innovante en mai 2007. Son objectif est de rendre Java - un langage fortement typé comme tout le monde le sait - encore plus typé. L'exemple suivant s'assure que la variable « ref » ne soit jamais nulle.

public class GetStarted {
    public void sample() {
        @NonNull Object ref = null; // A checker will throw an exception
    }
}

Avant Java 8, nous ne pouvions utiliser les annotations que sur des déclarations. À présent, elles peuvent être utilisées sur n'importe quel type. Néanmoins, la JDK n'est pas fournie avec un framework de vérification (checking framework), il est par conséquent nécessaire d'écrire/utiliser une bibliothèque (ou plusieurs pour effectuer des vérifications d'ordres différents) à ajouter dans la classpath du compilateur pour qu'il y ait une vérification. On notera que, bien qu'il s'agisse principalement d'une fonctionnalité d'audit ayant pour but de justifier de la qualité du code, elle est extrêmement intrusive et rend le code difficilement lisible.

Map<@NonNull String, @NonEmpty List<@Readonly Document>> files;

Alors que la tendance actuelle est de s'orienter vers plus de dynamisme, il reste quelques irréductibles du statisme et intrinsèquement de la verbosité. De plus, tant qu'il n'y aura pas d'outils permettant une intégration simple dans les modules de serveurs d'intégration continue, il sera difficile d'utiliser ce type d'annotations de manière cohérente dans une équipe de développement. Cet article étant consacré à Java 8 et non à divers frameworks, si vous souhaitez en savoir plus sur le sujet, l'Université de Washington héberge les informations relatives à la JSR 308, ainsi qu'un framework de vérification, ayant une documentation assez détaillée.

Nashorn est le successeur de Rhino, le moteur JavaScript créé par Mozilla. Il est basé sur l'ECMAScript-262 et est implémenté entièrement en Java en utilisant - entre autres - invokedynamic (JSR 292), une nouvelle instruction introduite avec Java 7, notamment pour les lambdas et pour les langages dynamiques. Dans cet article, nous éviterons d'entrer dans les détails de l'implémentation pour nous concentrer sur comment appeler du JavaScript depuis du code Java et inversement. Pour connaître les détails de l'implémentation, je vous invite à consulter le code du projet qui est une véritable mine d'or.

III-A. Du JavaScript en ligne de commande▲

$ jjs -version
nashorn 1.8.0
jjs>

$ jjs
jjs> var x = 10, y = 5
jjs> var z = x + y
jjs> z
15
jjs> print(z)
10
jjs> quit()

III-B. JavaScript depuis Java▲

/*
 * org.isk.nashorn.NashornTest
 */
@Test
public void nashornString() throws ScriptException {
    final ScriptEngineManager factory = new ScriptEngineManager();
    final ScriptEngine engine = factory.getEngineByName("nashorn");
    engine.eval("print(15 + 10)");
}

engine.eval("print(15 + 10)");

/*
 * simple.js
 */
var myVariable = "jsVariable";
 
function sum(a, b) {
    return a + b;
}

/*
 * org.isk.nashorn.NashornTest
 */
@Test
public void nashornFile() throws ScriptException, NoSuchMethodException {
    final ScriptEngineManager factory = new ScriptEngineManager();
    final ScriptEngine engine = factory.getEngineByName("nashorn");
 
    // Build a Reader
    final InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream("simple.js");
    final InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
    engine.eval("var mySecondeVariable = 10");
    engine.eval(inputStreamReader);
 
    // Get a variable from a JavaScript file
    Assert.assertEquals("jsVariable", engine.get("myVariable"));
 
    // Invoke a function from a JavaScript file
    final Invocable invocable = (Invocable)engine;
    final int sum = (Integer)invocable.invokeFunction("sum", 30, 20);
    Assert.assertEquals(50, sum);
 
    // Get a variable
    Assert.assertEquals(new Integer(10), engine.get("mySecondeVariable"));
}

III-C. Java depuis JavaScript▲

$jjs

/*
 * org.isk.nashorn.SimilarJavaCodeTest
 */
@Test
public void timerTask() throws InterruptedException {
    final TimerTask task = new TimerTask() {
        @Override
        public void run() {
            System.out.println("Hello!");
        }
    };
 
    new Timer().schedule(task, 0, 1000);
    Thread.sleep(10000);
    task.cancel();
}

/*
 * jjs_Packages.js
 */
var java = Packages.java;
 
var task = new java.util.TimerTask() {
    run: function() {
        print('Hello!');
    }
}
 
new java.util.Timer().schedule(task, 0, 1000);
java.lang.Thread.sleep(10000);
task.cancel();

/*
 * jjs_ShortPackages.js
 */
var javaPackage = Packages.java;
var TimerTask = java.util.TimerTask;
var Timer = java.util.Timer;
var Thread = java.lang.Thread;
 
var task = new TimerTask() {
    run: function() {
        print('Hello!');
    }
}
 
new Timer().schedule(task, 0, 1000);
Thread.sleep(10000);
task.cancel();

with(java) {
    // Code
}

/*
 * jjs_JavaImporter.js
 */
var java = new JavaImporter(java.lang, java.util);
 
with(java) {
    var task = new TimerTask() {
        run: function() {
            print('Hello!');
        }
    }
 
    new Timer().schedule(task, 0, 1000);
    Thread.sleep(10000);
    task.cancel();
}

/*
 * jjs_ShortPackagesAndClosures.js
 */
var javaPackage = Packages.java;
var TimerTask = java.util.TimerTask;
var Timer = java.util.Timer;
var Thread = java.lang.Thread;
 
var timer = new Timer();
timer.schedule(
    function() {
        print('Hello!');
    }, 0, 1000);
 
Thread.sleep(10000);
timer.cancel();

III-D. Nashorn, une autre révolution ?▲

Comme nous avons pu le voir au cours de ces trois articles, Java 8 peut être considéré comme révolutionnaire. Les nouvelles fonctionnalités ne feront probablement pas revenir les développeurs s'étant dirigés vers Scala, JRuby ou Groovy, néanmoins, elles permettent de donner un nouveau souffle à un langage vieillissant. Et ceci est un point intéressant. Le C et le C++ sont bien plus anciens que Java et pourtant leur âge avancé est synonyme de qualité. On se rend donc compte que Java est rattrapé par ses manques originels. Le fait d'être fourni avec une API et la non-implémentation des lambdas dans des versions antérieures - alors qu'elles existent dans de nombreux langages depuis plusieurs décennies - est un véritable handicap. Mais le problème majeur est probablement la lenteur des évolutions. Nous avons d'un côté de grosses sociétés généralement réfractaires au changement et de l'autre côté des développeurs - d'un nouveau genre - souhaitant des langages répondant à leur besoin tout de suite et non dans dix ans. Il est donc difficile de répondre au besoin de tout le monde. Et on ne peut que se réjouir des nouveautés de Java 8, en attendant la révolution de Java 9. De nombreuses entreprises ont déjà commencé leur révolution, en réduisant la part de Java, soit en le reléguant à des tâches purement backend, soit en le mixant avec d'autres langages. Et ceci n'est pas forcément une mauvaise chose, il ne fait aucun doute que les applications du futur seront des applications polyglottes.

Cet article a été publié avec l'aimable autorisation de la société SoatSoat.

Nous tenons à remercier Philippe Duval pour sa relecture attentive de cet article et Mickaël Baron pour la mise au gabarit.