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

200

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?

hamo
źródło
1
Powiązany samouczek: Spring MVC - Jak dołączyć pliki JS lub CSS na stronie JSP .
informatik01
@hamo Powiązany wątek: stackoverflow.com/questions/34279705/…
smwikipedia

Odpowiedzi:

266

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

Joris
źródło
12
Ten przykład powinien znajdować się w podręczniku użytkownika Spring - jest to najlepsze, jakie widziałem w tym temacie. Dzięki Joris!
Paul
To na pewno załatwiło sprawę - zacząłem robić tylko poradę rozky, ale z jakiegoś powodu każda strona, oprócz mojej strony głównej, renderowała adres URL zasobu w stosunku do strony - zastosowanie się do tej rady czyni relatywną zamiast tego do kontekstowego katalogu głównego mojej aplikacji - i działa idealnie! Dzięki!
Zmora
dzięki! Wyciągałem włosy, dopóki nie zmieniłem linii: <mvc: mapowanie zasobów = "/ resources / **" location = "/, ścieżka klasy: / META-INF / web-resources /" /> na <mvc: mapowanie zasobów = "/ resources / **" location = "/ resources /" />
Mark D
2
Jak wskazał @Bane, kluczową częścią tego rozwiązania jest <c: url value = ... />. Czy mógłbyś (lub ktokolwiek) powiedzieć mi dlaczego? Dzięki!
Mark
4
Możesz także użyć <mvc: resources mapping = "/ **" location = "/ resources /" />, a zostanie on zmapowany do katalogu głównego. (tzn .: katalog główny będzie zawierał oba zasoby ORAZ pliki jsp). To może cię uratować za pomocą c: url wszędzie
efaj
46

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ą

rozky
źródło
5
Chociaż tak naprawdę nie jest „zła”, ta odpowiedź jest zbyt krótka, ponieważ wydaje się, że w własnej dokumentacji Springa (którą nazwałeś swoją odpowiedzią) czegoś brakuje. Sprawdź odpowiedź Jorisa, aby uzyskać bardziej kompletną odpowiedź ... nie fakt, że jest ona długa, ale fakt, że wspomina o użyciu <c: url ...> o którym ani twoja odpowiedź, ani dox Springa nie wspominają - i który okazał się być kluczową częścią rozwiązania.
Zmora
38

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

Ayub Malik
źródło
gdy dodam ten wiersz, otrzymuję: org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException: Wiersz 31 w dokumencie XML z zasobu ścieżki klasy [META-INF / spring / application -ext.xml] jest nieprawidłowy; wyjątek zagnieżdżony to org.xml.sax.SAXParseException; lineNumber: 31; columnNumber: 35; cvc-complex-type.2.4.c: Pasujący znak wieloznaczny jest ścisły, ale nie można znaleźć deklaracji dla elementu „mvc: default-servlet-handler”.
Alex Worden,
Pamiętaj, aby postępować zgodnie z kolejnością programu obsługi, jeśli masz także inne programy rozpoznające widok.
feniks
20

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.

użytkownik243397
źródło
1
Nie chcę używać domyślnego serwletu, który łączy mnie z jboss / tomcat
hamo
@hamo, dlaczego to jest problem? (to jest prawdziwe pytanie, a nie argumentacja). Tak czy inaczej, będziesz musiał uruchomić serwer (jboss / tomcat / jetty), aby uruchomić wiosnę, prawda?
Manav
3
I możesz dodać wszystkie <url-pattern>tagi w tym samym<servlet-mapping>
Milanka
16

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>
użytkownik1788698
źródło
11

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.

hamo
źródło
5
Lepszą odpowiedzią są Spring 3 <mvc:resources/>, jak pokazał @Joris.
Paul
11

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>
nickdos
źródło
Nic złego rozwiązanie nickdos- dziękuję! Nadal nie rozumiem, dlaczego w rdzeniu sprężyny mvc nie ma serwletu zasobów (zamiast dodawać kolejną zależność z przepływem sieciowym) lub jakieś inne gotowe rozwiązanie. Urlrewrite działa dla mnie dobrze, więc na razie będę tego przestrzegać! Na zdrowie, Hamo
hamo
2
Spoglądając wstecz na standardową (nie-Roo) wersję aplikacji Spring Pet Clinic, zauważyłem, że definicja serwletu dla „default” jest skomentowana dodatkowym komentarzem: „Odkomentuj to w kontenerach (GlassFish), które tego nie deklarują niejawna definicja po wyjęciu z pudełka ". Jawna deklaracja pakietu domyślnie to org.apache.catalina.servlets.DefaultServlet. Więc może to być twój „gotowy do użycia” serwlet zasobów (?). Używam Jetty do pracy deweloperów i wygląda na to, że Jetty nie zapewnia domyślnego serwletu (takiego jak Glassfish).
nickdos
8

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.

Puneet Lamba
źródło
To było jedyne rozwiązanie, które działało dla mnie. Jedną interesującą rzeczą, którą zauważyłem, jest to, że nowe zasoby dodane po uruchomieniu aplikacji internetowej zostały odnalezione dopiero po ponownym uruchomieniu. Z punktu widzenia użytkownika nie ma to sensu, ale przez większość czasu nie powinno stanowić poważnego problemu.
Rafael Steil,
Powiedziałeś z perspektywy Tomcat, super :)
omkar sirra
Próbowałem każdej odpowiedzi na tej stronie. Na szczęście, kiedy do niego dotarłem, nie muszę już więcej próbować.
TimeTrax,
6

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.

Susitha Ravinda Senarath
źródło
2

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

Stoney
źródło
2

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.

Chepech
źródło
2

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.

Ruju
źródło
2

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.

Balasubramanian Jayaraman
źródło
1

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.

Teja Kantamneni
źródło
1

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>
Pablo Cantero
źródło
1

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.

0DayHack
źródło
1

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>

...

Jorge Sanchez
źródło
1

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");

    }
Vipul Panth
źródło
0

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> 
ngeek
źródło
0

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?

walkeros
źródło
0

Problem dotyczy URLPattern

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

Asif Malek
źródło
0
<?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();
    }
Jekin Kalariya
źródło
0

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

resources 
        ->static
               ->css
               ->js
(or) 
resources 
        ->public
               ->css
               ->js
Gangatharan Arumugam
źródło