Rola / cel Contextloaderlistener na wiosnę?

ContextLoaderListener jest opcjonalne . Dla przypomnienia: możesz uruchomić aplikację Spring bez konfigurowania ContextLoaderListener, tylko podstawowe minimum web.xml z DispatcherServlet.

Oto jak by to wyglądało:

Www.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
    xsi:schemaLocation="
        http://java.sun.com/xml/ns/javaee 
        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" 
    id="WebApp_ID" 
    version="2.5">
  <display-name>Some Minimal Webapp</display-name>
  <welcome-file-list>   
    <welcome-file>index.jsp</welcome-file>    
  </welcome-file-list>

  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>
      org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

Utwórz plik o nazwie dispatcher-servlet.xml i zapisz go pod WEB-INF. Ponieważ wspomnialiśmy index.jsp na liście powitalnej, dodaj ten plik Pod WEB-INF.

Dyspozytor-servlet.xml

W dispatcher-servlet.xml zdefiniuj swoje fasola:

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd     
        http://www.springframework.org/schema/context     
        http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="bean1">
      ...
    </bean>
    <bean id="bean2">
      ...
    </bean>         

    <context:component-scan base-package="com.example" />
    <!-- Import your other configuration files too -->
    <import resource="other-configs.xml"/>
    <import resource="some-other-config.xml"/>

    <!-- View Resolver -->
    <bean 
        id="viewResolver" 
        class="org.springframework.web.servlet.view.UrlBasedViewResolver">
      <property 
          name="viewClass" 
          value="org.springframework.web.servlet.view.JstlView" />
      <property name="prefix" value="/WEB-INF/jsp/" />
      <property name="suffix" value=".jsp" />
    </bean>
</beans>

Dla prostej aplikacji Spring, nie musisz definiować ContextLoaderListener w web.xml; możesz po prostu umieścić wszystkie swoje pliki konfiguracyjne Spring w <servlet>:

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/mvc-core-config.xml, classpath:spring/business-config.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

Dla bardziej złożonej aplikacji Spring, gdzie masz wiele zdefiniowanych DispatcherServlet, możesz mieć wspólne pliki konfiguracyjne Spring, które są współdzielone przez wszystkie DispatcherServlet zdefiniowane w ContextLoaderListener:

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/common-config.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

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

<servlet>
    <servlet-name>mvc2</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/mvc2-config.xmll</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

Pamiętaj, że ContextLoaderListener wykonuje rzeczywistą pracę inicjalizacyjną dla kontekstu aplikacji root .

I ten artykuł bardzo pomaga: Spring MVC-Application Context vs Web Application Context

Blog "Cel ContextLoaderListener-Spring MVC " daje bardzo dobre wyjaśnienie.

Zgodnie z nim konteksty aplikacji są hierarchiczne i dlatego kontekst DispatcherSerlvet staje się potomkiem kontekstu ContextLoaderListener. Dzięki temu technologia używana w warstwie kontrolera (Struts lub Spring MVC) może być niezależna od kontekstu głównego tworzonego przez ContextLoaderListener.

Jeśli chcesz umieścić plik Servleta w niestandardowej lokalizacji lub z niestandardową nazwą, zamiast domyślnej konwencji nazewnictwa [servletname]-servlet.xml i ścieżki pod Web-INF/, możesz użyć ContextLoaderListener.

ContextLoaderListner jest słuchaczem serwletów, który ładuje wszystkie różne pliki konfiguracyjne (konfiguracja warstwy usług, konfiguracja warstwy trwałości itp.) do kontekstu aplikacji single spring.

To pomaga podzielić konfiguracje spring na wiele plików XML.

Po załadowaniu plików kontekstowych, Spring tworzy obiekt WebApplicationContext oparty na definicji bean i przechowuje go w ServletContext Twojej aplikacji internetowej.

Zasadniczo można wyizolować kontekst aplikacji głównej i kontekstu aplikacji webowej za pomocą ContextLoaderListner.

Plik konfiguracyjny zmapowany z context param będzie zachowywał się jak konfiguracja kontekstu aplikacji root. A plik konfiguracyjny zmapowany serwletem dispatchera będzie zachowywał się jak kontekst aplikacji webowej.

W każdej aplikacji webowej możemy mieć wiele serwletów dyspozytorskich, a więc wiele kontekstów aplikacji webowej.

Ale w każdej aplikacji internetowej możemy mieć tylko jeden root kontekst aplikacji współdzielony ze wszystkimi kontekstami aplikacji internetowych.

Powinniśmy zdefiniować nasze wspólne usługi, podmioty, aspekty itp. w kontekście aplikacji root. I kontrolery, przechwytywacze itp. znajdują się w odpowiednim kontekście aplikacji internetowych.

Przykładowa sieć.xml to

<!-- language: xml -->
<web-app>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>example.config.AppConfig</param-value>
    </context-param>
    <servlet>
        <servlet-name>restEntryPoint</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>example.config.RestConfig</param-value>
        </init-param>       
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>restEntryPoint</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>
    <servlet>
        <servlet-name>webEntryPoint</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>example.config.WebConfig</param-value>
        </init-param>       
        <load-on-startup>1</load-on-startup>
    </servlet>  
    <servlet-mapping>
        <servlet-name>webEntryPoint</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app> 

Oto przykład klasy config.config.AppConfig może być używany do konfigurowania usług, elementów, aspektów itp. w kontekście aplikacji root, które będą współdzielone ze wszystkimi innymi kontekstami aplikacji webowych (na przykład tutaj mamy dwie klasy konfiguracji kontekstowej aplikacji webowej RestConfig i WebConfig)

PS: tutaj ContextLoaderListener jest całkowicie opcjonalny. Jeśli nie wspomnimy o ContextLoaderListener w sieci.xml tutaj AppConfig nie będzie działać. W takim przypadku musimy skonfigurować wszystkie nasze usługi i podmioty w WebConfig i Rest Config.

To da ci punkt zaczepienia, aby umieścić kod, który chcesz wykonać w czasie wdrażania aplikacji internetowej

Ten Bootstrap jest uruchamiany i wyłączany przez Spring root Webaplicationcontext. Jako aplikacja webowa może mieć wiele serwletów dispatchera i każdy z nich ma swój własny kontekst aplikacji zawierający Kontrolery, rozdzielacz widoku, mapowania obsługi itp. ale możesz chcieć mieć service beans, DAO beans w głównym kontekście aplikacji i chcieć używać we wszystkich kontekstach aplikacji potomnych (kontekst aplikacji tworzony przez serwlety dispatchera).

2. użycie tego słuchacz jest wtedy, gdy chcesz użyć spring security.

Twoje zrozumienie jest poprawne. Zastanawiam się, dlaczego nie widzisz żadnych korzyści w ContextLoaderListener. Na przykład musisz zbudować fabrykę sesji (do zarządzania Bazą Danych). Ta operacja może zająć trochę czasu, więc lepiej zrobić to przy starcie. Oczywiście możesz to zrobić z serwletami init lub czymś innym, ale zaletą podejścia Springa jest to, że konfigurację robisz bez pisania kodu.

Jeśli napiszemy web.xml bez ContextLoaderListener wtedy nie możemy dać athuntication używając customAuthenticationProvider w spring security. Ponieważ DispatcherServelet jest kontekstem potomnym programu ContextLoaderListener, customAuthenticationProvider jest częścią parentContext, która jest ContextLoaderListener. Tak więc kontekst rodzica nie może mieć zależności kontekstu potomnego. Tak więc najlepiej jest pisać kontekst wiosenny.xml w contextparam zamiast zapisywać go w initparam.

Wierzę, że jego prawdziwe zastosowanie pojawia się, gdy chcesz mieć więcej niż jeden plik konfiguracyjny lub masz xyz.plik xml zamiast applicationcontext.xml dla eg

<context-param><param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/training-service.xml, /WEB-INF/training-data.xml</param-value> </context-param>

Innym podejściem do ContextLoaderListener jest użycie ContextLoaderServlet jak poniżej

<servlet> <servlet-name>context</servlet-name> <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet>

Klasa słuchacza-słucha na wydarzeniu (np.. Uruchamianie/zamykanie serwera)

ContextLoaderListener-

1. nasłuchuje podczas uruchamiania/zamykania serwera
2. pobiera pliki konfiguracyjne Springa jako dane wejściowe i tworzy beans zgodnie z konfiguracją i przygotowuje go (niszczy bean podczas zamykania)

3. Pliki konfiguracyjne mogą być dostarczane w taki sposób w web.xml

   <param-name>contextConfigLocation</param-name>  
   <param-value>/WEB-INF/dispatcher-servlet.xml</param-value>  
   

W kontekście spring Framework celem ContextLoaderListener jest załadowanie innych fasoli w aplikacji, takich jak komponenty warstwy środkowej i warstwy danych, które napędzają tylny koniec aplikacji.