Créer des applications Java avec IBM Cloud Functions

Pour obtenir une description d'IBM Cloud Functions proprement dit, voir Création d'une application PHP avec IBM Cloud Functions --Qiita.

Hello World

Créé à l'aide de IntelliJ IDEA (ci-après abrégé en IntelliJ). L'environnement est Mac.

Ouvrez IntelliJ et cliquez sur "Créer un nouveau projet" ou créez un projet à partir de "Fichier" - "Nouveau" - "Projet".

Sélectionnez Gradle sur la gauche, vérifiez Java sur la droite et cliquez sur Suivant.

Le Groupid peut être vide si vous ne prévoyez pas de le déployer dans le référentiel Maven. Entrez le nom du projet dans ArtifactId. Ici, c'est sample-java. Laissez la version par défaut.

Cochez Utiliser l'importation automatique.

Terminez avec le nom du projet et l'emplacement du projet tels quels.

Une fois terminé, le traitement initial de Gradle est effectué et la structure du répertoire est la suivante.

Cliquez avec le bouton droit sur le répertoire src --main --java et créez une classe Java.

Le nom est Sample.

Reportez-vous au code dans exemple Java pour créer et lancer des actions Cloud Functions.

import com.google.gson.JsonObject;
public class Sample {
    public static JsonObject main(JsonObject args) {
        String name = "stranger";
        if (args.has("name"))
            name = args.getAsJsonPrimitive("name").getAsString();
        JsonObject response = new JsonObject();
        response.addProperty("greeting", "Hello " + name + "!");
        return response;
    }
}

Vers Sample.java. Ajoutez gson aux dépendances de build.gradle pour importer gson.

version '1.0-SNAPSHOT'

apply plugin: 'java'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    compile 'com.google.code.gson:gson:2.6.2'  //ajouter
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

Une fois ajouté, gson sera installé.

Jetons maintenant un œil à build.gradle.

Définissez la version de ce projet avec la version.

apply plugin: 'java'

Définissez le plug-in Java avec [^ 1]. Vous pouvez maintenant utiliser les paramètres et les tâches utilisés en Java. La structure de répertoires créée par la création d'un projet IntelliJ

└── src/
    ├── main/
    │   ├── java/
    │   └── resources/
    └── test/
        ├── java/
        └── resources/

Mais c'est la présentation de projet par défaut du plug-in Java

src/main/Source Java pour les produits Java
src/main/ressources Ressources produits
src/test/Source Java pour le test Java
src/test/ressources Test des ressources

Il est devenu.

Définissez les référentiels pour utiliser le référentiel central Maven.

Ecrire des bibliothèques de dépendances dans les dépendances. Écrivez la dépendance au moment de la compilation dans compile et la dépendance supplémentaire au moment de la compilation du test dans testCompile. Le style d'écriture est différent entre compile et testCompile, mais le style d'écriture de compile est

compile group: 'com.google.code.gson', name: 'gson', version: '2.6.2'

Version abrégée de. Les paramètres Gradle sont écrits en Groovy, mais comme Groovy peut omettre les parenthèses de la méthode, les parenthèses ne sont pas ajoutées à compile. Comme il ne peut pas être omis s'il n'y a pas d'argument, il est attaché à mavenCentral ().

Vous pouvez vérifier la version, l'application, la compatibilité source, les référentiels et les dépendances définis ici dans Projet.

Maintenant, fabriquez un pot. Cliquez sur Gradle sur le côté droit d'IntelliJ pour afficher la fenêtre des projets Gradle.

Si vous exécutez "Tasks" - "build" - "jar", vous obtiendrez un jar appelé sample-java-1.0-SNAPSHOT.jar dans build / libs.

Ou il y a un fichier appelé gradlew dans le répertoire du projet, alors utilisez ceci

$ ./gradlew jar

Mais vous pouvez créer un pot. gradlew est appelé un wrapper gradle, qui télécharge les binaires gradle si nécessaire.

Vérifions le contenu du pot.

$ jar -tf build/libs/sample-java-1.0-SNAPSHOT.jar
META-INF/
META-INF/MANIFEST.MF
Sample.class

-t est une option pour afficher le contenu de l'archive, -f est une spécification de fichier.

jar est un fichier compressé au format zip.

$ file build/libs/sample-java-1.0-SNAPSHOT.jar
build/libs/sample-java-1.0-SNAPSHOT.jar: Zip archive data, at least v1.0 to extract

En passant, le contenu du fichier compressé peut être visualisé avec Vim.

$ vim build/libs/sample-java-1.0-SNAPSHOT.jar
" zip.vim version v28
" Browsing zipfile /Users/tmsanrinsha/IdeaProjects/sample-java/build/libs/sample-java-1.0-SNAPSHOT.jar
" Select a file with cursor and press ENTER

META-INF/
META-INF/MANIFEST.MF
Sample.class

Placez le curseur sur la ligne «META-INF / MANIFEST.MF» et appuyez sur Entrée

Manifest-Version: 1.0

Le contenu est affiché sous la forme.

Télécharger l'action.

$ bx wsk action create sample-java build/libs/sample-java-1.0-SNAPSHOT.jar --main Sample

Exécuter.

$ bx wsk action invoke sample-java --result
{
    "greeting": "Hello stranger!"
}

Définissez les paramètres et exécutez.

$ bx wsk action invoke sample-java --result -p name reader
{
    "greeting": "Hello reader!"
}

S'il existe des bibliothèques dépendantes

$ jar -tf build/libs/sample-java-1.0-SNAPSHOT.jar
META-INF/
META-INF/MANIFEST.MF
Sample.class

En regardant le contenu du pot, Gson n'est pas inclus. Cependant, Gson fonctionne même s'il n'est pas fourni par IBM Cloud Functions.

Création d'actions OpenWhisk avec Java et Gradle - Blog IBM Cloud avec les bibliothèques dépendantes Il y a un exemple.

Réécrivez Sample.java comme suit. Il s'agit d'un programme qui renvoie le texte reçu sous forme de code QR.

import java.io.*;
import java.util.Base64;
import com.google.gson.JsonObject;
import com.google.zxing.*;
import com.google.zxing.client.j2se.MatrixToImageWriter;
import com.google.zxing.common.BitMatrix;

public class Sample {

    public static JsonObject main(JsonObject args) throws Exception {
        String text = args.getAsJsonPrimitive("text").getAsString();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        OutputStream b64os = Base64.getEncoder().wrap(baos);

        BitMatrix matrix = new MultiFormatWriter().encode(text, BarcodeFormat.QR_CODE, 300, 300);

        MatrixToImageWriter.writeToStream(matrix, "png", b64os);

        b64os.close();

        String output = baos.toString("utf-8");
        JsonObject response = new JsonObject();
        response.addProperty("qr", output);

        return response;
    }
}

Réécrivez build.gradle comme suit.

version '1.0-SNAPSHOT'

apply plugin: 'java'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

configurations {
    provided
    compile.extendsFrom provided
}

dependencies {
    provided 'com.google.code.gson:gson:2.6.2'
    compile 'com.google.zxing:core:3.3.0'
    compile 'com.google.zxing:javase:3.3.0'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

jar {
    dependsOn configurations.runtime
    from {
        (configurations.runtime - configurations.provided).collect {
            it.isDirectory() ? it : zipTree(it)
        }
    }
}

Le réglage de ce gradle est basé sur Fat Jars with Excluded Dependencies in Gradle.

Premier,

configurations {
    provided
    compile.extendsFrom provided
}

Définissez provided dans et [ʻextends From`](https://docs.gradle.org/current/dsl/org.gradle.api.artifacts.Configuration.html#org.gradle.api.artifacts. Hériter de la compilation fournie à l'aide de Configuration: extendFrom (org.gradle.api.artifacts.Configuration [])).

Dans dependencies, celles qui n'ont pas besoin d'être incluses dans le fichier jar sont définies dans provided, et celles qui sont incluses sont définies dans compile. Puisque «compile» dépend de «provided», la dépendance écrite dans «provided» est également incluse au moment de la compilation.

Je fais dependOn avec jar, mais cela a fonctionné sans lui, donc je ne sais pas si c'est là.

[de](https://docs.gradle.org/current/dsl/org.gradle.api.tasks.bundling.Jar.html#org.gradle.api.tasks.bundling.Jar:from(java. lang.Object [])) est utilisé pour définir les fichiers à inclure dans le fichier jar. Inclus dans «from» est «configurations.runtime» moins «configurations.provided». Selon configurations de dépendances, runtime est un héritage de compile, donc compile est dans runtime. Et la dépendance de «provided» est entrée, et elle est soustraite par «provided», donc seule la dépendance de «compile» reste.

Faire un pot,

$ ./gradlew jar

$ jar -tf build/libs/sample-java-1.0-SNAPSHOT.jar

Si vous le faites, vous pouvez voir que des bibliothèques autres que Gson sont incluses.

mise à jour

$ bx wsk action update sample-java build/libs/sample-java-1.0-SNAPSHOT.jar --main Sample

Exécuter

$ bx wsk action invoke sample-java --result -p text 'Hello world!'
{
    "qr": "iVBORw0KGgoAAAANSUhEUgAAASwAAAEsAQAAAABRBrPYAAABHElEQVR42u3aPRKCMBCG4VBxDI5KjpojWFIR2ezyEx3Uwiyj86ZwgjxU32w2/IT8ybgFGAwGg8F+ik3BxpDnMOapy9H+6GB+TI9yHGSWepkdT8CcWJRgooalF0
h2sEvYHhbsOiY52QUwf5brQnm3vsEasK2JT1Y3b3o9rAGrRlxPvt73wr7NJgumRDTK4Zj6WX5gfkxGEpG0bo4VBPNidfsIS07lNm+ZZZgfs4iWsMoFs9ZNGDLMj+mYrUaShvW8lYI5MItt1JNldtbrYQ3YoV8Ys9u8HubItvYha5a2871uYG5
sf7xhD8D7sr3qYFcwa+JBbzBOw4I1Zw/vImBubH8ZtNZNeLG+wVqw6qFf/UIC5sX4HAIGg8Fgf8Pu1ACAFLpztaIAAAAASUVORK5CYII="
}

Le résultat reviendra correctement. Pour faire ce png

bx wsk action invoke sample-java --result -p text 'Hello world!' | jq -r .qr | base64 -d > qr.png

Comme

$ open qr.png

Ensuite, le code QR sera affiché.

Créer une méthode de débogage

Ajoutez public static void main (String [] args) pour que vous puissiez jouer avec les ʻargs de public static JsonObject main (JsonObject args) `.

public class Sample {

    public static void main(String[] args) throws Exception {
        String str;
        if (args.length == 0) {
            str = "{\"text\":\"Hello stranger\"}";
        } else {
            str = args[0];
        }
        JsonObject jsonArgs = new JsonParser().parse(str).getAsJsonObject();
        System.out.println(main(jsonArgs).toString());
    }

    public static JsonObject main(JsonObject args) throws Exception {
// ...
    }
}

Maintenant, si un argument est donné et exécuté, le premier argument est exécuté, sinon str est utilisé pour exécuter public static JsonObject main (JsonObject args).

Si vous créez une méthode de public static void main (String [] args), vous pouvez l'exécuter en mettant une marque ▶ sur le côté gauche du code IntelliJ et en cliquant dessus.

Si vous souhaitez définir l'argument, vous pouvez le définir à partir de "Exécuter" - "Modifier les configurations ...". Cependant, il serait plus facile de corriger le «str» dans le code.

Si vous souhaitez l'exécuter sur Gradle, ajoutez ce qui suit à build.gradle.

// ...
apply plugin: 'java'
apply plugin: 'application' //ajouter à

mainClassName = 'Sample' //ajouter à

sourceCompatibility = 1.8
// ...

Le Plugin d'application vous permet d'utiliser une tâche appelée run pour exécuter une application. Le nom de la classe principale est défini avec mainClassName.

avec ça

$ ./gradlew run

Peut être exécuté avec. Vous pouvez également l'exécuter à partir de Tâches --application --run dans la fenêtre des projets Gradle.

Cependant, il n'est pas possible de passer des arguments directement avec gradle task. Selon tâche Gradle - passer les arguments à l'application Java - débordement de pile

run {
    if (project.hasProperty("appArgs")) {
        args Eval.me(appArgs)
    }
}

Pour build.gradle

$ ./gradlew run -PappArgs='"{\"text\":\"a\"}"'

Peut être exécuté avec des arguments.

Gérer avec Git

Les fichiers suivants ne sont pas nécessaires, alors écrivez-les dans .gitignore.

`.gitignore`


.gradle/
.idea/
build/

Lors de l'importation, spécifiez l'URL GitHub, etc. dans "Fichier" - "Nouveau" - "Projet à partir du contrôle de version". Projet Gradle non lié? Apparaîtra, donc je vais faire un projet Import Gradle.

Au lieu d'importer depuis le contrôle de version, vous pouvez git clone, sélectionnez" Fichier "-" Nouveau "-" Projet à partir de sources existantes ... ", et sélectionnez Gradle dans" Importer le projet Gradle ".

Échantillon fait cette fois

https://github.com/tmsanrinsha/ibm-cloud-functions-sample-java

Matériel de référence

[^ 1]: Chapitre 23 Java Plugin, [The Java Plugin --Gradle User Manual](https: //docs.gradle) .org / current / userguide / java_plugin.html). Notez que le japonais est ancien.