Unterschied zwischen applicationContext.xml und spring-servlet.xml in Spring Framework

Question

• Sind applicationContext.xml y spring-servlet.xml in Spring Framework in irgendeiner Weise zusammenhängen?

• Werden die Eigenschaftsdateien, die in applicationContext.xml zur Verfügung stehen DispatcherServlet ?

• In diesem Zusammenhang: Warum brauche ich eine *-servlet.xml überhaupt? Warum ist applicationContext.xml allein unzureichend?

Answer 1

Mit Spring können Sie mehrere Kontexte in einer Eltern-Kind-Hierarchie definieren.

En applicationContext.xml definiert die Beans für den "Root-Webapp-Kontext", d. h. den mit der Webapp verbundenen Kontext.

En spring-servlet.xml (oder wie auch immer Sie es nennen) definiert die Beans für den Anwendungskontext eines Servlets. Es kann viele davon in einer Webapp geben, eine pro Spring-Servlet (z.B. spring1-servlet.xml für Servlet spring1 , spring2-servlet.xml für Servlet spring2 ).

Bohnen in spring-servlet.xml kann auf Bohnen in applicationContext.xml , aber nicht umgekehrt.

Alle Spring MVC-Controller müssen in der spring-servlet.xml Kontext.

In den meisten einfachen Fällen ist die applicationContext.xml Kontext ist unnötig. Er wird im Allgemeinen verwendet, um Beans zu enthalten, die von allen Servlets in einer Webapp gemeinsam genutzt werden. Wenn Sie nur ein Servlet haben, ist das nicht wirklich sinnvoll, es sei denn, Sie haben eine spezielle Verwendung dafür.

Answer 2

Szenario 1

In der Client-Anwendung (Anwendung ist keine Web-Anwendung, kann z.B. eine Swing-Anwendung sein)

private static ApplicationContext context = new  ClassPathXmlApplicationContext("test-client.xml");

context.getBean(name);

Kein Bedarf an web.xml . ApplicationContext als Container zum Abrufen von Bean-Diensten. Ein Webserver-Container ist nicht erforderlich. In test-client.xml es kann Simple bean ohne Remoting und bean mit Remoting geben.

Schlussfolgerung : In Szenario 1 werden applicationContext und DispatcherServlet sind nicht verwandt.

Szenario 2

In einer Serveranwendung (Anwendung auf einem Server, z. B. Tomcat). Zugriff auf den Dienst über Remoting vom Client-Programm aus (z. B. Swing-Anwendung)

Definieren Sie Hörer in web.xml

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

Beim Start des Servers ContextLoaderListener instanziiert Beans, die in applicationContext.xml .

Angenommen, Sie haben Folgendes in applicationContext.xml :

<import resource="test1.xml" />
<import resource="test2.xml" />
<import resource="test3.xml" />
<import resource="test4.xml" />

Die Beans werden aus allen vier Konfigurationsdateien instanziiert test1.xml , test2.xml , test3.xml , test4.xml .

Schlussfolgerung : In Szenario 2 werden applicationContext und DispatcherServlet sind nicht verwandt.

Szenario 3

In einer Webanwendung mit Spring MVC.

Unter web.xml definieren:

<servlet>
    <servlet-name>springweb</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>    
</servlet>

<servlet-mapping>
    <servlet-name>springweb</servlet-name>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

Wenn Tomcat startet, werden Beans, die in springweb-servlet.xml instanziiert werden. DispatcherServlet erweitert FrameworkServlet . Unter FrameworkServlet Die Bean-Instanziierung erfolgt für springweb . In unserem Fall springweb ist FrameworkServlet.

Schlussfolgerung : In Szenario 3 werden applicationContext und DispatcherServlet sind nicht verwandt.

Szenario 4

In Webanwendungen mit Spring MVC. springweb-servlet.xml für Servlet und applicationContext.xml für den Zugriff auf den Geschäftsdienst innerhalb des Serverprogramms oder für den Zugriff auf den DB-Dienst in einem anderen Serverprogramm.

Unter web.xml sind die folgenden definiert:

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

<servlet>
    <servlet-name>springweb</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>        
</servlet>

<servlet-mapping>
    <servlet-name>springweb</servlet-name>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>

Beim Start des Servers, ContextLoaderListener instanziiert Beans, die in applicationContext.xml ; in der Annahme, dass Sie hier eine Erklärung abgegeben haben:

<import resource="test1.xml" />
<import resource="test2.xml" />
<import resource="test3.xml" />
<import resource="test4.xml" />

Die Beans werden alle aus allen vier test1.xml , test2.xml , test3.xml , test4.xml . Nach Abschluss der Instanziierung der Bohne, die in applicationContext.xml Bohnen, definiert in springweb-servlet.xml instanziiert werden.

Die Reihenfolge der Instanziierung ist also: die Wurzel (Anwendungskontext), dann FrameworkServlet.

Jetzt sollte klar sein, warum sie in welchem Szenario wichtig sind.

Answer 3

Ein weiterer Punkt, den ich hinzufügen möchte. Unter spring-servlet.xml enthalten wir einen Komponentenscan für das Controller-Paket. Im folgenden Beispiel fügen wir eine Filter-Anmerkung für das Controller-Paket ein.

<!-- Scans for annotated @Controllers in the classpath -->
<context:component-scan base-package="org.test.web" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

Unter applicationcontext.xml fügen wir einen Filter für das verbleibende Paket ohne Controller hinzu.

<context:component-scan base-package="org.test">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

Answer 4

Mit einfachen Worten,

applicationContext.xml definiert die Beans, die von allen Servlets gemeinsam genutzt werden. Wenn Ihre Anwendung mehr als ein Servlet hat, sollten Sie die gemeinsamen Ressourcen in der applicationContext.xml würde mehr Sinn machen.

spring-servlet.xml definiert die Beans, die sich nur auf dieses Servlet beziehen. Hier ist es das Dispatcher-Servlet. Ihre Spring MVC-Controller müssen also in dieser Datei definiert werden.

Es ist nicht falsch, alle Bohnen in der Datei spring-servlet.xml wenn Sie nur ein Servlet in Ihrer Webanwendung verwenden.

Answer 5

In Servlet-Technologie, wenn Sie eine beliebige Eingabe an ein bestimmtes Servlet übergeben wollen, dann müssen Sie in init param wie unten Code übergeben.

 <servlet>
    <servlet-name>DBController</servlet-name>
    <servlet-class>com.test.controller.DBController</servlet-class>
    <init-param>
        <param-name>username</param-name>
        <param-value>John</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>DBController</servlet-name>
    <url-pattern>/DBController</url-pattern>
</servlet-mapping>

Wenn Sie etwas in put übergeben wollen, das für alle Servlets gemeinsam ist, dann müssen Sie dieses Mal den Kontextparameter konfigurieren. Beispiel

 <context-param>
    <param-name>email</param-name>
    <param-value>admin@example.com</param-value>
</context-param>

SO genau wie diese, wenn immer wir mit Spring MVC arbeiten, müssen wir einige Informationen zu vordefinierten Servlet zur Verfügung gestellt von Spring, die DispatcherServlet durch init-Parameter ist. Die Konfiguration ist also wie folgt, hier stellen wir die spring-servlet.xml als init-Parameter für DispatcherServlet bereit.

 <?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_3_0.xsd"
    id="WebApp_ID" version="3.0">
    <display-name>Spring MVC App</display-name>

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

    <servlet-mapping>
        <servlet-name>SpringController</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>
</web-app>

Auch hier brauchen wir etwas Kontext. Das gilt für die gesamte Anwendung. Wir können also den Root-Kontext bereitstellen, der applicationcontext.xml ist. Die Konfiguration sieht folgendermaßen aus:

    <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationcontext.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

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

    <servlet-mapping>
        <servlet-name>SpringController</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>