Comment gérer le contenu statique dans Spring MVC?

Je développe une webapp à l'aide de Spring MVC 3 et ai la DispatcherServletcapture de toutes les demandes à '/' comme ça (web.xml):

  <servlet>
    <servlet-name>app</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>app</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

Maintenant, cela fonctionne comme annoncé, mais comment puis-je gérer le contenu statique? Auparavant, avant d'utiliser des URL RESTful, j'aurais intercepté tous les fichiers * .html par exemple et les aurais envoyés au DispatcherServlet, mais maintenant c'est un jeu de balle différent.

J'ai un dossier / static / qui inclut / styles /, / js /, / images / etc et je voudrais exclure / static / * du DispatcherServlet.

Maintenant, je pouvais faire fonctionner les ressources statiques quand je faisais ceci:

  <servlet-mapping>
    <servlet-name>app</servlet-name>
    <url-pattern>/app/</url-pattern>
  </servlet-mapping>

Mais je veux qu'il ait de belles URL (le point pour moi d'utiliser Spring MVC 3) pas la page de destination étant www.domain.com/app/

Je ne veux pas non plus de solution couplée à tomcat ou à tout autre conteneur de servlet, et comme il s'agit d'un trafic (relativement) faible, je n'ai pas besoin d'un serveur Web (comme apache httpd) en face.

Y a-t-il une solution propre à cela?

Depuis que j'ai passé beaucoup de temps sur cette question, j'ai pensé partager ma solution. Depuis le printemps 3.0.4, il existe un paramètre de configuration appelé <mvc:resources/>(plus d'informations à ce sujet sur le site Web de documentation de référence ) qui peut être utilisé pour servir des ressources statiques tout en utilisant le DispatchServlet à la racine de votre site.

Pour l'utiliser, utilisez une structure de répertoires qui ressemble à ceci:

src/
 springmvc/
  web/
   MyController.java
WebContent/
  resources/
   img/
    image.jpg
  WEB-INF/
    jsp/
      index.jsp
    web.xml
    springmvc-servlet.xml

Le contenu des fichiers doit ressembler à:

src / springmvc / web / HelloWorldController.java:

package springmvc.web;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloWorldController {

 @RequestMapping(value="/")
 public String index() {
  return "index";
 }
}

WebContent / WEB-INF / web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
         http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

 <servlet>
  <servlet-name>springmvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
 </servlet>

 <servlet-mapping>
  <servlet-name>springmvc</servlet-name>
  <url-pattern>/</url-pattern>
 </servlet-mapping>
</web-app>

WebContent / WEB-INF / springmvc-servlet.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://www.springframework.org/schema/mvc
 http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- not strictly necessary for this example, but still useful, see http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/mvc.html#mvc-ann-controller for more information -->
 <context:component-scan base-package="springmvc.web" />

    <!-- the mvc resources tag does the magic -->
 <mvc:resources mapping="/resources/**" location="/resources/" />

    <!-- also add the following beans to get rid of some exceptions -->
 <bean      class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
 <bean
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
 </bean>

    <!-- JSTL resolver -->
 <bean id="viewResolver"
  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="viewClass"
   value="org.springframework.web.servlet.view.JstlView" />
  <property name="prefix" value="/WEB-INF/jsp/" />
  <property name="suffix" value=".jsp" />
 </bean>

</beans>

WebContent / jsp / index.jsp:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<h1>Page with image</h1>
<!-- use c:url to get the correct absolute path -->
<img src="<c:url value="/resources/img/image.jpg" />" />

J'espère que cela t'aides :-)

Ce problème est résolu dans la version Spring 3.0.4.RELEASE où vous pouvez utiliser l' <mvc:resources mapping="..." location="..."/> élément de configuration dans votre fichier de configuration du répartiteur Spring.

Vérifier la documentation de Spring

Dans Spring 3.0.x, ajoutez ce qui suit à votre servlet-config.xml (le fichier configuré dans web.xml en tant que contextConfigLocation. Vous devez également ajouter l'espace de noms mvc mais juste google pour cela si vous ne savez pas comment !;)

Ça marche pour moi

<mvc:default-servlet-handler/>

Cordialement

Ayub Malik

Si je comprends bien votre problème, je pense avoir trouvé une solution à votre problème:

J'ai eu le même problème où la sortie brute était affichée sans styles css, javascripts ou fichiers jquery trouvés.

Je viens d'ajouter des mappages au servlet "par défaut". Les éléments suivants ont été ajoutés au fichier web.xml:

 <servlet-mapping>
  <servlet-name>default</servlet-name>
  <url-pattern>*.css</url-pattern>
 </servlet-mapping>

 <servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.js</url-pattern>
 </servlet-mapping>

Cela devrait filtrer les demandes de fichiers javascript et css de l'objet DispatcherRequest.

Encore une fois, je ne sais pas si c'est ce que vous recherchez, mais cela a fonctionné pour moi. Je pense que "par défaut" est le nom du servlet par défaut dans JBoss. Je ne sais pas trop ce que c'est pour les autres serveurs.

Il existe un autre poste de débordement de pile qui a une excellente solution .

Il ne semble pas être spécifique à Tomcat, est simple et fonctionne très bien. J'ai essayé quelques solutions dans ce post avec Spring MVC 3.1, mais j'ai eu des problèmes pour que mon contenu dynamique soit servi.

En bref, il dit d'ajouter un mappage de servlet comme celui-ci:

<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>/images/*</url-pattern>
</servlet-mapping>

J'ai trouvé un moyen de contourner cela en utilisant le filtre d'urlrewrite de tuckey. N'hésitez pas à donner une meilleure réponse si vous en avez une!

Dans web.xml:

<filter>
    <filter-name>UrlRewriteFilter</filter-name>
    <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
</filter>

<filter-mapping>
    <filter-name>UrlRewriteFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

  <servlet>
    <servlet-name>app</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>app</servlet-name>
    <url-pattern>/app/*</url-pattern>
  </servlet-mapping>

Dans urlrewrite.xml:

<urlrewrite default-match-type="wildcard">
<rule>
    <from>/</from>
    <to>/app/</to>
</rule>
<rule match-type="regex">
    <from>^([^\.]+)$</from>
    <to>/app/$1</to>
</rule>
<outbound-rule>
    <from>/app/**</from>
    <to>/$1</to>
</outbound-rule>    

Cela signifie que tout uri avec un '.' dedans (comme style.css par exemple) ne sera pas réécrit.

Je viens de me débattre avec ce problème dans Spring MVC 3.0 et j'ai d'abord choisi l'option UrlRewriteFilter. Cependant, je n'étais pas satisfait de cette solution car elle "ne se sentait pas bien" (je ne suis pas le seul - voir le lien ci-dessus vers les forums de printemps où le mot "hack" apparaît plusieurs fois).

J'ai donc trouvé une solution similaire à "Inconnu (Google)" ci-dessus, mais j'ai emprunté l'idée d'avoir tout le contenu statique servi à partir de / statique / (tiré de la version Spring Roo de l'application Pet Store). Le servlet "par défaut" n'a pas fonctionné pour moi, mais le Spring Webflow ResourceServlet l'a fait (également tiré de l'application générée par Spring Roo).

Web.xml:

<servlet>
    <servlet-name>mainDispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>2</load-on-startup>
</servlet>

<servlet>
    <servlet-name>Resource Servlet</servlet-name>
    <servlet-class>org.springframework.js.resource.ResourceServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>mainDispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

<servlet-mapping>
    <servlet-name>Resource Servlet</servlet-name>
    <url-pattern>/static/*</url-pattern>
</servlet-mapping>

La seule modification que j'ai apportée aux JSP a été d'ajouter le chemin / statique / aux URL pour CSS, JS et les images. Par exemple, "$ {pageContext.request.contextPath} /static/css/screen.css".

pour les utilisateurs de Maven, la dépendance pour "org.springframework.js.resource.ResourceServlet" est:

<dependency>
    <groupId>org.springframework.webflow</groupId>
    <artifactId>org.springframework.js</artifactId>
    <version>2.0.8.RELEASE</version>
</dependency>

Ma propre expérience avec ce problème est la suivante. La plupart des pages Web et des livres liés à Spring semblent suggérer que la syntaxe la plus appropriée est la suivante.

    <mvc:resources mapping="/resources/**" location="/resources/" />

La syntaxe ci-dessus suggère que vous pouvez placer vos ressources statiques (CSS, JavaScript, images) dans un dossier nommé "ressources" à la racine de votre application, c'est-à-dire / webapp / resources /.

Cependant, d'après mon expérience (j'utilise Eclipse et le plugin Tomcat), la seule approche qui fonctionne est si vous placez votre dossier de ressources dans WEB_INF (ou META-INF). Ainsi, la syntaxe que je recommande est la suivante.

    <mvc:resources mapping="/resources/**" location="/WEB-INF/resources/" />

Dans votre JSP (ou similaire), référencez la ressource comme suit.

<script type="text/javascript"
        src="resources/my-javascript.js">
</script>

Inutile de mentionner que toute la question s'est posée uniquement parce que je voulais que mon servlet répartiteur Spring (contrôleur frontal) intercepte tout, tout dynamique, c'est-à-dire. J'ai donc ce qui suit dans mon web.xml.

<servlet>
    <servlet-name>front-controller</servlet-name>
    <servlet-class>
                org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <load-on-startup>1</load-on-startup>
    <!-- spring automatically discovers /WEB-INF/<servlet-name>-servlet.xml -->
</servlet>

<servlet-mapping>
    <servlet-name>front-controller</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

Enfin, puisque j'utilise les meilleures pratiques actuelles, j'ai ce qui suit dans mon servlet de contrôleur frontal xml (voir ci-dessus).

<mvc:annotation-driven/>

Et j'ai les éléments suivants dans mon implémentation de contrôleur réelle, pour m'assurer d'avoir une méthode par défaut pour gérer toutes les demandes entrantes.

@RequestMapping("/")

J'espère que ça aide.

J'ai eu le même problème et j'ai trouvé la réponse de Joris très utile. Mais en plus je dois ajouter

<mvc:annotation-driven /> 

dans le fichier de configuration du servlet. Sans cela, le mappage des ressources ne fonctionnera pas et tous les gestionnaires cesseront de fonctionner. J'espère que cela aidera quelqu'un.

L'URLRewrite est une sorte de "hack" si vous voulez l'appeler ainsi. Cela revient à dire que vous réinventez la roue; car il existe déjà des solutions. Une autre chose à retenir est le serveur Http = contenu statique et le serveur d'applications = contenu dynamique (c'est ainsi qu'ils ont été conçus). En déléguant les responsabilités appropriées à chaque serveur, vous maximisez l'efficacité ... mais de nos jours, cela n'est probablement qu'une préoccupation dans un environnement à performances critiques et quelque chose comme Tomcat fonctionnerait très bien dans les deux rôles la plupart du temps; mais c'est quand même quelque chose à garder à l'esprit.

Je l'ai résolu de cette façon:

<servlet-mapping>
    <servlet-name>Spring MVC Dispatcher Servlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.png</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.gif</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.css</url-pattern>
</servlet-mapping>

Cela fonctionne sur Tomcat et bien sûr Jboss. Cependant, j'ai finalement décidé d'utiliser la solution que Spring propose (comme mentionné par rozky) qui est beaucoup plus portable.

J'ai utilisé les deux façons qui sont basées sur l'urlrewrite et les annotations dans Spring mvc 3.0.x et j'ai trouvé que l'approche basée sur les annotations est la plus appropriée qui est

<annotation-driven />

<resources mapping="/resources/**" location="/resources/" />

En cas d'urlrewrite, vous devez définir un bon nombre de règles et obtenir également une exception de classe non trouvée pour UrlRewriteFilter, comme déjà fourni la dépendance. J'ai trouvé que cela se produisait en raison de la présence d'une dépendance transitive, donc encore une étape sera augmentée et devra exclure cette dépendance de pom.xml en utilisant

<exclusion></exclusion> tags.

L'approche basée sur les annotations sera donc la bonne affaire.

À partir du printemps 3, toutes les ressources doivent être cartographiées de manière différente. Vous devez utiliser la balise pour spécifier l'emplacement des ressources.

Exemple :

<mvc:resources mapping="/resources/**" location="/resources/" />

De cette façon, vous demandez au servlet du répartiteur de rechercher dans les ressources du répertoire pour rechercher le contenu statique.

Ma façon de résoudre ce problème consiste à placer toutes vos actions avec un préfixe spécifique comme "web" ou "service" et à configurer que toutes les URL avec ce préfixe seront interceptées par le DispatcherServlet.

J'ajoute juste trois règles avant la règle par défaut du printemps (/ **) à l'urlrewritefilter de tuckey (urlrewrite.xml) pour résoudre le problème

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE urlrewrite PUBLIC "-//tuckey.org//DTD UrlRewrite 3.0//EN" "http://tuckey.org/res/dtds/urlrewrite3.0.dtd">
    <urlrewrite default-match-type="wildcard">
     <rule>
      <from>/</from>
      <to>/app/welcome</to>
     </rule>
     <rule>
      <from>/scripts/**</from>
      <to>/scripts/$1</to>
     </rule>
     <rule>
      <from>/styles/**</from>
      <to>/styles/$1</to>
     </rule>
     <rule>
      <from>/images/**</from>
      <to>/images/$1</to>
     </rule>
     <rule>
      <from>/**</from>
      <to>/app/$1</to>
     </rule>
     <outbound-rule>
      <from>/app/**</from>
      <to>/$1</to>
     </outbound-rule> 
    </urlrewrite>

Je sais qu'il existe quelques configurations pour utiliser le contenu statique, mais ma solution est que je crée simplement un dossier d'applications Web en bloc dans votre tomcat. Cette "webapp en vrac" ne sert que tous les contenus statiques sans servir d'applications. Il s'agit d'une solution simple et sans douleur pour servir des contenus statiques à votre webapp réelle de printemps.

Par exemple, j'utilise deux dossiers webapp sur mon tomcat.

1. springapp : il exécute uniquement une application Web Spring sans contenu statique comme imgs, js ou css. (dédié aux applications de printemps.)
2. ressources : il ne sert que le contenu statique sans JSP, servlet ou toute sorte d'application web java. (dédié aux contenus statiques)

Si je veux utiliser javascript, j'ajoute simplement l'URI de mon fichier javascript.

EX> /resources/path/to/js/myjavascript.js

Pour les images statiques, j'utilise la même méthode.

EX> /resources/path/to/img/myimg.jpg

Enfin, je mets " la contrainte de sécurité " sur mon tomcat pour bloquer l'accès au répertoire réel. J'ai mis le rouleau d'utilisateur "personne" à la contrainte afin que la page génère "erreur interdite 403" lorsque les gens ont essayé d'accéder au chemin du contenu statique.

Jusqu'à présent, cela fonctionne très bien pour moi. J'ai également remarqué que de nombreux sites Web populaires comme Amazon, Twitter et Facebook utilisent différents URI pour diffuser des contenus statiques. Pour le savoir, faites un clic droit sur un contenu statique et vérifiez leur URI.

Cela a fait le vrai travail dans mon cas

dans web.xml:

...
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>/images/*</url-pattern>
    <url-pattern>/css/*</url-pattern>
    <url-pattern>/javascripts/*</url-pattern>
</servlet-mapping>


<servlet-mapping>
    <servlet-name>spring-mvc-dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

...

Pour une configuration de ressort basée sur java, vous pouvez utiliser les éléments suivants

Utilisation de ResourceHandlerRegistry qui stocke les enregistrements de gestionnaires de ressources pour servir des ressources statiques.

Plus d'informations @ WebMvcConfigurerAdapter qui définit les méthodes de rappel pour personnaliser la configuration Java pour Spring MVC activée via @EnableWebMvc.

@EnableWebMvc
@Configurable
@ComponentScan("package.to.scan")
public class WebConfigurer extends WebMvcConfigurerAdapter {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static_resource_path/*.jpg").addResourceLocations("server_destination_path");

    }

Après avoir rencontré et suivi le même processus de prise de décision décrit ici, j'ai décidé d'aller avec la proposition ResourceServlet qui fonctionne très bien.

Notez que vous obtenez plus d'informations sur la façon d'utiliser webflow dans votre processus de construction maven ici: http://static.springsource.org/spring-webflow/docs/2.0.x/reference/html/ch01s05.html

Si vous utilisez le référentiel central Maven standard, l'artefact est (à l'opposé du bundle source de sources mentionné ci-dessus):

<dependency>
    <groupId>org.springframework.webflow</groupId>
    <artifactId>spring-js</artifactId>
    <version>2.0.9.RELEASE</version>
</dependency> 

Cela peut être réalisé de trois manières au moins.

Solutions :

• exposer le html en tant que fichier de ressources
• demander au JspServlet de gérer également les requêtes * .html
• écrivez votre propre servlet (ou passez à une autre requête de servlet existante dans * .html).

Pour des exemples de code complets sur la façon d'y parvenir, veuillez vous reporter à ma réponse dans un autre article: Comment mapper les demandes au fichier HTML dans Spring MVC?

Le problème est avec URLPattern

Modifiez votre modèle d'URL sur le mappage de votre servlet de "/" à "/ *"

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<mvc:default-servlet-handler/>
</beans>

et si vous souhaitez utiliser une configuration basée sur des annotations, utilisez le code ci-dessous

@Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

Placer le contenu statique comme css, js dans le chemin suivant

resources 
        ->static
               ->css
               ->js
(or) 
resources 
        ->public
               ->css
               ->js