programar - pildorasinformaticas java excepciones

¿Cómo desplegar una aplicación web de chispa Java?

Question

Utilicé el framework web de spark para crear una aplicación web, pero no sé cómo implementar esta aplicación web. Lo siento si esto es muy básico, pero soy nuevo en el marco de chispa y no puedo encontrar ningún documento que me guíe sobre cómo implementar una aplicación web de chispa.

• Cómo desplegar una chispa webapp independiente
• Cómo construir una aplicación web de chispa (para guardar un archivo o un archivo de este tipo) y desplegar con un servidor web (embarcadero o Tomcat).

Answer 1

1) Clone este repositorio: https://github.com/simplesteph/ec2-masterclass-sampleapp

2) Navegue al directorio del proyecto pom.xml

3) mvn instalación limpia

4) ir a la carpeta de destino

5) java -jar ec2-masterclass-sample-app-1.0-jar-with-dependencies.jar

6) En el navegador, navegue a http: // localhost: 4567

Answer 2

Aquí encontrará información sobre la implementación: http://sparkjava.com/documentation.html#embedded-web-server

En primer lugar, configure las opciones de filtro para 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 clase de Application debe implementar la interfaz spark.servlet.SparkApplication y debe inicializar las rutas en el método init() .

Este se ve así (en Java SE 8 puedes usar Lambda Expression para enrutador):

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

La aplicación con esta configuración funciona bien para los servidores tomcat y glassfish .

Answer 3

Para el escenario independiente, puede usar Gradle (o Maven) para crear grasa (es decir, tiene todas las dependencias, incluido un servidor Jetty integrado), archivo jar ejecutable. Aquí hay un simple archivo build.gradle que hace precisamente eso:

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"
}

Cree su aplicación en la línea de comandos a través de la gradle build . Esto creará un archivo app.jar en su carpeta build/libs luego ejecute:

java -jar build/libs/app.jar

Si desea estar realmente actualizado :) entonces tiene que usar Docker para empaquetar su JRE y la aplicación jar, por lo que no depende de la pila de software instalada en el servidor. Para ello podemos utilizar un Dockerfile :

FROM java:8

ADD build/libs/app.jar /

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

Cree la imagen de la ventana acoplable y ejecútela, por ejemplo:

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

Por supuesto, si desea utilizar la imagen de Docker en un servidor web remoto, debe enviarla a Docker Hub o a un repositorio privado de la ventana acoplable y usar la función de docker pull para llevarla a su servidor, antes de ejecutarla.

Answer 4

Primero deberá crear un proyecto Java normal que pueda integrarse en un archivo .war (en Eclipse esto sería un Proyecto Web Dinámico)

La documentación de chispa en este enlace describe lo que debe agregarse al archivo web.xml de sus proyectos. http://sparkjava.com/documentation.html#other-webserver

El valor-parámetro que se indica en la documentación dentro del filtro debe apuntar a la clase en la que ha definido sus rutas.

Además, todo el código que estaba anteriormente en main () debe moverse a init ().

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

    });

Además, para poder implementarlo en JBoss, solo tenía que incluir las bibliotecas de chispas y no las bibliotecas de Jetty. Una vez hecho esto, deberías poder construir la guerra y desplegarla en tu servidor de la misma forma que lo harías con cualquier otro proyecto Java.