Réempaqueter un fichier WAR dans un fichier JAR

Ce document explique comment réempaqueter une application Java 8 en tant que fichier JAR à exécuter sur les environnements d'exécution Java 11/17.

Votre application doit comporter une classe Main qui démarre un serveur Web répondant aux requêtes HTTP sur le port spécifié par la variable d'environnement PORT, généralement 8081.

Exemple :

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.webapp.Configuration.ClassList;
import org.eclipse.jetty.webapp.WebAppContext;

/** Simple Jetty Main that can execute a WAR file when passed as an argument. */
public class Main {

  public static void main(String[] args) throws Exception {
    if (args.length != 1) {
      System.err.println("Usage: need a relative path to the war file to execute");
      System.exit(1);
    }
    System.setProperty("org.eclipse.jetty.util.log.class", "org.eclipse.jetty.util.log.StrErrLog");
    System.setProperty("org.eclipse.jetty.LEVEL", "INFO");

    // Create a basic Jetty server object that will listen on port defined by
    // the PORT environment variable when present, otherwise on 8080.
    int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8080"));
    Server server = new Server(port);

    // The WebAppContext is the interface to provide configuration for a web
    // application. In this example, the context path is being set to "/" so
    // it is suitable for serving root context requests.
    WebAppContext webapp = new WebAppContext();
    webapp.setContextPath("/");
    webapp.setWar(args[0]);
    ClassList classlist = ClassList.setServerDefault(server);

    // Enable Annotation Scanning.
    classlist.addBefore(
        "org.eclipse.jetty.webapp.JettyWebXmlConfiguration",
        "org.eclipse.jetty.annotations.AnnotationConfiguration");

    // Set the the WebAppContext as the ContextHandler for the server.
    server.setHandler(webapp);

    // Start the server! By using the server.join() the server thread will
    // join with the current thread. See
    // "http://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Thread.html#join()"
    // for more details.
    server.start();
    server.join();
  }
}

Exemple de migration WAR

Les instructions suivantes montrent comment réempaqueter une application Java 8 hello-world App Engine en tant que fichier JAR à exécuter sur l'environnement d'exécution Java 11/17.

La migration utilise l'artefact appengine-simple-jetty-main. Cela fournit une classe Main avec un serveur Web Jetty simple qui charge un fichier WAR et empaquette votre application dans un fichier JAR exécutable :

Clonez l'artefact Embedded Jetty Server sur votre ordinateur local :
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples
```
Vous pouvez également télécharger l'exemple en tant que fichier zip et l'extraire.

Accédez au répertoire qui contient l'exemple de code :

cd java-docs-samples/appengine-java11/appengine-simple-jetty-main/

Installez la dépendance en local :
```
mvn install
```

Ajoutez le code suivant au fichier pom.xml :

Dépendance appengine-simple-jetty-main :

<dependency>
  <groupId>com.example.appengine</groupId>
  <artifactId>simple-jetty-main</artifactId>
  <version>1</version>
  <scope>provided</scope>
</dependency>

Plug-in maven-dependency :

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-dependency-plugin</artifactId>
  <version>3.6.1</version>
  <executions>
    <execution>
      <id>copy</id>
      <phase>prepare-package</phase>
      <goals>
        <goal>copy-dependencies</goal>
      </goals>
      <configuration>
        <outputDirectory>
          ${project.build.directory}/appengine-staging
        </outputDirectory>
      </configuration>
    </execution>
  </executions>
</plugin>

App Engine déploie les fichiers situés dans le répertoire ${build.directory}/appengine-staging. En ajoutant le plug-in maven-dependency à votre compilation, App Engine installe les dépendances spécifiées dans le dossier approprié.

Créez un élément entrypoint dans votre fichier app.yaml pour appeler l'objet appengine-simple-jetty-main et transmettre votre fichier WAR en tant qu'argument. La version de WAR doit être identique à la version indiquée dans votre fichier pom.xml :

runtime: java
env: flex
runtime_config:
  operating_system: ubuntu18
  runtime_version: 11
entrypoint: 'java -cp "*" com.example.appengine.jetty.Main helloworld-1.war'
handlers:
- url: /.*
  script: this field is required, but ignored

manual_scaling:
  instances: 1

Pour exécuter votre application localement, procédez comme suit :
1. Empaqueter votre application :
```
mvn clean package
```
2. Démarrez le serveur avec votre fichier WAR en tant qu'argument.
  
  Par exemple, vous pouvez démarrer le serveur dans l'exemple helloworld-war en exécutant la commande suivante à partir du dossier java-docs-samples/appengine-java11/appengine-simple-jetty-main/ :
```
mvn exec:java -Dexec.args="../flexible/java-11/helloworld-war/target/helloworld-1.war"
```
3. Dans votre navigateur Web, saisissez l'adresse suivante :
  
  http://localhost:8080
Pour déployer votre application à l'aide du plug-in Maven, procédez comme suit :
```
mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID
```
Remplacez PROJECT_ID par l'ID de votre projet Google Cloud. Si votre ID de projet est déjà inclus dans le fichier pom.xml, vous n'avez pas besoin d'inclure la propriété -Dapp.deploy.projectId dans la commande que vous exécutez.