Come distribuire un'app web Java spark?

Question

Ho usato il framework web spark per creare una webapp, ma non so come distribuire questa webapp. Mi dispiace se questo è molto semplice, ma io sono nuovo di innescare quadro e non riesco a trovare alcun documento che mi guida come distribuire una webapp scintilla .:

• come distribuire un autonomo scintilla webapp
• Come creare una scintilla webapp (in un file war o un file di questo tipo) e distribuire con il server web (jetty o Tomcat).

Answer 1

È necessario prima creare un progetto Java regolare che può essere costruito in un file .war (in Eclipse questo sarebbe un progetto Web dinamico)

La documentazione scintilla a questo link descrive ciò che deve essere aggiunto al file web.xml del tuo progetto. http://sparkjava.com/documentation.html#other-webserver

il valore param elencato nella documentazione all'interno del filtro deve puntare alla classe in cui sono stati definiti i percorsi.

Inoltre, tutto il codice precedentemente in main() deve essere spostato su init().

@Override 
public void init() { 
    get(new Route("/test") { 
     @Override 
     public Object handle(Request request, Response response) { 
      return "response goes here; 
     } 

    }); 

Inoltre, in modo per me per distribuirlo a JBoss, ho dovuto includere solo le librerie d'accensione e non le librerie Jetty. Una volta che questo è stato fatto, dovresti essere in grado di costruire la guerra e distribuirla sul tuo server nello stesso modo in cui faresti qualsiasi altro progetto Java.

Answer 2

Qui trovate le informazioni su Deploy: http://sparkjava.com/documentation.html#embedded-web-server

Pugno di tutto, impostare le opzioni di filtro per web.xml config:

<web-app> 
    <!-- some options --> 
    <filter> 
    <filter-name>SparkFilter</filter-name> 
    <filter-class>spark.servlet.SparkFilter</filter-class> 
    <init-param> 
     <param-name>applicationClass</param-name> 
     <param-value>your.package.Application</param-value> 
    </init-param> 
    </filter> 

    <filter-mapping> 
    <filter-name>SparkFilter</filter-name> 
    <url-pattern>/*</url-pattern> 
    </filter-mapping> 
</web-app> 

Application classe deve implementare l'interfaccia spark.servlet.SparkApplication e hanno per inizializzare i percorsi in il metodo init().

Questo sembra come (in Java SE 8 è possibile utilizzare Lambda Expression per router.):

package your.package; 

import static spark.Spark.*; 

public class Application implements SparkApplication { 
    @Override 
    public void init() { 
     get("/", (request, response) -> "Hello World"); 

     get("/hello/:name", (request, response) -> { 
      return "Hello: " + request.params(":name"); 
     }); 
    } 
} 

App con questa configurazione funziona bene per Tomcat e GlassFish server.

Answer 3

Per lo scenario standalone, è possibile utilizzare semplicemente Gradle (o Maven) per creare il grasso (ovvero tutte le dipendenze incluso un server Jetty incorporato), il file jar eseguibile. Ecco un semplice file build.gradle che fa proprio questo:

apply plugin: 'java' 
apply plugin: 'application' 

// TODO Change this to your class with your main method 
mainClassName = "my.app.Main" 

defaultTasks 'run' 

repositories { 
    mavenCentral() 
} 

dependencies { 
    compile group: 'com.sparkjava', name: 'spark-core', version: '2.5.5' 
    // TODO add more dependencies here... 
} 

// Create a fat executable jar 
jar { 
    manifest { 
     attributes "Main-Class": "$mainClassName" 
    } 

    from { 
     configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } 
    } 

    archiveName "app.jar" 
} 

costruire l'applicazione si sulla riga di comando tramite gradle build. Questo creerà un file nella cartella app.jarbuild/libs poi basta eseguire:

java -jar build/libs/app.jar 

Se si vuole essere davvero aggiornati :) allora dovete usare Docker per confezionare il vostro JRE e vaso di applicazione, quindi non si è dipende dallo stack software installato sul server.Per fare questo possiamo usare un Dockerfile:

FROM java:8 

ADD build/libs/app.jar/

EXPOSE 4567 
ENTRYPOINT ["java", "-jar", "app.jar"] 

costruire l'immagine finestra mobile ed eseguirlo, ad esempio:

docker build -t myapp:v1 . 
docker run --rm --name myapp -p 4567:4567 myapp:v1 

Naturalmente, se si desidera utilizzare l'immagine Docker su un server web remoto, è è necessario spostarlo su Docker Hub o su un repository mobile privato e utilizzare docker pull per estrarlo sul server, prima di eseguirlo.