O wielu kontenerach w ramach wiosna

Question

W typowym wiosennym projekcie MVC istnieją dwa "kontenery": jeden stworzony przez ContextLoaderListener i drugi stworzony przez DispatchServlet.

chcę wiedzieć, to są naprawdę dwie IoC instancja pojemnik? (Widzę dwa pliki konfiguracyjne fasola, jedna jest root-context.xml drugi jest servlet-context.xml)

Jeśli istnieją 2 pojemniki, to co to jest związek?

Czy ziarna zadeklarowane w jednym pojemniku można wykorzystać w drugim?

Answer 1

Z Spring Official Website:

Interfejs org.springframework.context.ApplicationContext przedstawia pojemnik Wiosna IoC i jest odpowiedzialny za uruchamianiu, konfiguracja i montaż wspomnianych fasoli. Kontener otrzymuje instrukcje dotyczące obiektów, które można utworzyć, skonfigurować i złożyć, czytając metadane konfiguracyjne. Metadane konfiguracyjne są reprezentowane w adnotacjach XML, Java lub kodu Java.

Znowu z oficjalnej Doc:

W ramach Web MVC, każdy ma swój własny DispatcherServlet WebApplicationContext, która dziedziczy wszystkie fasole już zdefiniowane w WebApplicationContext korzeń. Te odziedziczone komponenty bean mogą być nadpisywane w zakresie specyficznym dla serwletu i można definiować nowe fasole specyficzne dla zakresu od lokalnie dla danej instancji Serwletu.

Teraz zbliża się do twojego pytania, jak jest powiedziane here:

w Spring Web Applications, istnieją dwa rodzaje opakowania, każdy z który jest skonfigurowany i zainicjowany inaczej. Jednym z nich jest "Kontekst aplikacji", a drugim jest "Kontekst aplikacji internetowej". Najpierw porozmawiajmy o "Kontekście aplikacji".Kontekst aplikacji jest pojemnik zainicjowany przez ContextLoaderListener lub ContextLoaderServlet zdefiniowanego w web.xml i konfiguracji będzie wyglądać mniej więcej tak:

<listener> 
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
</listener> 

<context-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value>classpath:*-context.xml</param-value> 
</context-param> 

W powyższej konfiguracji, pytam wiosna załadować wszystkie pliki z Ścieżka klasy pasująca do * -context.xml i utwórz z niej kontekst aplikacji . Kontekst ten może na przykład zawierać komponenty , takie jak usługi transakcyjne warstwy pośredniej, obiekty dostępu do danych lub inne obiekty, które mogą być przydatne (i ponownie użyte) w aplikacji . W aplikacji będzie jeden kontekst aplikacji.

Innym kontekstem jest kontekst "Kontekst aplikacji internetowej", który jest kontekstem kontekstu aplikacji dla dziecka. Każdy serwer DispatcherServlet zdefiniowany w aplikacji WWW wiosennej będzie mieć powiązany obiekt WebApplicationContext o nazwie . Inicjalizacji WebApplicationContext dzieje się tak:

<servlet> 
     <servlet-name>platform-services</servlet-name> 
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
     <init-param> 
      <param-name>contextConfigLocation</param-name> 
      <param-value>classpath:platform-services-servlet.xml</param-value> 
     </init-param> 
     <load-on-startup>1</load-on-startup> 
</servlet> 

podać nazwę pliku konfiguracyjnego wiosennej jako parametr inicjalizacji serwletu . Ważne jest, aby pamiętać, że nazwa XML musi być z formularza -servlet. xml. W tym przykładzie nazwa serwletu to usługi platformy , dlatego nazwa naszego pliku XML musi być platform-service-servlet.xml. Niezależnie od tego, jakie fasole są dostępne w ApplicationContext, można uzyskać od każdego WebApplicationContext numer . Najlepszą praktyką jest utrzymanie wyraźnej separacji między usługami warstwy pośredniej, takimi jak logika biznesowa komponenty i klasy dostępu do danych (które są zwykle zdefiniowane w ApplicationContext) i komponenty związane z WWW, takie jak kontrolery i widoki rozpoznawania nazw (które są zdefiniowane w WebApplicationContext na serwlet Dispatcher).

sprawdzić te linki

Difference between applicationContext.xml and spring-servlet.xml in Spring Framework

http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/beans.html#beans-basics

Answer 2

Nie utworzono dwóch oddzielnych pojemników. Zazwyczaj chcesz, aby sprężyna stawiła obiekt zadeklarowany w pliku servlet-context.xml, gdy obiekt jest wymagany. Mapujesz plik konfiguracyjny servlet-context.xml do serwletu Dispatchera, tzn. Chcesz zainicjować obiekt, gdy żądanie trafi do serwletu dispatchera.

<servlet> 
    <servlet-name>appServlet</servlet-name> 
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
    <init-param> 
     <param-name>contextConfigLocation</param-name> 
     <param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value> 
    </init-param> 
    <load-on-startup>1</load-on-startup> 
</servlet> 

Jeżeli tak, jeśli chcesz zainicjować obiektu i wykonać działania, gdy kontekst jest ładowany będzie zadeklarować plik konfiguracyjny w context-param tagów swoim deskryptorze wdrożenia.

<context-param> 
    <param-name>contextConfigLocation</param-name> 
    <param-value>/WEB-INF/spring/root-context.xml</param-value> 
</context-param> 

Można to sprawdzić przez pisanie deklarując oddzielnych ziaren w servlet-context.xml i korzeni context.xml a następnie autowiring je w niestandardowy Context klasy Loader słuchacza. Można znaleźć tylko instancje kontekstu głównego są inicjalizowane, a fasole kontekstu serwletu są puste.

Answer 3

Wiosna MVC mieć conajmniej 2 Container -

1. kontekst aplikacji deklarowaną przez

   <context-param> 
       <param-name>contextConfigLocation</param-name> 
       <param-value>/WEB-INF/spring/root-context.xml</param-value> 
   </context-param> 
   

2. kontekst Servlet deklarowało -

   <servlet> 
       <servlet-name>appServlet</servlet-name> 
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
       <init-param> 
        <param-name>contextConfigLocation</param-name> 
        <param-value>servlet-context.xml</param-value> 
       </init-param> 
       <load-on-startup>1</load-on-startup> 
   </servlet> 
   

A aplikacja internetowa może zdefiniować dowolną liczbę DispatcherServlet wieku. Każdy serwlet będzie działał we własnej przestrzeni nazw, ładując swój własny kontekst aplikacji za pomocą odwzorowań, procedur obsługi itp. Tylko kontekst aplikacji root załadowany przez ContextLoaderListener, jeśli jest, będzie współużytkowany. W związku z tym może mieć dowolną liczbę kontenerów podrzędnych.