Como lidar com conteúdo estático no Spring MVC?

Estou desenvolvendo um webapp usando o Spring MVC 3 e tenho DispatcherServlettodos os pedidos para '/' assim (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>

Agora isso funciona como anunciado, no entanto, como posso lidar com conteúdo estático? Antes, antes de usar URLs RESTful, eu pegava todos * .html, por exemplo, e enviava isso para o DispatcherServlet, mas agora é um jogo diferente.

Eu tenho uma pasta / static / que inclui / styles /, / js /, / images / etc e gostaria de excluir / static / * do DispatcherServlet.

Agora eu poderia obter recursos estáticos funcionando quando fiz isso:

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

Mas eu quero que ele tenha URLs legais (o ponto de eu usar o Spring MVC 3) e não a página de destino sendo www.domain.com/app/

Também não quero uma solução acoplada ao tomcat ou a qualquer outro contêiner de servlet, e como esse tráfego é (relativamente) baixo, não preciso de um servidor da web (como o apache httpd) na frente.

Existe uma solução limpa para isso?

Como passei muito tempo com esse problema, pensei em compartilhar minha solução. Desde a primavera 3.0.4, existe um parâmetro de configuração chamado <mvc:resources/>(mais sobre isso no site da documentação de referência ) que pode ser usado para servir recursos estáticos enquanto você ainda usa o DispatchServlet na raiz do seu site.

Para usar isso, use uma estrutura de diretórios semelhante à seguinte:

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

O conteúdo dos arquivos deve se parecer com:

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 isto ajude :-)

Esse problema foi resolvido na primavera 3.0.4.RELEASE, onde você pode usar o <mvc:resources mapping="..." location="..."/> elemento de configuração no arquivo de configuração do dispatcher da primavera.

Verifique a documentação da primavera

No Spring 3.0.x, adicione o seguinte ao seu servlet-config.xml (o arquivo configurado no web.xml como o contextConfigLocation. Você também precisa adicionar o espaço para nome mvc, mas pesquise no google se não souber como !;)

Isso funciona para mim

<mvc:default-servlet-handler/>

Saudações

Ayub Malik

Se entendi seu problema corretamente, acho que encontrei uma solução para o seu problema:

Eu tive o mesmo problema em que a saída bruta foi mostrada sem estilos CSS, javascripts ou arquivos jquery encontrados.

Acabei de adicionar mapeamentos ao servlet "padrão". O seguinte foi adicionado ao arquivo 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>

Isso deve filtrar as solicitações de arquivos javascript e css do objeto DispatcherRequest.

Novamente, não tenho certeza se é isso que você procura, mas funcionou para mim. Eu acho que "padrão" é o nome do servlet padrão no JBoss. Não tenho muita certeza do que é para outros servidores.

Há outro post de estouro de pilha que tem uma excelente solução .

Não parece específico do Tomcat, é simples e funciona muito bem. Eu tentei algumas das soluções neste post com o spring mvc 3.1, mas depois tive problemas para exibir meu conteúdo dinâmico.

Em resumo, ele diz adicionar um mapeamento de servlet como este:

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

Encontrei uma maneira de contornar isso usando o urlrewritefilter da tuckey. Por favor, sinta-se livre para dar uma resposta melhor se você tiver uma!

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

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

Isso significa que qualquer uri com um '.' nele (como style.css por exemplo) não será reescrito.

Acabei de lidar com esse problema no Spring MVC 3.0 e, inicialmente, fui com a opção UrlRewriteFilter. No entanto, não fiquei satisfeito com esta solução, pois "não parecia certa" (não sou a única - veja o link acima para os Fóruns do Spring, onde a palavra "hack" aparece algumas vezes).

Então, eu vim com uma solução semelhante ao "Unknown (Google)" acima, mas peguei emprestada a idéia de ter todo o conteúdo estático veiculado em / static / (extraído da versão Spring Roo do aplicativo Pet Store). O servlet "padrão" não funcionou para mim, mas o Spring Webflow ResourceServlet funcionou (também retirado do aplicativo gerado pelo 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>

A única alteração que fiz nas JSPs foi adicionar o caminho / static / aos URLs para CSS, JS e imagens. Por exemplo, "$ {pageContext.request.contextPath} /static/css/screen.css".

para usuários do Maven, a dependência de "org.springframework.js.resource.ResourceServlet" é:

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

Minha própria experiência com esse problema é a seguinte. A maioria das páginas da Web e livros relacionados ao Spring parecem sugerir que a sintaxe mais apropriada é a seguinte.

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

A sintaxe acima sugere que você pode colocar seus recursos estáticos (CSS, JavaScript, imagens) em uma pasta chamada "recursos" na raiz do seu aplicativo, ou seja, / webapp / resources /.

No entanto, na minha experiência (estou usando o Eclipse e o plug-in Tomcat), a única abordagem que funciona é se você colocar sua pasta de recursos dentro de WEB_INF (ou META-INF). Portanto, a sintaxe que eu recomendo é a seguinte.

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

No seu JSP (ou similar), faça referência ao recurso da seguinte maneira.

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

Desnecessário mencionar, toda a questão surgiu apenas porque eu queria que meu servlet do despachante Spring (controlador frontal) interceptasse tudo, tudo dinâmico, ou seja. Então, eu tenho o seguinte no meu 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>

Por fim, como estou usando as melhores práticas atuais, tenho o seguinte no meu servlet de controlador frontal xml (veja acima).

<mvc:annotation-driven/>

E tenho o seguinte na implementação real do controlador, para garantir que eu tenha um método padrão para lidar com todas as solicitações recebidas.

@RequestMapping("/")

Eu espero que isso ajude.

Eu tive o mesmo problema e achei a resposta de Joris muito útil. Mas além disso eu preciso adicionar

<mvc:annotation-driven /> 

para o arquivo de configuração do servlet. Sem esse recurso, o mapeamento não funcionará e todos os manipuladores deixarão de funcionar. Espero que isso ajude alguém.

O URLRewrite é uma espécie de "hack", se você quiser chamar assim. O que se resume é que você está reinventando a roda; pois já existem soluções. Outra coisa a lembrar é o servidor HTTP = conteúdo estático e servidor de aplicativos = conteúdo dinâmico (é assim que eles foram projetados). Ao delegar as responsabilidades apropriadas para cada servidor, você maximiza a eficiência ... mas hoje em dia isso provavelmente é apenas uma preocupação em ambientes críticos de desempenho e algo como o Tomcat provavelmente funcionaria bem nas duas funções na maioria das vezes; mas ainda é algo a ter em mente.

Eu resolvi assim:

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

Isso funciona no Tomcat e no Jboss, é claro. No entanto, no final, decidi usar a solução que o Spring fornece (como mencionado por rozky), que é muito mais portátil.

Usei as duas formas urlrewrite e anotação com base no spring mvc 3.0.xe descobri que a abordagem baseada em anotação é a mais adequada.

<annotation-driven />

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

No caso de urlrewrite, é necessário definir várias regras e, por algum tempo, também obter exceção de classe não encontrada para UrlRewriteFilter, já que a dependência foi fornecida. Descobri que isso está acontecendo devido à presença de dependência transitiva; portanto, mais uma etapa aumentará e será necessário excluir essa dependência do pom.xml usando

<exclusion></exclusion> tags.

Portanto, a abordagem baseada em anotação será o bom negócio.

A partir da primavera 3, todos os recursos precisam ser mapeados de uma maneira diferente. Você precisa usar a tag para especificar a localização dos recursos.

Exemplo:

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

Dessa maneira, você está direcionando o servlet do dispatcher a procurar nos recursos de diretório para procurar o conteúdo estático.

Minha maneira de resolver esse problema é colocar todas as suas ações com um prefixo específico como "web" ou "serviço" e configurar que todas as URLs com esse prefixo serão interceptadas pelo DispatcherServlet.

Acabei de adicionar três regras antes da regra padrão da primavera (/ **) ao urlrewritefilter da tuckey (urlrewrite.xml) para resolver o 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>

Sei que existem algumas configurações para usar o conteúdo estático, mas minha solução é criar uma pasta de aplicativos Web em massa no seu tomcat. Esse "webapp em massa" serve apenas todo o conteúdo estático sem exibir aplicativos. Esta é uma solução fácil e sem dor para fornecer conteúdo estático ao seu webapp de primavera real.

Por exemplo, estou usando duas pastas de aplicativos da web no meu tomcat.

1. springapp : está executando apenas o aplicativo da web spring sem conteúdo estático como imgs, js ou css. (dedicado para aplicativos da primavera.)
2. recursos : está servindo apenas o conteúdo estático sem JSP, servlet ou qualquer tipo de aplicativo da web java. (dedicado ao conteúdo estático)

Se eu quiser usar o javascript, basta adicionar o URI para o meu arquivo javascript.

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

Para imagens estáticas, estou usando o mesmo método.

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

Por último, eu coloquei " restrição de segurança " no meu tomcat para bloquear o acesso ao diretório real. Eu coloquei "ninguém" rolagem de usuário na restrição, para que a página gere "403 erro proibido" quando as pessoas tentavam acessar o caminho do conteúdo estático.

Até agora, funciona muito bem para mim. Também notei que muitos sites populares como Amazon, Twitter e Facebook estão usando URI diferente para veicular conteúdo estático. Para descobrir isso, clique com o botão direito do mouse em qualquer conteúdo estático e verifique seu URI.

Isso fez o trabalho real no meu caso

no 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 configuração de mola baseada em java, você pode usar o seguinte

Usando ResourceHandlerRegistry que armazena registros de manipuladores de recursos para servir recursos estáticos.

Mais informações @ WebMvcConfigurerAdapter, que define métodos de retorno de chamada para personalizar a configuração baseada em Java para o Spring MVC ativada 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");

    }

Depois de encontrar e passar pelo mesmo processo de tomada de decisão descrito aqui, decidi seguir a proposta do ResourceServlet, que funciona muito bem.

Observe que você obtém mais informações sobre como usar o fluxo da web em seu processo de criação do maven aqui: http://static.springsource.org/spring-webflow/docs/2.0.x/reference/html/ch01s05.html

Se você usar o repositório central padrão do Maven, o artefato é (oposto ao pacote de fontes de fontes acima mencionado):

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

Isso pode ser conseguido de pelo menos três maneiras.

Soluções :

• expor o html como um arquivo de recurso
• instrua o JspServlet a também manipular solicitações * .html
• escreva seu próprio servlet (ou passe para outras solicitações de servlet existentes em * .html).

Para obter exemplos completos de código, como conseguir isso, consulte a minha resposta em outra postagem: Como mapear solicitações para o arquivo HTML no Spring MVC?

O problema é com URLPattern

Altere seu padrão de URL no mapeamento do servlet de "/" para "/ *"

<?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 você quiser usar a configuração baseada em anotação, use o código abaixo

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

Coloque o conteúdo estático como css, js no caminho a seguir

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