Come gestire il contenuto statico in Spring MVC?

Sto sviluppando una webapp usando Spring MVC 3 e ho DispatcherServletcatturato tutte le richieste in questo modo (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>

Ora funziona come pubblicizzato, tuttavia come posso gestire il contenuto statico? In precedenza, prima di utilizzare gli URL RESTful, avrei preso tutti * .html per esempio e li avrei inviati a DispatcherServlet, ma ora è un gioco con la palla diverso.

Ho una cartella / static / che include / styles /, / js /, / images / etc e vorrei escludere / static / * da DispatcherServlet.

Ora potrei far funzionare le risorse statiche quando ho fatto questo:

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

Ma voglio che abbia dei bei URL (il punto di me che utilizzo Spring MVC 3) non che la pagina di destinazione sia www.domain.com/app/

Inoltre, non voglio una soluzione accoppiata a Tomcat o ad altri container servlet, e poiché si tratta di un traffico (relativamente) basso, non ho bisogno di un server web (come apache httpd) davanti.

C'è una soluzione pulita a questo?

Dato che ho dedicato molto tempo a questo problema, ho pensato di condividere la mia soluzione. Dalla primavera 3.0.4, esiste un parametro di configurazione che viene chiamato <mvc:resources/>(ulteriori informazioni sul sito Web della documentazione di riferimento ) che può essere utilizzato per servire risorse statiche mentre si utilizza ancora DispatchServlet sulla radice del proprio sito.

Per usarlo, usa una struttura di directory simile alla seguente:

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

Il contenuto dei file dovrebbe essere simile a:

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

Spero che questo ti aiuti :-)

Questo problema è stato risolto nella primavera 3.0.4.RILEASE in cui è possibile utilizzare l' <mvc:resources mapping="..." location="..."/> elemento di configurazione nel file di configurazione di Spring Dispatcher.

Controlla la documentazione di primavera

In Spring 3.0.x aggiungi quanto segue al tuo servlet-config.xml (il file che è configurato in web.xml come contextConfigLocation. Devi aggiungere anche lo spazio dei nomi mvc ma basta google per questo se non sai come !;)

Per me va bene

<mvc:default-servlet-handler/>

Saluti

Ayub Malik

Se capisco correttamente il tuo problema, penso di aver trovato una soluzione al tuo problema:

Ho avuto lo stesso problema in cui è stato mostrato l'output non elaborato senza stili CSS, javascript o file jquery trovati.

Ho appena aggiunto i mapping al servlet "predefinito". Quanto segue è stato aggiunto al file 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>

Questo dovrebbe filtrare le richieste di file javascript e css dall'oggetto DispatcherRequest.

Ancora una volta, non sono sicuro se questo è ciò che stai cercando, ma ha funzionato per me. Penso che "default" sia il nome del servlet predefinito all'interno di JBoss. Non sono sicuro di cosa si tratti per altri server.

C'è un altro post di overflow dello stack che ha una soluzione eccellente .

Non sembra essere specifico per Tomcat, è semplice e funziona alla grande. Ho provato un paio di soluzioni in questo post con Spring mvc 3.1 ma poi ho avuto problemi a pubblicare il mio contenuto dinamico.

In breve, dice aggiungere una mappatura servlet come questa:

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

Ho trovato un modo per aggirarlo usando il filtro urlrewrite di tuckey. Sentiti libero di dare una risposta migliore se ne hai una!

In 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>

In 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>    

Ciò significa che qualsiasi uri con un '.' in esso (come style.css per esempio) non verrà riscritto.

Ho appena affrontato questo problema in Spring MVC 3.0 e inizialmente ho scelto l'opzione UrlRewriteFilter. Tuttavia non ero contento di questa soluzione in quanto "non mi sentivo bene" (non sono il solo - vedi il link sopra ai forum di primavera dove la parola "hack" appare alcune volte).

Quindi ho trovato una soluzione simile a "Unknown (Google)" sopra, ma ho preso in prestito l'idea di ricevere tutto il contenuto statico da / static / (preso dalla versione Spring Roo dell'app Pet Store). Il servlet "predefinito" non ha funzionato per me, ma il ResourceServlet di Spring Webflow ha funzionato (anche preso dall'app generata da 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>

L'unica modifica che ho apportato ai JSP è stata l'aggiunta del percorso / static / agli URL per CSS, JS e immagini. Ad esempio "$ {pageContext.request.contextPath} /static/css/screen.css".

per gli utenti Maven la dipendenza per "org.springframework.js.resource.ResourceServlet" è:

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

La mia esperienza con questo problema è la seguente. La maggior parte delle pagine Web e dei libri relativi a Spring sembrano suggerire che la sintassi più appropriata sia la seguente.

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

La sintassi sopra suggerisce che è possibile posizionare le risorse statiche (CSS, JavaScript, immagini) in una cartella denominata "risorse" nella radice dell'applicazione, ad esempio / webapp / resources /.

Tuttavia, nella mia esperienza (sto usando Eclipse e il plugin Tomcat), l'unico approccio che funziona è se inserisci la cartella delle risorse all'interno di WEB_INF (o META-INF). Quindi, la sintassi che raccomando è la seguente.

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

Nel tuo JSP (o simile), fai riferimento alla risorsa come segue.

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

Inutile dire che l'intera domanda è nata solo perché volevo che il mio servlet del dispatcher Spring (front controller) intercettasse tutto, tutto dinamico, cioè. Quindi ho il seguente nel mio 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>

Infine, dal momento che sto usando le migliori pratiche attuali, ho quanto segue nel mio servlet xml del controller frontale (vedi sopra).

<mvc:annotation-driven/>

E ho quanto segue nella mia effettiva implementazione del controller, per assicurarmi di avere un metodo predefinito per gestire tutte le richieste in arrivo.

@RequestMapping("/")

Spero che aiuti.

Ho avuto lo stesso problema e ho trovato la risposta di Joris molto utile. Ma devo anche aggiungere

<mvc:annotation-driven /> 

al file di configurazione servlet. Senza tale mappatura delle risorse non funzionerà e tutti i gestori smetteranno di funzionare. Spero che questo possa aiutare qualcuno.

URLRewrite è una specie di "hack" se si desidera chiamarlo così. Ciò che si riduce è che stai reinventando la ruota; in quanto esistono già soluzioni. Un'altra cosa da ricordare è Http Server = contenuto statico e server app = contenuto dinamico (ecco come sono stati progettati). Delegando le responsabilità appropriate a ciascun server massimizzi l'efficienza ... ma oggi questo è probabilmente solo un problema in un ambiente critico per le prestazioni e qualcosa come Tomcat molto probabilmente funzionerebbe bene in entrambi i ruoli per la maggior parte del tempo; ma è comunque qualcosa da tenere a mente.

L'ho risolto in questo modo:

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

Funziona su Tomcat e ovviamente Jboss. Tuttavia alla fine ho deciso di utilizzare la soluzione fornita da Spring (come menzionato da rozky) che è molto più portatile.

Ho usato entrambi i modi che sono urlrewrite e annotazioni basate in Spring mvc 3.0.x e ho scoperto che l'approccio basato sulle annotazioni è più adatto che sia

<annotation-driven />

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

In caso di urlrewrite, devi definire un sacco di regole e qualche volta ottenere anche l'eccezione della classe non trovata per UrlRewriteFilter poiché già fornita la dipendenza per essa. Ho scoperto che sta accadendo a causa della presenza di dipendenza transitiva, quindi di nuovo un passo aumenterà e dovrà escludere quella dipendenza da pom.xml usando

<exclusion></exclusion> tags.

Quindi l'approccio basato sull'annotazione sarà un buon affare.

Dalla primavera 3, tutte le risorse devono essere mappate in modo diverso. È necessario utilizzare il tag per specificare la posizione delle risorse.

Esempio :

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

In questo modo, si sta indirizzando il servlet dispatcher a cercare nelle risorse della directory per cercare il contenuto statico.

Il mio modo di risolvere questo problema è posizionare tutte le tue azioni con un prefisso specifico come "web" o "servizio" e configurare che tutti gli URL con quel prefisso vengano intercettati da DispatcherServlet.

Ho appena aggiunto tre regole prima della regola predefinita di primavera (/ **) a urlrewritefilter di tuckey (urlrewrite.xml) per risolvere il problema

<?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>

So che ci sono alcune configurazioni per utilizzare i contenuti statici, ma la mia soluzione è che creo una cartella di applicazioni Web di massa all'interno di Tomcat. Questa "webapp di massa" offre solo tutti i contenuti statici senza le app. Questa è una soluzione semplice e indolore per servire contenuti statici sulla tua webapp primaverile.

Ad esempio, sto usando due cartelle webapp sul mio Tomcat.

1. springapp : è in esecuzione solo un'applicazione web di primavera senza contenuto statico come imgs, js o css. (dedicato alle app di primavera.)
2. risorse : serve solo i contenuti statici senza JSP, servlet o qualsiasi tipo di applicazione Web Java. (dedicato ai contenuti statici)

Se voglio usare javascript, aggiungo semplicemente l'URI per il mio file javascript.

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

Per le immagini statiche, sto usando lo stesso metodo.

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

Infine, ho inserito " vincolo di sicurezza " sul mio tomcat per bloccare l'accesso alla directory effettiva. Ho messo "nessuno" sul rotolo dell'utente in modo tale che la pagina generi "403 errore proibito" quando le persone hanno tentato di accedere al percorso dei contenuti statici.

Finora funziona molto bene per me. Ho anche notato che molti siti Web popolari come Amazon, Twitter e Facebook utilizzano URI diversi per pubblicare contenuti statici. Per scoprirlo, fai clic con il pulsante destro del mouse su qualsiasi contenuto statico e controlla il loro URI.

Questo ha fatto il vero lavoro nel mio caso

in 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>

...

Per la configurazione delle molle basata su Java è possibile utilizzare quanto segue

Utilizzo di ResourceHandlerRegistry che memorizza le registrazioni dei gestori di risorse per servire le risorse statiche.

Altre info @ WebMvcConfigurerAdapter che definisce i metodi di callback per personalizzare la configurazione basata su Java per Spring MVC abilitata tramite @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");

    }

Dopo aver incontrato e seguito lo stesso processo decisionale qui descritto, ho deciso di seguire la proposta ResourceServlet che funziona abbastanza bene.

Si noti che è possibile ottenere ulteriori informazioni su come utilizzare il flusso Web nel processo di compilazione di Maven qui: http://static.springsource.org/spring-webflow/docs/2.0.x/reference/html/ch01s05.html

Se si utilizza il repository centrale Maven standard, il manufatto è (in opposizione al pacchetto di molle di cui sopra):

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

Ciò può essere ottenuto in almeno tre modi.

Soluzioni :

• esporre l'html come file di risorse
• indica a JspServlet di gestire anche le richieste * .html
• scrivere il proprio servlet (o passare a un'altra richiesta servlet esistente su * .html).

Per esempi di codice completi su come raggiungere questo obiettivo, fai riferimento alla mia risposta in un altro post: Come mappare le richieste al file HTML in Spring MVC?

Il problema è con URLPattern

Modifica il pattern URL sulla mappatura del servlet da "/" a "/ *"

<?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>

e se si desidera utilizzare la configurazione basata su annotazioni, utilizzare il codice seguente

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

Inserisci i contenuti statici come css, js nel seguente percorso

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