Jak obsłużyć statyczną zawartość w Spring MVC?

Ten problem zostanie rozwiązany wiosną 3.0.4.Zwolnij, gdzie możesz użyć <mvc:resources mapping="..." location="..."/> element konfiguracyjny w pliku konfiguracyjnym dyspozytora spring.

Sprawdź Dokumentacja Sprężyny

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

That works for me

<mvc:default-servlet-handler/>

Pozdrawiam

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

Miałem ten sam problem, gdzie surowe wyjście było wyświetlane bez stylów css, javascripts lub plików jquery znaleziono.

Właśnie dodałem mapowania do" domyślnego " servletu. Do sieci dodano:plik 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>

To powinno odfiltrować żądania plików javascript i css z obiektu DispatcherRequest.

Jest jeszcze jeden stack overflow post, który ma doskonałe rozwiązanie .

W skrócie, jest napisane dodaj mapowanie servleta w ten sposób:

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

Właśnie borykałem się z tym problemem na wiosnę 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 jedynym - patrz link powyżej do forów Spring, gdzie słowo "hack" pojawia się kilka razy).

Więc wymyśliłem podobne rozwiązanie do" Unknown (Google) " powyżej, ale zapożyczyłem pomysł, aby wszystkie statyczne treści były serwowane z / static / (zaczerpnięte z wiosennej wersji sklepu zoologicznego app). "Domyślny" servlet nie działał dla mnie, ale zrobił to Spring Webflow ResourceServlet (również zaczerpnięty z aplikacji generowanej przez Spring Roo).

Www.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ą, jaką wprowadziłem w JSPs, było dodanie /static / path do adresów URL dla CSS, JS i obrazów. Np. " ${pageContext.Prośba.contextPath}/static / css / screen.css".

Dla użytkowników Maven zależność dla " org.springframework.js.zasoby.ResourceServlet " jest:

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

Znalazłem sposób obejścia go za pomocą filtra urlrewritefilter tuckey ' a. Proszę dać lepszą odpowiedź, jeśli masz!

W sieci.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 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"."in it (like style.css na przykład) nie zostanie ponownie napisany.

Moje własne doświadczenia z tym problemem są następujące. Większość stron internetowych i książek związanych z 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 statyczne zasoby (CSS, JavaScript, obrazy) w folderze o nazwie "resources" w katalogu głównym aplikacji, np. /webapp/resources/.

Jednak z mojego doświadczenia (używam Eclipse i wtyczki Tomcat), jedyne podejście, które działa, to jeśli umieścisz swój folder zasobów wewnątrz WEB_INF (lub META-INF). Tak więc składnia, którą polecam, jest następująca.

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

W Twoim JSP (lub podobnym) , odwołaj się do zasobu w następujący sposób.

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

Nie trzeba wspominać, całe pytanie powstało tylko dlatego, że chciałem, aby mój Spring dispatcher servlet (front controller) przechwytywał wszystko, wszystko dynamiczne, czyli. Więc mam następujące w mojej sieci.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 aktualnych najlepszych praktyk, mam następujące w moim przednim sterowniku servlet xml (patrz wyżej).

<mvc:annotation-driven/>

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

@RequestMapping("/")

Mam ten sam problem i uznałem odpowiedź Jorisa za bardzo pomocną. Ale dodatkowo muszę dodać

<mvc:annotation-driven /> 

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

URLRewrite jest rodzajem "włamania", jeśli chcesz to tak nazwać. Wszystko sprowadza się do tego, że od nowa wymyślasz koło, ponieważ istnieją już rozwiązania. Kolejną rzeczą do zapamiętania jest serwer Http = zawartość statyczna & serwer aplikacji = zawartość dynamiczna (tak zostały zaprojektowane). Delegując odpowiednie obowiązki na każdy serwer, maksymalizujesz wydajność... ale teraz jest to prawdopodobnie tylko problem w środowisku krytycznym wydajności i coś takiego jak Tomcat najprawdopodobniej sprawdzi się 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>

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

Przykład:

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

W ten sposób kierujesz serwlet dyspozytora, aby zajrzał do zasobów katalogu, aby wyszukać statyczną zawartość.

Moim sposobem rozwiązania tego problemu jest umieszczenie wszystkich twoich działań z określonym prefiksem, takim jak " web " lub "service" i skonfigurowanie, że wszystkie adresy url z tym prefiksem będą przechwytywane przez DispatcherServlet.

Dodaję tylko trzy reguły przed domyślną regułą springa ( / * * ) do urlrewritefilter Tuckey ' a (urlrewrite.xml) do rozwiązania problemu

<?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, aby użyć statycznej zawartości, ale moim rozwiązaniem jest to, że po prostu utworzyć zbiorczy folder aplikacji internetowych w Twoim tomcat. Ta "masowa aplikacja webapp" obsługuje tylko wszystkie treści statyczne bez serwowania aplikacji. Jest to bezbolesne i łatwe rozwiązanie do serwowania statycznych treści do rzeczywistej wiosennej webapp.

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

1. springapp : działa tylko aplikacja webowa spring bez statyczne-treści takie jak imgs, js, czy css. (dedykowane dla aplikacji wiosennych.)
2. resources : obsługuje tylko statyczną zawartość bez JSP, servletu lub jakiejkolwiek aplikacji internetowej java. (dedykowane dla statycznych treści)

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

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

Dla obrazów statycznych używam tej samej metody.

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

Na koniec umieściłem "security-constraint" na moim tomcacie, aby zablokować dostęp do rzeczywistego katalogu. Umieściłem" nobody "user-roll na ograniczeniu tak, że strona generuje "403 forbidden error", gdy ludzie próbowali uzyskać dostęp do ścieżki treści statycznych.

Jak na razie działa to bardzo dobrze dla mnie. Zauważyłem również, że wiele popularnych stron internetowych, takich jak Amazon, Twitter i Facebook, używa różnych URI do serwowania treści statycznych. Na dowiedz się tego, po prostu kliknij prawym przyciskiem myszy dowolną statyczną zawartość i sprawdź ich URI.

Użyłem obu sposobów, które są urlrewrite i adnotacja oparta na Spring mvc 3.0.x i okazało się, że Najbardziej odpowiednie jest podejście oparte na adnotacji, czyli

<annotation-driven />

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

W przypadku urlrewrite, trzeba zdefiniować wiele reguł i trochę czasu również uzyskać klasę not found exception dla UrlRewriteFilter jako już podaną zależność dla niego. Odkryłem, że dzieje się to ze względu na obecność zależności przechodniej, więc znowu jeden krok wzrośnie i trzeba będzie wykluczyć tę zależność z pom.xml using

<exclusion></exclusion> tags.

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

To było prawdziwe zadanie w moim przypadku

W sieci.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>

...

Po napotkaniu i przejściu przez ten sam proces decyzyjny opisany tutaj, postanowiłem przejść z propozycją ResourceServlet, która działa całkiem nieźle.

Zauważ, że więcej informacji na temat korzystania z webflow w procesie budowania Mavena znajdziesz tutaj: http://static.springsource.org/spring-webflow/docs/2.0.x/reference/html/ch01s05.html

Jeśli używasz standardowego centralnego repozytorium Mavena, artefakt jest (w przeciwieństwie do wyżej wymienionego springsource "bundle"): {]}

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

• wyeksponuj html jako plik zasobów
• poinstruuj JspServlet, aby również obsługiwał *.żądania html
• napisać własny servlet (lub przekazać do innego istniejącego servleta żądania do *.html).

Aby uzyskać pełne przykłady kodu jak to osiągnąć proszę o odpowiedź w innym poście: jak mapować żądania do pliku HTML w Spring MVC?

Problem jest z URLPattern

Zmień wzór adresu URL na mapowaniu serwletów 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>

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

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

W konfiguracji sprężyny opartej na Javie możesz użyć następującego

Korzystanie z ResourceHandlerRegistry , które 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");

    }