it-swarm.com.de

Rolle / Zweck von ContextLoaderListener im Frühjahr?

Ich lerne Spring Framework welches in meinem Projekt verwendet wird. Ich habe den Eintrag ContextLoaderListener in meiner web.xml Datei gefunden. Aber konnten nicht herausfinden, wie genau es einem Entwickler hilft?

In der offiziellen Dokumentation von ContextLoaderListener heißt es WebApplicationContext. Zu WebApplicationContext JavaDocs sagen:

Schnittstelle zur Bereitstellung der Konfiguration für eine Webanwendung.


Aber ich kann nicht verstehen, was ich mit ContextLoaderListener erreiche, das den WebApplicationContext intern initialisiert?

Nach meinem Verständnis liest ContextLoaderListener die Spring-Konfigurationsdatei (wobei der Wert gegen contextConfigLocation in web angegeben wird .xml), parst es und lädt die in dieser Konfigurationsdatei definierte Singleton Bean. Wenn wir prototype bean laden möchten, wird derselbe Webanwendungskontext zum Laden verwendet. Also initialisieren wir die Webapplikation mit ContextLoaderListener, damit wir die Konfigurationsdatei im Voraus lesen/analysieren/validieren und wann immer wir Abhängigkeiten einschleusen wollen, können wir dies unverzüglich tun. Ist dieses Verständnis richtig?

160
M Sach

Dein Verständnis ist korrekt. Das ApplicationContext ist der Ort, an dem Ihre Frühlingsbohnen leben. Der Zweck von ContextLoaderListener ist zweifach:

  1. den Lebenszyklus des ApplicationContext mit dem Lebenszyklus des ServletContext zu verknüpfen und

  2. um die Erstellung des ApplicationContext zu automatisieren, müssen Sie keinen expliziten Code schreiben, um es zu erstellen - es ist eine praktische Funktion.

Ein weiterer Vorteil von ContextLoaderListener ist, dass ein WebApplicationContext erstellt wird und WebApplicationContext über ServletContext auf ServletContextAware zugreift. Beans und die getServletContext Methode.

103
sourcedelica

ContextLoaderListener ist optional . Um hier einen Punkt zu verdeutlichen: Sie können eine Spring-Anwendung starten, ohne jemals ContextLoaderListener zu konfigurieren, nur ein Minimum web.xml Mit DispatcherServlet.

So würde es aussehen:

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

Erstellen Sie eine Datei mit dem Namen dispatcher-servlet.xml Und speichern Sie sie unter WEB-INF. Da wir index.jsp In der Willkommensliste erwähnt haben, fügen Sie diese Datei unter WEB-INF Hinzu.

dispatcher-servlet.xml

Im dispatcher-servlet.xml Definieren Sie Ihre Bohnen:

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

Für eine einfache Spring-Anwendung müssen Sie ContextLoaderListener nicht in Ihrem web.xml Definieren. Sie können einfach alle Ihre Spring-Konfigurationsdateien in <servlet> ablegen:

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

Für eine komplexere Spring-Anwendung, in der mehrere DispatcherServlet definiert sind, können Sie die allgemeinen Spring-Konfigurationsdateien verwenden, die von allen in DispatcherServlet definierten ContextLoaderListener gemeinsam genutzt werden:

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

Denken Sie daran, dass ContextLoaderListener die eigentliche Initialisierungsarbeit für den Stammanwendungskontext ausführt.

Ich fand diesen Artikel sehr hilfreich: Spring MVC - Anwendungskontext vs. Webanwendungskontext

23
xli

Der Blog " Zweck von ContextLoaderListener - Spring MVC " gibt eine sehr gute Erklärung.

Demnach sind Anwendungskontexte hierarchisch und daher wird der Kontext von DispatcherSerlvet zum Kind des ContextLoaderListener-Kontexts. Aufgrund dessen kann die in der Controller-Ebene verwendete Technologie (Struts oder Spring MVC) unabhängig vom erstellten ContextLoaderListener-Stammkontext verwendet werden.

10
Dileepa

Wenn Sie Ihre Servlet-Datei an Ihrem benutzerdefinierten Speicherort oder mit einem benutzerdefinierten Namen anstelle der Standardbenennungskonvention ablegen möchten [servletname]-servlet.xml und Pfad unter Web-INF/, dann können Sie ContextLoaderListener verwenden.

3
Dungeon_master

ContextLoaderListner ist ein Servlet-Listener, der alle verschiedenen Konfigurationsdateien (Service-Layer-Konfiguration, Persistenz-Layer-Konfiguration usw.) in den Kontext einer einzelnen Spring-Anwendung lädt.

Dies hilft, Federkonfigurationen auf mehrere XML-Dateien aufzuteilen.

Sobald die Kontextdateien geladen sind, erstellt Spring ein WebApplicationContext-Objekt auf der Grundlage der Bean-Definition und speichert es im ServletContext Ihrer Webanwendung.

3
Prashant_M

enter image description here Dieser Bootstrap Listener soll Spring's root WebApplicationContext starten und herunterfahren mehrere Dispatcher-Servlets mit jeweils einem eigenen Anwendungskontext, der Controller, View Resolver, Handler-Mappings usw. enthält. Möglicherweise möchten Sie jedoch Service-Beans und DAO-Beans im Stammanwendungskontext haben und in allen untergeordneten Anwendungskontexten (Anwendungskontexten, die von Dispatcher-Servlets erstellt wurden) verwenden ).

Die zweite Verwendung dieses Hörers ist, wenn Sie die Federsicherung verwenden möchten.

2
rulhaniam

Grundsätzlich können Sie Ihren Stammanwendungskontext und Ihren Webanwendungskontext mit ContextLoaderListner isolieren.

Die mit context param zugeordnete Konfigurationsdatei verhält sich wie die Kontextkonfiguration der Stammanwendung. Und die mit dem Dispatcher-Servlet zugeordnete Konfigurationsdatei verhält sich wie der Kontext einer Webanwendung.

In jeder Webanwendung können mehrere Dispatcher-Servlets vorhanden sein, also mehrere Webanwendungskontexte.

In jeder Webanwendung gibt es jedoch möglicherweise nur einen Stammanwendungskontext, der für alle Webanwendungskontexte freigegeben ist.

Wir sollten unsere gemeinsamen Dienste, Entitäten, Aspekte usw. im Kontext der Stammanwendung definieren. Und Controller, Abfangjäger usw. befinden sich im relevanten Webanwendungskontext.

Ein Beispiel für eine web.xml ist

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

Hier kann die Konfigurationsklasse example.config.AppConfig verwendet werden, um Dienste, Entitäten, Aspekte usw. im Stammanwendungskontext zu konfigurieren, die mit allen anderen Webanwendungskontexten gemeinsam genutzt werden (hier gibt es beispielsweise zwei Konfigurationsklassen für den Webanwendungskontext, RestConfig und WebConfig).

PS: Hier ist ContextLoaderListener völlig optional. Wenn wir ContextLoaderListener in der Datei web.xml hier nicht erwähnen, funktioniert AppConfig nicht. In diesem Fall müssen wir alle unsere Dienste und Entitäten in WebConfig und Rest Config konfigurieren.

2
Anil Agrawal

Listener-Klasse - Hört auf ein Ereignis (z. B. Starten/Herunterfahren des Servers)

ContextLoaderListener -

  1. Lauscht beim Starten/Herunterfahren des Servers
  2. Nimmt die Spring-Konfigurationsdateien als Eingabe und erstellt die Beans gemäß Konfiguration und macht sie fertig (zerstört die Bean beim Herunterfahren)
  3. Konfigurationsdateien können wie folgt in der Datei web.xml bereitgestellt werden

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

Es gibt Ihnen die Möglichkeit, Code einzufügen, den Sie zur Bereitstellungszeit der Webanwendung ausführen möchten

1
Jigar Joshi

Wenn wir web.xml ohne ContextLoaderListener schreiben, können wir die Athuntication nicht mit customAuthenticationProvider im Frühjahr Sicherheit geben. Da DispatcherServelet der untergeordnete Kontext von ContextLoaderListener ist, ist customAuthenticationProvider der Teil von parentContext, der ContextLoaderListener ist. Der übergeordnete Kontext kann also nicht die Abhängigkeiten des untergeordneten Kontexts aufweisen. Daher empfiehlt es sich, spring-context.xml in contextparam zu schreiben, anstatt es im initparam zu schreiben.

0
SathishSakthi

Ich glaube, seine eigentliche Verwendung kommt, wenn Sie mehr als eine Konfigurationsdatei haben möchten oder Sie xyz.xml Datei anstelle von applicationcontext.xml für z

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

Ein anderer Ansatz für ContextLoaderListener ist die Verwendung von ContextLoaderServlet wie unten

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

0
user666

Im Kontext des Spring Frameworks besteht der Zweck von ContextLoaderListener darin, die anderen Beans in Ihrer Anwendung zu laden, z. B. die Middle-Tier- und Data-Tier-Komponenten, die das Back-End der Anwendung steuern.

0
Salahin Rocky

Dein Verständnis ist korrekt. Ich frage mich, warum Sie in ContextLoaderListener keine Vorteile sehen. Beispielsweise müssen Sie eine Sitzungsfactory erstellen (um die Datenbank zu verwalten). Dieser Vorgang kann einige Zeit in Anspruch nehmen. Es ist daher besser, ihn beim Start auszuführen. Natürlich können Sie es mit init-Servlets oder etwas anderem tun, aber der Vorteil von Spring besteht darin, dass Sie die Konfiguration vornehmen, ohne Code zu schreiben.

0
evg