Empacotar novamente um arquivo WAR em um arquivo JAR

Este documento descreve como reempacotar um aplicativo Java 8 como um arquivo JAR para ser executado nos ambientes de execução do Java 11/17.

Seu aplicativo precisa ter uma classe Main que inicie um servidor da Web que responda às solicitações HTTP na porta especificada pela variável de ambiente PORT, normalmente 8081.

Exemplo:

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();
  }
}

Exemplo de migração do WAR

As instruções a seguir demonstram como empacotar novamente um aplicativo hello-world Java 8 do App Engine como um JAR a ser executado no ambiente de execução do Java 11/17.

A migração usa o artefato appengine-simple-jetty-main. Isso fornece uma classe Main com um servidor da Web Jetty simples que carrega um arquivo WAR e empacota seu aplicativo em um arquivo JAR executável:

  1. Clone o artefato do servidor incorporado do Jetty na sua máquina local:

    git clone https://github.com/GoogleCloudPlatform/java-docs-samples
    

    Também é possível fazer o download do exemplo como um arquivo zip e extraí-lo.

  2. Acesse o diretório que contém o código de amostra:

    cd java-docs-samples/appengine-java11/appengine-simple-jetty-main/
    
  3. Instale a dependência localmente:

    mvn install
    
  4. Adicione o seguinte código ao arquivo pom.xml:

    • Dependência 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>
      O App Engine implanta os arquivos localizados no diretório ${build.directory}/appengine-staging. Ao adicionar o plug-in maven-dependency à build, o App Engine instala as dependências especificadas na pasta correta.
  5. Crie um elemento entrypoint no arquivo app.yaml para chamar o objeto appengine-simple-jetty-main e insira o arquivo WAR como um argumento. A versão WAR precisa ser igual à versão listada no arquivo 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
  6. Para executar seu aplicativo localmente:

    1. Empacote seu aplicativo:

      mvn clean package
      
    2. Inicie o servidor com o arquivo WAR como um argumento.

      Por exemplo, você pode iniciar o servidor no helloworld-war de exemplo executando o seguinte comando da sua pasta java-docs-samples/appengine-java11/appengine-simple-jetty-main/:

      mvn exec:java -Dexec.args="../flexible/java-11/helloworld-war/target/helloworld-1.war"
      
    3. No navegador da Web, digite este endereço:

      http://localhost:8080

  7. Siga estas instruções para implantar o aplicativo usando o plug-in Maven:

    mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud. Se o arquivo pom.xmlespecificar o ID do projeto, não será necessário incluir a propriedade -Dapp.deploy.projectId no comando executado.