Est-il possible avec Spring Boot pour servir des pages Jsp avec un POT de l'emballage

Je suis familier avec le Printemps de Démarrage JSP exemple d'application

Cependant cet exemple utilise la WAR emballage. Est-il possible de faire la même chose avec <packaging>JAR</packaging>?

Mon objectif est de mettre JSPs sous src/main/resources/jsp de simplifier la structure de mon application.

La raison pour laquelle nous mettre des pages Jsp dans WEB-INF est qu'il est protégé. Déplaçant signifie que vous serez en mesure d'accéder à la page JSP, code brut à l'aide d'un navigateur. Est-ce mauvais d'un aspect de la sécurité. Cependant, je crois que vous pouvez le faire. Vous devez configurer votre application ViewResolver (C'est un Printemps de la classe) pour lire vos fichiers à partir de votre /ressources/jsp dossier au lieu de partir du WEB-INF.

OriginalL'auteur checketts | 2014-01-20

20

@Andy Wilkinson dit, il y a des limites liées à la JSP. Veuillez package de votre application comme war et exécuter en tant que jar. Ceci est documenté au printemps site.

Avec Tomcat cela devrait fonctionner si vous utilisez la guerre de l'emballage, c'est à dire un fichier exécutable va à la guerre (...). Un exécutable jar ne fonctionnera pas à cause d'un fichier codé en dur modèle dans Tomcat.
- 27.3.5 JSP limitations
- jsp échantillon
Obsolète, vieux répondre

Oui, c'est possible avec Spring Boot.

Prendre regardez cet exemple: https://github.com/mariuszs/spring-boot-web-jsp-example.

Pour ce faire, utilisez spring-boot-maven-plugin ou gradle équivalent.

Avec ce plugin jar exécutable et peut servir des fichiers JSP.
```
$ mvn package
$ java -jar target/mymodule-0.0.1-SNAPSHOT.jar 
```
ou tout simplement
```
$ mvn spring-boot:run
```
Lorsque votre application est disponible sous forme d'un fichier JAR exécutable, il y a quelques limitations avec les Jsp être au courant: github.com/spring-projects/spring-boot/tree/master/...
href="http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-jsp-limitations" >docs.printemps.io/spring-boot/docs/current/reference/htmlsingle/...
ne fonctionne pas. cet exemple ne fonctionne pas. toutes les pages 404
Ok, j'ai donc un fichier exécutable fichier war de travail maintenant. Si vous utilisez le printemps de démarrage démarreur parent, juste faire de l'emballage de type war et aussi référence spring boot maven plugin avec configuration -> fichier exécutable mis à true
Je l'ai fait: struts2 + tuiles + jsp + tomcat intégré + docker m'a fallu 2 jours, mais je l'ai fait.

OriginalL'auteur MariuszS
5

Avec Tomcat il est aussi possible de mettre le contenu de votre WEB-INF/jsp à /src/main/resources/META-INF/resources (à l'aide de Maven par exemple). META-INF/ressources est en fait traitée comme votre traditionnel webapps dossier.

Pour plus de détails voir: http://hillert.blogspot.com/2016/03/spring-boot-with-jsp-in-executable-jar.html

Exemple de code: https://github.com/ghillert/spring-boot-jsp-demo

Votre lien vers GitHub n'est pas disponible
Ni lien de travail

OriginalL'auteur Gunnar Hillert
4

Votre meilleur pari est de changer le type d'emballage dans la guerre, et elle devrait fonctionner sans modification.

Comme mentionné dans les commentaires ci-dessus, il y a quelques limitations:

http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-developing-web-applications.html#boot-features-jsp-limitations

Ce n'est pas une solution, la question se rapporte à POT n'est pas la GUERRE

OriginalL'auteur aliwister
2

27.3.5 JSP limitations

Lors de l'exécution d'un Ressort de Démarrage de l'application qui utilise un intégré à conteneur de servlet (et est emballé comme un exécutable archive), il y a certaines limites dans la prise en charge de JSP.

Avec Tomcat cela devrait fonctionner si vous utilisez la guerre de l'emballage, c'est à dire un fichier exécutable guerre, et également d'être déployée à un conteneur standard (non limité à, mais y compris Tomcat).

Un exécutable jar ne fonctionnera pas à cause d'un fichier codé en dur modèle dans Tomcat.

Avec ponton cela devrait fonctionner si vous utilisez la guerre de l'emballage, c'est à dire un fichier exécutable guerre, et sera également déployable pour tout conteneur standard.

Ressac ne prend pas en charge les Jsp.

La création d'un message d'erreur personnalisé.page jsp ne pas surcharger la vue par défaut pour la gestion des erreurs, pages d'erreur personnalisées doivent être utilisés à la place.

OriginalL'auteur RBuser2769569

Je suis en utilisant JSP avec succès sur Printemps de Démarrage Application avec pot emballage, de mettre mes pages JSP sur src/main/webapp/WEB-INF/JSP répertoire et la configuration de mon Application comme ci-dessous

@Bean
public InternalResourceViewResolver viewResolver() {
    InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
    viewResolver.setViewClass(JstlView.class);
    viewResolver.setPrefix("/WEB-INF/JSP/");
    viewResolver.setSuffix(".jsp");
    return viewResolver;
}

Mon Contrôleur est:

@Controller
public class HelloController {

    @RequestMapping(value = { "/", "/hello**" }, method = RequestMethod.GET)
    public ModelAndView welcomePage() {
        ModelAndView model = new ModelAndView();
        model.addObject("title", "Spring Security Example");
        model.addObject("message", "This is Hello World!");
        model.setViewName("hello");
        System.out.println("° ° ° ° welcomePage running. model = " + model);
        return model;
    }
    . . .

Et mon bonjour.jsp est

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@page session="true"%>
<html>
<body>
    <h1>Title : ${title}</h1>   
    <h1>${message}</h1>
    <h2>Options: 
        <a href="<c:url value="/hello" />" >Home</a> | 
        <a href="<c:url value="/admin" />" >Administration</a> | 
        <a href="<c:url value="/super" />" >Super user</a>
        <c:if test="${pageContext.request.userPrincipal.name != null}"> |
            <a href="<c:url value="/logout" />" >Logout</a> 
        </c:if>
    </h2>   
</body>
</html>

Mon pom.xml fichier est

<groupId>br.com.joao-parana</groupId>
<artifactId>my-spring-boot-app</artifactId>
<packaging>jar</packaging>
<version>1.0</version>
<name>my-spring-boot-app Maven Webapp</name>
<url>http://maven.apache.org</url>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.4.RELEASE</version>
</parent>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
. . . 
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
<build>
<finalName>my-spring-boot-app</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

J'espère que cela aide quelqu'un !

comment êtes-vous l'exécution de votre application? Pouvez-vous réussi à le faire fonctionner avec java -jar your_app.jar? Peut-être que le WEB-INF répertoire est manquant dans le fichier jar exécutable? Vous pouvez toujours exécuter avec succès à l'aide de mvn spring:boot ou de l'exécution de l'application principale directement. Mais je suis intéressé de savoir si vous pouvez l'exécuter en tant que fichier jar exécutable avec la ci-dessus.
cela ne fonctionne pas si c'est jar emballé (et qui a été le principal sujet abordé ici)

OriginalL'auteur João Paraná

1

Printemps de Démarrage est très bonne avec JSP et il n'est pas facile aussi simplement vous avez besoin ci-dessous la configuration

1 - tomcat-embad-jasper dépendance
```
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>
```
2 - Ajouter en dessous de la configuration de l'application.propriétés
```
spring.mvc.view.prefix: /
spring.mvc.view.suffix: .jsp
```
Qui ont encore un doute alors check it out ci-dessous le lien

Printemps de Démarrage et JSP intégration

OriginalL'auteur jeet singh parmar

Si, pour quelque raison que ce soit, vous ne pouvez pas faire face à une guerre de l'emballage, il y a un hack. Crédit complet à cette mec pour le faire pour une ancienne version de spring-boot.

Une façon de le faire est de personnaliser tomcat et ajouter BOOT-INF/classes de tomcat ResourceSet. Dans tomcat, toutes les ressources numérisées sont mis dans quelque chose appelé un ResourceSet. Par exemple, le META-INF/ressources de l'application jar paquet dans la servlet 3.0 spécification est numérisé et mis dans le ResourceSet.

Maintenant, nous devons trouver un moyen d'ajouter de la BOTTE-INF/classes répertoire de la graisse pot aux ResourceSet. Nous pouvons le faire par le biais de l'interface LifecycleListener de tomcat, dans le Lifecycle.CONFIGURE_START_EVENT cas, obtenir le BOOT-INF/classes URL, puis ajoutez cette URL à la WebResourceSet. Un exemple complet est ici, mais vous pouvez le faire comme ceci:

import org.apache.catalina.Context;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@ConditionalOnProperty(name = "tomcat.staticResourceCustomizer.enabled", matchIfMissing = true)
public class TomcatConfiguration {
@Bean
public WebServerFactoryCustomizer<WebServerFactory> staticResourceCustomizer() {
return new WebServerFactoryCustomizer<WebServerFactory>() {
@Override
public void customize(WebServerFactory factory) {
if (factory instanceof TomcatServletWebServerFactory) {
((TomcatServletWebServerFactory) factory)
.addContextCustomizers(new org.springframework.boot.web.embedded.tomcat.TomcatContextCustomizer() {
@Override
public void customize(Context context) {
context.addLifecycleListener(new StaticResourceConfigurer(context));
}
});
}
}
};
}
}

Et ensuite utiliser le LifecycleListener comme suit:

import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import org.apache.catalina.Context;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.WebResourceRoot.ResourceSetType;
import org.springframework.util.ResourceUtils;
public class StaticResourceConfigurer implements LifecycleListener {
private final Context context;
StaticResourceConfigurer(Context context) {
this.context = context;
}
@Override
public void lifecycleEvent(LifecycleEvent event) {
if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
URL location = this.getClass().getProtectionDomain().getCodeSource().getLocation();
if (ResourceUtils.isFileURL(location)) {
//when run as exploded directory
String rootFile = location.getFile();
if (rootFile.endsWith("/BOOT-INF/classes/")) {
rootFile = rootFile.substring(0, rootFile.length() - "/BOOT-INF/classes/".length() + 1);
}
if (!new File(rootFile, "META-INF" + File.separator + "resources").isDirectory()) {
return;
}
try {
location = new File(rootFile).toURI().toURL();
} catch (MalformedURLException e) {
throw new IllegalStateException("Can not add tomcat resources", e);
}
}
String locationStr = location.toString();
if (locationStr.endsWith("/BOOT-INF/classes!/")) {
//when run as fat jar
locationStr = locationStr.substring(0, locationStr.length() - "/BOOT-INF/classes!/".length() + 1);
try {
location = new URL(locationStr);
} catch (MalformedURLException e) {
throw new IllegalStateException("Can not add tomcat resources", e);
}
}
this.context.getResources().createWebResourceSet(ResourceSetType.RESOURCE_JAR, "/", location,
"/META-INF/resources");
}
}
}

OriginalL'auteur code4kix

Salut, je figer comment copier des jsp de pot tomcat intégré dossier

package com.demosoft.stlb.loadbalancer;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.context.ServletContextAware;
import javax.annotation.PostConstruct;
import javax.servlet.ServletContext;
import java.io.*;
import java.net.MalformedURLException;
import java.util.Enumeration;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
@Component
public class JarFileResourcesExtractor implements ServletContextAware {
private String resourcePathPattern = "WEB-INF/**";
private String resourcePathPrefix = "WEB-INF/";
private String destination = "/WEB-INF/";
private ServletContext servletContext;
private AntPathMatcher pathMatcher = new AntPathMatcher();
/**
* Extracts the resource files found in the specified jar file into the destination path
*
* @throws IOException           If an IO error occurs when reading the jar file
* @throws FileNotFoundException If the jar file cannot be found
*/
@PostConstruct
public void extractFiles() throws IOException {
try {
JarFile jarFile = (JarFile) getClass().getProtectionDomain().getCodeSource().getLocation().getContent();
Enumeration<JarEntry> entries = jarFile.entries();
System.out.println("Tomcat destination : " + servletContext.getRealPath(destination));
while (entries.hasMoreElements()) {
processJarEntry(jarFile, entries);
}
} catch (MalformedURLException e) {
throw new FileNotFoundException("Cannot find jar file in libs: ");
} catch (IOException e) {
throw new IOException("IOException while moving resources.", e);
}
}
private void processJarEntry(JarFile jarFile, Enumeration<JarEntry> entries) throws IOException {
JarEntry entry = entries.nextElement();
if (pathMatcher.match(resourcePathPattern, entry.getName())) {
String fileName = getFileName(entry);
if (checkFileName(fileName)) return;
String sourcePath = getSourcePath(entry, fileName);
if (checkSourcePath(sourcePath)) return;
copyAndClose(jarFile.getInputStream(entry), getOutputStream(fileName, sourcePath));
}
}
private FileOutputStream getOutputStream(String fileName, String sourcePath) throws IOException {
File destinationFolder = new File(servletContext.getRealPath(destination)+sourcePath);
destinationFolder.mkdirs();
File materializedFile = new File(destinationFolder, fileName);
materializedFile.createNewFile();
return new FileOutputStream(materializedFile);
}
private boolean checkSourcePath(String sourcePath) {
return sourcePath.startsWith(".idea");
}
private String getSourcePath(JarEntry entry, String fileName) {
String sourcePath = entry.getName().replaceFirst(fileName, "");
sourcePath = sourcePath.replaceFirst(resourcePathPrefix, "").trim();
return sourcePath;
}
private boolean checkFileName(String fileName) {
return fileName.trim().equals("");
}
private String getFileName(JarEntry entry) {
return entry.getName().replaceFirst(".*\\/", "");
}
@Override
public void setServletContext(ServletContext servletContext) {
this.servletContext = servletContext;
}
public static int IO_BUFFER_SIZE = 8192;
private static void copyAndClose(InputStream in, OutputStream out) throws IOException {
try {
byte[] b = new byte[IO_BUFFER_SIZE];
int read;
while ((read = in.read(b)) != -1) {
out.write(b, 0, read);
}
} finally {
in.close();
out.close();
}
}
}

Bienvenue à Débordement de Pile! Alors que vous pourriez avoir résolu ce le problème de l'utilisateur, le code-seulement les réponses ne sont pas très utiles pour les utilisateurs qui viennent à cette question dans l'avenir. Merci de modifier votre réponse pour expliquer pourquoi votre code résout le problème d'origine.

OriginalL'auteur Andrey Korkoshko

Vous devez vous connecter pour publier un commentaire.