¿Cómo manejar el contenido estático en Spring MVC?

Estoy desarrollando una aplicación web usando Spring MVC 3 y tengo la DispatcherServletcaptura de todas las solicitudes a '/' así (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>

Ahora esto funciona como se anuncia, sin embargo, ¿cómo puedo manejar el contenido estático? Anteriormente, antes de usar URL RESTful, habría capturado todo * .html por ejemplo y lo había enviado al DispatcherServlet, pero ahora es un juego de pelota diferente.

Tengo una carpeta / static / que incluye / styles /, / js /, / images / etc y me gustaría excluir / static / * del DispatcherServlet.

Ahora podría hacer que los recursos estáticos funcionen cuando hice esto:

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

Pero quiero que tenga URLs agradables (el punto de mí usando Spring MVC 3) no que la página de destino sea www.domain.com/app/

Tampoco quiero una solución acoplada a tomcat o cualquier otro contenedor de servlet, y debido a que este es (relativamente) de poco tráfico, no necesito un servidor web (como apache httpd) enfrente.

¿Hay una solución limpia para esto?

Como pasé mucho tiempo en este tema, pensé en compartir mi solución. Desde la primavera 3.0.4, hay un parámetro de configuración que se llama <mvc:resources/>(más sobre eso en el sitio web de documentación de referencia ) que se puede utilizar para servir recursos estáticos mientras se sigue utilizando el DispatchServlet en la raíz de su sitio.

Para usar esto, use una estructura de directorio similar a la siguiente:

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

El contenido de los archivos debería verse así:

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

Espero que esto ayude :-)

Este problema se resuelve en spring 3.0.4.RELEASE, donde puede usar el <mvc:resources mapping="..." location="..."/> elemento de configuración en el archivo de configuración del despachador de spring.

Verifique la documentación de primavera

En Spring 3.0.x agregue lo siguiente a su servlet-config.xml (el archivo que está configurado en web.xml como contextConfigLocation. También debe agregar el espacio de nombres mvc pero solo google para eso si no sabe cómo !;)

Funciona para mi

<mvc:default-servlet-handler/>

Saludos

Ayub Malik

Si entiendo su problema correctamente, creo que he encontrado una solución a su problema:

Tuve el mismo problema donde se mostraba la salida sin procesar sin encontrar estilos CSS, javascripts o archivos jquery.

Acabo de agregar asignaciones al servlet "predeterminado". Lo siguiente se agregó al archivo 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>

Esto debería filtrar las solicitudes de archivos javascript y css del objeto DispatcherRequest.

De nuevo, no estoy seguro de si esto es lo que buscas, pero funcionó para mí. Creo que "predeterminado" es el nombre del servlet predeterminado dentro de JBoss. No estoy muy seguro de lo que es para otros servidores.

Hay otra publicación de desbordamiento de pila que tiene una excelente solución .

No parece ser específico de Tomcat, es simple y funciona muy bien. He probado un par de soluciones en esta publicación con spring mvc 3.1, pero luego tuve problemas para que se sirviera mi contenido dinámico.

En resumen, dice agregar una asignación de servlet como esta:

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

Encontré una forma de evitarlo usando el filtro urlrewrite de tuckey. ¡Siéntase libre de dar una mejor respuesta si tiene una!

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

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

Esto significa que cualquier uri con un '.' en él (como style.css por ejemplo) no se volverá a escribir.

Acabo de lidiar con este problema en Spring MVC 3.0 e inicialmente utilicé la opción UrlRewriteFilter. Sin embargo, no estaba contento con esta solución, ya que "no me sentía bien" (no soy el único, vea el enlace de arriba a los foros de Spring donde aparece la palabra "piratear" varias veces).

Así que se me ocurrió una solución similar a "Desconocido (Google)" anterior, pero tomé prestada la idea de que todo el contenido estático se sirviera desde / static / (tomado de la versión Spring Roo de la aplicación Pet Store). El servlet "predeterminado" no funcionó para mí pero sí el Spring Webflow ResourceServlet (también tomado de la aplicación generada por 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>

El único cambio que hice en JSP fue agregar la ruta / static / a las URL para CSS, JS e imágenes. Por ejemplo, "$ {pageContext.request.contextPath} /static/css/screen.css".

para los usuarios de Maven, la dependencia de "org.springframework.js.resource.ResourceServlet" es:

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

Mi propia experiencia con este problema es la siguiente. La mayoría de las páginas web y libros relacionados con Spring parecen sugerir que la sintaxis más adecuada es la siguiente.

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

La sintaxis anterior sugiere que puede colocar sus recursos estáticos (CSS, JavaScript, imágenes) en una carpeta llamada "recursos" en la raíz de su aplicación, es decir, / webapp / resources /.

Sin embargo, en mi experiencia (estoy usando Eclipse y el complemento Tomcat), el único enfoque que funciona es si coloca su carpeta de recursos dentro de WEB_INF (o META-INF). Entonces, la sintaxis que recomiendo es la siguiente.

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

En su JSP (o similar), haga referencia al recurso de la siguiente manera.

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

No hace falta mencionar que toda la pregunta solo surgió porque quería que mi servlet de despachador Spring (controlador frontal) interceptara todo, todo lo dinámico, eso es. Entonces tengo lo siguiente en mi 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>

Finalmente, como estoy usando las mejores prácticas actuales, tengo lo siguiente en mi controlador frontal servlet xml (ver arriba).

<mvc:annotation-driven/>

Y tengo lo siguiente en mi implementación de controlador real, para asegurarme de que tengo un método predeterminado para manejar todas las solicitudes entrantes.

@RequestMapping("/")

Espero que esto ayude.

Tuve el mismo problema y la respuesta de Joris me pareció muy útil. Pero además necesito agregar

<mvc:annotation-driven /> 

al archivo de configuración del servlet. Sin ese recurso, la asignación no funcionará y todos los controladores dejarán de funcionar. Espero que esto ayude a alguien.

El URLRewrite es una especie de "hack" si quieres llamarlo así. Todo se reduce a que estás reinventando la rueda; como ya existen soluciones existentes. Otra cosa para recordar es Http Server = Contenido estático y Servidor de aplicaciones = contenido dinámico (así es como fueron diseñados). Al delegar las responsabilidades apropiadas a cada servidor, maximiza la eficiencia ... pero hoy en día esto probablemente solo sea una preocupación en entornos críticos de rendimiento y algo como Tomcat probablemente funcionaría bien en ambos roles la mayor parte del tiempo; pero aun así es algo a tener en cuenta.

Lo resolví de esta manera:

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

Esto funciona en Tomcat y, por supuesto, Jboss. Sin embargo, al final decidí usar la solución que proporciona Spring (como mencionó rozky) que es mucho más portátil.

Utilicé ambas formas, que es urlrewrite y anotación basada en spring mvc 3.0.x, y descubrí que el enfoque basado en anotaciones es el más adecuado, es decir

<annotation-driven />

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

En caso de urlrewrite, debe definir muchas reglas y, en algún momento, también obtener una excepción de clase no encontrada para UrlRewriteFilter, ya que ya proporcionó la dependencia para ello. Descubrí que está sucediendo debido a la presencia de dependencia transitiva, por lo que nuevamente un paso aumentará y tendrá que excluir esa dependencia de pom.xml usando

<exclusion></exclusion> tags.

Por lo tanto, el enfoque basado en anotaciones será el buen negocio.

Desde la primavera 3, todos los recursos deben asignarse de una manera diferente. Debe usar la etiqueta para especificar la ubicación de los recursos.

Ejemplo:

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

Al hacer esto, está indicando al servlet del despachador que busque en los recursos del directorio para buscar el contenido estático.

Mi forma de resolver este problema es colocar todas sus acciones con un prefijo específico como "web" o "servicio" y configurar que todas las URL con ese prefijo sean interceptadas por DispatcherServlet.

Solo agrego tres reglas antes de la regla predeterminada de primavera (/ **) al filtro urlrewrite de tuckey (urlrewrite.xml) para resolver el 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>

Sé que hay algunas configuraciones para usar el contenido estático, pero mi solución es que solo creo una carpeta de aplicación web masiva dentro de su tomcat. Esta "aplicación web masiva" solo sirve todos los contenidos estáticos sin aplicaciones. Esta es una solución fácil e indolora para servir contenido estático en su aplicación web de primavera real.

Por ejemplo, estoy usando dos carpetas de aplicaciones web en mi tomcat.

1. springapp : solo ejecuta la aplicación web spring sin contenido estático como imgs, js o css. (dedicado para aplicaciones de primavera).
2. recursos : solo sirve el contenido estático sin JSP, servlet o cualquier tipo de aplicación web java. (dedicado para contenido estático)

Si quiero usar javascript, simplemente agrego el URI para mi archivo javascript.

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

Para imágenes estáticas, estoy usando el mismo método.

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

Por último, pongo " restricción de seguridad " en mi tomcat para bloquear el acceso al directorio real. Puse el rol de usuario "nadie" en la restricción para que la página genere un "error prohibido 403" cuando las personas intentaron acceder a la ruta de contenido estático.

Hasta ahora funciona muy bien para mí. También noté que muchos sitios web populares como Amazon, Twitter y Facebook están usando diferentes URI para servir contenido estático. Para descubrir esto, simplemente haga clic derecho en cualquier contenido estático y verifique su URI.

Esto hizo el verdadero trabajo en mi caso

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

...

Para la configuración de primavera basada en Java, puede usar lo siguiente

Usando ResourceHandlerRegistry que almacena registros de manejadores de recursos para servir recursos estáticos.

Más información @ WebMvcConfigurerAdapter que define métodos de devolución de llamada para personalizar la configuración basada en Java para Spring MVC habilitada a través de @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");

    }

Después de encontrar y pasar por el mismo proceso de toma de decisiones descrito aquí, decidí seguir con la propuesta de ResourceServlet, que funciona bastante bien.

Tenga en cuenta que aquí obtiene más información sobre cómo usar el flujo web en su proceso de compilación de Maven: http://static.springsource.org/spring-webflow/docs/2.0.x/reference/html/ch01s05.html

Si usa el repositorio central estándar de Maven, el artefacto es (en oposición al paquete de fuente de recursos mencionado anteriormente):

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

Esto se puede lograr al menos de tres maneras.

Soluciones :

• exponer el html como un archivo de recursos
• instruir a JspServlet para que también maneje solicitudes * .html
• escriba su propio servlet (o pase a otras solicitudes de servlet existentes a * .html).

Para obtener ejemplos de código completos sobre cómo lograr esto, consulte mi respuesta en otra publicación: ¿Cómo asignar solicitudes al archivo HTML en Spring MVC?

El problema es con URLPattern

Cambie su patrón de URL en su asignación de servlet de "/" 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>

y si quieres usar la configuración basada en anotaciones usa el siguiente código

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

Coloque contenido estático como css, js en la siguiente ruta

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