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

Este problema se resuelve en spring 3.0.4.LANZAMIENTO donde se puede utilizar <mvc:resources mapping="..." location="..."/> elemento de configuración en el archivo de configuración de Spring dispatcher.

Compruebe La documentación de Spring

En Primavera 3.0.x añada lo siguiente a su servlet-config.xml (el archivo que se configura en web.xml como contextConfigLocation. Es necesario añadir el espacio de nombres mvc, así, pero solo Google para que si usted no sabe cómo! ;)

Que funciona para mí

<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 en el que la salida raw se mostraba sin estilos CSS, javascript o archivos jquery encontrados.

Acabo de añadir asignaciones al servlet "default". Lo siguiente fue añadido a la web.archivo 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 "default" es el nombre del servlet predeterminado dentro de JBoss. No estoy muy seguro de lo que es para otros servidores.

Hay otro stack overflow post que tiene una excelente solución.

No parece ser específico de Tomcat, es simple y funciona muy bien. He intentado un par de las soluciones en este post con spring mvc 3.1 pero luego tuve problemas para obtener mi contenido dinámico servido.

En resumen, dice agregar un mapeo de servlet como este:

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

Acabo de estar lidiando con este problema en Spring MVC 3.0 e inicialmente fui con la opción UrlRewriteFilter. Sin embargo, no estaba contento con esta solución, ya que "no se sentía bien" (no soy el único - ver el enlace de arriba a los Foros de Primavera, donde la palabra "hack" aparece un par de veces).

Así que se me ocurrió una solución similar a" Unknown (Google) " anterior, pero tomé prestada la idea de tener todo el contenido estático servido desde / static /(tomado de la versión Spring Roo de la Tienda de Mascotas app). El servlet "predeterminado" no funcionó para mí, pero el Spring Webflow ResourceServlet sí (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 a JSPs fue agregar la ruta /static/ a las URL para CSS, JS e imágenes. Por ejemplo, " {{pageContext.solicitud.contextPath} / static / css / screen.css".

Para los usuarios Maven la dependencia de "org.springframework.js.recurso.ResourceServlet " es:

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

Encontré una manera de evitarlo usando urlrewritefilter de Tuckey. Por favor, siéntase libre de dar una mejor respuesta si usted tiene uno!

En la 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 una '.'en ella (como el estilo.css por ejemplo) no se reescribirá.

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 apropiada 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 "resources" 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). Por lo tanto, 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 Spring dispatcher servlet (controlador frontal) interceptara todo, todo dinámico, es decir. Así que 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, ya que estoy utilizando las mejores prácticas actuales, tengo la siguiendo en mi controlador frontal servlet xml (ver arriba).

<mvc:annotation-driven/>

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

@RequestMapping("/")

Espero que esto ayude.

Tengo el mismo problema y encontré la respuesta de Joris muy útil. Pero, además, tengo que añadir

<mvc:annotation-driven /> 

Al archivo de configuración de servlet. Sin esa asignación de recursos no funcionará y todos los controladores dejarán de funcionar. Espero que esto ayude a alguien.

El URLRewrite es una especie de "hackeo" si quieres llamarlo así. Lo que se reduce a es que estás reinventando la rueda, ya que ya existen soluciones. Otra cosa a recordar es Http Server = Static content & App server = dynamic content (así es como fueron diseñados). Al delegar las responsabilidades apropiadas a cada servidor, maximiza la eficiencia... pero ahora, esto es probablemente solo una preocupación en entornos críticos de rendimiento y algo como Tomcat lo más probable es que funcione bien en ambos roles la mayor parte del tiempo; pero aún 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, en Jboss. Sin embargo, al final decidí usar la solución Spring provides (como mencionó rozky) que es mucho más portátil.

A partir de la primavera 3, todos los recursos deben mapearse 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, usted está dirigiendo el servlet despachador para buscar en los recursos del directorio para buscar el contenido estático.

Mi forma de resolver este problema es colocar todas tus acciones con un prefijo específico como "web" o "service" y configurar que todas las url con ese prefijo serán interceptadas por el DispatcherServlet.

Solo añado tres reglas antes de spring default rule (/**) al filtro urlrewritefilter 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 masiva de aplicaciones web dentro de su tomcat. Esta "aplicación web masiva" solo sirve todos los contenidos estáticos sin servir aplicaciones. Esta es una solución fácil y sin dolor para servir contenidos estáticos a su aplicación web de primavera real.

Por ejemplo, estoy usando dos carpetas webapp en mi tomcat.

1. springapp : se está ejecutando solo la aplicación web spring sin static-contenido como imgs, js, o css. (dedicado para aplicaciones de primavera.)
2. resources: sirve solo el contenido estático sin JSP, servlet o cualquier tipo de aplicación web java. (dedicado a contenidos estáticos)

Si quiero usar javascript, simplemente añado 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, puse " security-constraint" en mi tomcat para bloquear el acceso al directorio real. Puse" nobody "user-roll a la restricción para que la página genere" 403 forbidden error " cuando la gente intentó 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 utilizando diferentes URI para servir contenidos estáticos. A averigüe esto, simplemente haga clic derecho en cualquier contenido estático y verifique su URI.

Usé ambas formas que es urlrewrite y anotación basada en spring mvc 3.0.x y encontró que el enfoque basado en anotaciones es el más adecuado que es

<annotation-driven />

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

En el caso de urlrewrite,tiene que definir un montón de regla y algún tiempo también obtener la clase no se encuentra excepción para UrlRewriteFilter como ya proporcionó la dependencia para ella. 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.

Así que el enfoque basado en la anotación será el buen negocio.

Esto hizo el trabajo real en mi caso

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

...

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

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

Si utiliza el repositorio central Maven estándar, el artefacto es (opuesto al springsource mencionado anteriormente paquete):

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

Esto se puede lograr de al menos tres maneras.

Soluciones:

• exponer el html como un archivo de recursos
• indique al JspServlet que también maneje *.solicitudes html
• escriba su propio servlet (o pase a otro servlet existente peticiones a *.HTML).

Para ejemplos completos de código cómo lograr esto, por favor refiérase a mi respuesta en otro post: ¿Cómo asignar solicitudes a un 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 desea usar la configuración basada en anotaciones, use el siguiente código

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

Para la configuración de spring basada en java puede usar lo siguiente

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

More Info @ WebMvcConfigurerAdapter que define métodos de devolución de llamada para personalizar la configuración basada en Java para Spring MVC habilitado 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");

    }