Jak obsługiwać zawartość statyczną w Spring MVC?

Zajmuję się tworzeniem aplikacji internetowej przy użyciu Spring MVC 3 i DispatcherServletprzechwytywanie wszystkich żądań do „/” w ten sposób (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>

Teraz działa to tak, jak w reklamie, ale jak mogę obsługiwać zawartość statyczną? Wcześniej przed użyciem adresów URL RESTful wychwyciłem na przykład wszystkie pliki * .html i wysłałem je do DispatcherServlet, ale teraz jest inna gra w piłkę.

Mam folder / static /, który zawiera / styles /, / js /, / images / etc i chciałbym wykluczyć / static / * z DispatcherServlet.

Teraz mogłem uruchomić statyczne zasoby, kiedy to zrobiłem:

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

Ale chcę, żeby miał ładne adresy URL (chodzi mi o to, że korzystam z Spring MVC 3), a nie o stronę docelową, którą jest www.domain.com/app/

Nie chcę też rozwiązania połączonego z tomcat lub innym kontenerem serwletów, a ponieważ jest to (stosunkowo) mały ruch, nie potrzebuję serwera WWW (takiego jak apache httpd) przed.

Czy istnieje na to czyste rozwiązanie?

Ponieważ spędziłem dużo czasu na tej kwestii, pomyślałem, że podzielę się moim rozwiązaniem. Od wiosny 3.0.4 wywoływany jest parametr konfiguracyjny <mvc:resources/>(więcej o tym na stronie z dokumentacją referencyjną ), który może być używany do obsługi zasobów statycznych przy jednoczesnym użyciu DispatchServlet w katalogu głównym witryny.

Aby tego użyć, użyj struktury katalogów, która wygląda następująco:

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

Zawartość plików powinna wyglądać następująco:

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

Mam nadzieję że to pomoże :-)

Ten problem został rozwiązany wiosną 3.0.4. ZWOLNIENIE, w którym można użyć <mvc:resources mapping="..." location="..."/> elementu konfiguracyjnego w pliku konfiguracyjnym programu uruchamiającego wiosnę .

Sprawdź dokumentację wiosenną

W Spring 3.0.x dodaj następujące elementy do pliku servlet-config.xml (plik skonfigurowany w pliku web.xml jako contextConfigLocation. Musisz również dodać przestrzeń nazw mvc, ale po prostu google, jeśli nie wiesz jak !;)

To działa dla mnie

<mvc:default-servlet-handler/>

pozdrowienia

Ayub Malik

Jeśli dobrze rozumiem twój problem, myślę, że znalazłem rozwiązanie twojego problemu:

Miałem ten sam problem, w którym wyświetlane były surowe dane wyjściowe bez stylów css, skryptów javascript lub plików jquery.

Właśnie dodałem mapowania do „domyślnego” serwletu. Do pliku web.xml dodano:

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

Powinno to odfiltrować żądania plików javascript i css z obiektu DispatcherRequest.

Znów nie jestem pewien, czy tego właśnie szukasz, ale dla mnie to zadziałało. Myślę, że „default” to nazwa domyślnego serwletu w JBoss. Nie jestem pewien, co to jest dla innych serwerów.

Jest jeszcze jeden słupek przepełnienia stosu, który ma doskonałe rozwiązanie .

Nie wydaje się być specyficzny dla Tomcata, jest prosty i działa świetnie. Wypróbowałem kilka rozwiązań w tym poście z wiosenną wersją mvc 3.1, ale potem miałem problemy z udostępnieniem mojej zawartości dynamicznej.

Mówiąc krótko, dodaje mapowanie serwletu w następujący sposób:

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

Znalazłem sposób na obejście tego za pomocą filtra urlrewrite Tuckeya. Jeśli masz taką odpowiedź, podaj lepszą odpowiedź!

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

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

Oznacza to, że każdy uri z „.” w nim (na przykład style.css) nie zostanie przepisany.

Właśnie zmagałem się z tym problemem w Spring MVC 3.0 i początkowo wybrałem opcję UrlRewriteFilter. Jednak nie byłem zadowolony z tego rozwiązania, ponieważ „nie czułem się dobrze” (nie jestem jedyny - zobacz powyższy link do wiosennych forów, na których słowo „hack” pojawia się kilka razy).

Wymyśliłem więc podobne rozwiązanie do powyższego „Nieznany (Google)”, ale pożyczyłem pomysł, aby wszystkie statyczne treści były podawane z / static / (wzięte z wersji Spring Roo aplikacji Pet Store). „Domyślny” serwlet nie działał dla mnie, ale działał ResourceServlet Spring Webflow (również pobrany z aplikacji generowanej przez 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>

Jedyną zmianą, którą wprowadziłem do stron JSP, było dodanie / static / path do adresów URL dla CSS, JS i obrazów. Np. „$ {PageContext.request.contextPath} /static/css/screen.css”.

dla użytkowników Maven zależność dla „org.springframework.js.resource.ResourceServlet” wynosi:

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

Moje własne doświadczenia z tym problemem są następujące. Większość stron i książek związanych ze wiosną wydaje się sugerować, że najbardziej odpowiednia składnia jest następująca.

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

Powyższa składnia sugeruje, że możesz umieścić swoje zasoby statyczne (CSS, JavaScript, obrazy) w folderze o nazwie „zasoby” w katalogu głównym aplikacji, tj. / Webapp / resources /.

Jednak z mojego doświadczenia (używam Eclipse i wtyczki Tomcat), jedyne podejście, które działa, to umieszczenie folderu zasobów w WEB_INF (lub META-INF). Polecam więc następującą składnię.

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

Na stronie JSP (lub podobnej) odwołaj się do zasobu w następujący sposób.

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

Nie trzeba dodawać, że całe pytanie powstało tylko dlatego, że chciałem, aby mój serwlet dyspozytorski Spring (kontroler frontowy) przechwytywał wszystko, wszystko dynamiczne, to znaczy. Więc mam następujące w moim pliku 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>

Wreszcie, ponieważ korzystam z bieżących najlepszych praktyk, mam następujące serwlety kontrolera xml (patrz wyżej).

<mvc:annotation-driven/>

I mam następujące w mojej rzeczywistej implementacji kontrolera, aby upewnić się, że mam domyślną metodę obsługi wszystkich przychodzących żądań.

@RequestMapping("/")

Mam nadzieję, że to pomoże.

Mam ten sam problem i uważam, że odpowiedź Jorisa była bardzo pomocna. Ale dodatkowo muszę dodać

<mvc:annotation-driven /> 

do pliku konfiguracyjnego serwletu. Bez tego mapowanie zasobów nie będzie działać, a wszystkie programy obsługi przestaną działać. Mam nadzieję, że to komuś pomoże.

URLRewrite to swego rodzaju „hack”, jeśli chcesz to tak nazwać. Wszystko sprowadza się do tego, że od nowa wymyślasz koło; ponieważ istnieją już rozwiązania. Inną rzeczą do zapamiętania jest Http Server = zawartość statyczna i serwer aplikacji = zawartość dynamiczna (w taki sposób zostały zaprojektowane). Przenosząc odpowiednie obowiązki na każdy serwer, maksymalizujesz wydajność ... ale obecnie jest to prawdopodobnie tylko problem w środowiskach o krytycznym znaczeniu i coś takiego jak Tomcat najprawdopodobniej działałoby dobrze w obu rolach przez większość czasu; ale nadal należy o tym pamiętać.

Rozwiązałem to w ten sposób:

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

Działa to na Tomcat i oczywiście Jboss. Jednak ostatecznie zdecydowałem się skorzystać z rozwiązania zapewnianego przez Spring (jak wspomniano przez rozky), które jest znacznie bardziej przenośne.

Użyłem obu sposobów, czyli urlrewrite i adnotacji opartych na wersji wiosennej mvc 3.0.x, i odkryłem, że podejście oparte na adnotacjach jest najbardziej odpowiednie, to znaczy

<annotation-driven />

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

W przypadku urlrewrite, musisz zdefiniować wiele reguł i jakiś czas dostać również wyjątek klasy nie znaleziony dla UrlRewriteFilter, ponieważ już podał zależność. Odkryłem, że dzieje się tak z powodu obecności zależności przechodnich, więc ponownie jeden krok zwiększy się i będę musiał wykluczyć tę zależność z pom.xml przy użyciu

<exclusion></exclusion> tags.

Tak więc podejście oparte na adnotacjach będzie dobrym rozwiązaniem.

Od wiosny 3 wszystkie zasoby muszą być mapowane w inny sposób. Musisz użyć znacznika, aby określić lokalizację zasobów.

Przykład:

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

Postępując w ten sposób, kierujesz serwletem programu rozsyłającego, aby sprawdził zasoby katalogu w poszukiwaniu zawartości statycznej.

Moim sposobem rozwiązania tego problemu jest umieszczenie wszystkich swoich działań z określonym prefiksem, takim jak „web” lub „service” i skonfigurowanie, aby wszystkie adresy URL z tym prefiksem były przechwytywane przez DispatcherServlet.

Właśnie dodałem trzy reguły przed wiosną domyślną regułą (/ **) do urlrewritefilter Tuckeya (urlrewrite.xml), aby rozwiązać problem

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

Wiem, że istnieje kilka konfiguracji używania zawartości statycznej, ale moje rozwiązanie polega na tym, że po prostu tworzę zbiorczy folder aplikacji sieciowej w twoim kocurku. Ta „masowa aplikacja internetowa” obsługuje tylko całą zawartość statyczną bez udostępniania aplikacji. Jest to bezbolesne i łatwe rozwiązanie do podawania statycznych treści do rzeczywistej wiosennej aplikacji internetowej.

Na przykład używam dwóch folderów aplikacji internetowych na moim tomcat.

1. springapp : działa tylko wiosenna aplikacja internetowa bez zawartości statycznej, takiej jak imgs, js lub css. (dedykowany do aplikacji wiosennych).
2. zasoby : obsługuje tylko zawartość statyczną bez JSP, serwletu lub jakiejkolwiek aplikacji Java. (dedykowany dla zawartości statycznej)

Jeśli chcę użyć javascript, po prostu dodaję identyfikator URI do mojego pliku javascript.

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

W przypadku obrazów statycznych używam tej samej metody.

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

Na koniec postawiłem „ ograniczenie bezpieczeństwa koniec ” na moim kocurku, aby zablokować dostęp do rzeczywistego katalogu. Ustawiam rolkę użytkownika „none” na ograniczenie, aby strona generowała „błąd 403 zabroniony”, gdy ludzie próbowali uzyskać dostęp do ścieżki zawartości statycznej.

Jak dotąd działa dla mnie bardzo dobrze. Zauważyłem również, że wiele popularnych stron internetowych, takich jak Amazon, Twitter i Facebook, używają różnych URI do udostępniania treści statycznych. Aby się tego dowiedzieć, kliknij prawym przyciskiem myszy dowolną treść statyczną i sprawdź jej identyfikator URI.

To zrobiło prawdziwą robotę w moim przypadku

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

...

W przypadku wiosennej konfiguracji opartej na języku Java można użyć następujących opcji

Korzystanie z ResourceHandlerRegistry która przechowuje rejestracje procedur obsługi zasobów do obsługi zasobów statycznych.

Więcej informacji @ WebMvcConfigurerAdapter, który definiuje metody wywołania zwrotnego w celu dostosowania konfiguracji opartej na Javie dla Spring MVC włączonej przez @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");

    }

Po spotkaniu i przejściu tego samego procesu decyzyjnego opisanego tutaj, zdecydowałem się na propozycję ResourceServlet, która działa całkiem nieźle.

Zwróć uwagę, że więcej informacji na temat korzystania z przepływu w procesie kompilacji maven znajduje się tutaj: http://static.springsource.org/spring-webflow/docs/2.0.x/reference/html/ch01s05.html

Jeśli używasz standardowego centralnego repozytorium Maven, artefaktem jest (w przeciwieństwie do wyżej wspomnianego pakietu źródeł źródłowych):

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

Można to osiągnąć na co najmniej trzy sposoby.

Rozwiązania :

• ujawnić HTML jako plik zasobów
• poinstruuj JspServlet, aby obsługiwał również żądania * .html
• napisz własny serwlet (lub przekaż do innego istniejącego żądania serwletu na * .html).

Aby uzyskać pełne przykłady kodu, jak to osiągnąć, proszę odnieść się do mojej odpowiedzi w innym poście: Jak mapować żądania do pliku HTML w Spring MVC?

Problem dotyczy URLPattern

Zmień wzorzec adresu URL w mapowaniu serwletu z „/” na „/ *”

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

a jeśli chcesz użyć konfiguracji opartej na adnotacjach, użyj poniższego kodu

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

Umieść zawartość statyczną, taką jak css, js w następującej ścieżce

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