Informazioni su più contenitori nella struttura di primavera

Question

In un tipico progetto MVC di Spring sono presenti due "contenitori": uno creato da ContextLoaderListener e l'altro creato da DispatchServlet.

voglio sapere, sono questi in realtà due IoC esempio contenitore? (Vedo due file di configurazione di fagioli, uno è root-context.xml l'altro è servlet-context.xml)

Se ci sono 2 contenitori, allora qual è il rapporto?

I fagioli dichiarati in un contenitore possono essere utilizzati nell'altro?

Answer 1

Dal Spring Official Website:

L'interfaccia org.springframework.context.ApplicationContext rappresenta il contenitore IoC molla ed è responsabile creare un'istanza, la configurazione e assemblaggio dei fagioli suddetti. Il contenitore riceve le sue istruzioni sugli oggetti da istanziare, configurare e assemblare leggendo i metadati di configurazione. I metadati di configurazione sono rappresentati in XML, annotazioni Java o codice Java .

Sempre da Doc ufficiale:

Nel framework MVC Web, ognuno ha il proprio DispatcherServlet WebApplicationContext, che eredita tutti i fagioli già definite nel il WebApplicationContext radice. Questi bean ereditati possono essere sovrascritti nell'ambito specifico del servlet ed è possibile definire nuovi bean specifici dell'ambito in una determinata istanza Servlet.

Ora venendo alla tua domanda, come si afferma here:

nelle applicazioni Web di primavera, ci sono due tipi di contenitori, ognuno di , che è configurato e inizializzati in modo diverso. Uno è il "Contesto applicativo" e l'altro è il "Contesto applicazione Web". Consente di parlare per la prima volta del "contesto dell'applicazione".Applicazione Context è il contenitore inizializzato da un ContextLoaderListener o ContextLoaderServlet definito nel web.xml e la configurazione sarebbe simile a questa:

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

Nella configurazione sopra, chiedo primavera per caricare tutti i file da il classpath che corrisponde a * -context.xml e crea un Contesto applicazione da esso. Questo contesto potrebbe, ad esempio, contenere componenti come servizi transazionali di livello intermedio, oggetti di accesso ai dati o altri oggetti che è possibile utilizzare (e riutilizzare) attraverso l'applicazione . Ci sarà un contesto applicativo per applicazione.

L'altro contesto è "WebApplicationContext", che è il contesto child del contesto dell'applicazione. Ogni DispatcherServlet definito in un'applicazione Web Spring avrà un associato WebApplicationContext. L'inizializzazione del WebApplicationContext avviene in questo modo:

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

si fornisce il nome del file di configurazione di primavera come parametro di inizializzazione servlet . Quello che è importante ricordare qui è che il nome dell'XML deve essere del modulo -servlet. xml. In questo esempio, il nome del servlet è servizi di piattaforma , pertanto il nome del nostro XML deve essere platform-service-servlet.xml. Qualsiasi bean disponibile in ApplicationContext può essere inviato a da ogni WebApplicationContext. È consigliabile mantenere una separazione netta tra i servizi di livello intermedio come la logica aziendale e le classi di accesso ai dati (che sono tipicamente definite nel ApplicationContext) e i componenti relativi al Web come i controllori e visualizzare i risolutori (che sono definiti nel WebApplicationContext per il servlet Dispatcher .

controllare questi collegamenti

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

Non sono stati creati due contenitori separati. In genere, si desidera che spring instanzia l'oggetto dichiarato in servlet-context.xml quando l'oggetto è richiesto. Pertanto, si associa il file di configurazione servlet-context.xml al servlet Dispatcher, ovvero, si desidera inizializzare l'oggetto quando una richiesta raggiunge il servlet del dispatcher.

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

Dove, come, se si desidera inizializzare l'oggetto e eseguire l'azione quando il contesto viene caricata si dovrebbe dichiarare il file di configurazione con le context-param tag del vostro descrittore di deployment.

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

Si potrebbe testare il tutto scrivendo dichiarando fagioli separati nel servlet-context.xml e radice-context.xml e poi, li autowiring in un contesto personalizzato classe Loader Listener. È possibile trovare solo le istanze del contesto root inizializzate e i bean di contesto servlet sono nulli.

Answer 3

Spring MVC hanno almeno 2 container -

1. contesto applicativo dichiarato dal

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

2. contesto Servlet dichiarato -

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

E un'applicazione web può definire un numero qualsiasi di DispatcherServlet 's. Ogni servlet opererà nel proprio spazio dei nomi, caricando il proprio contesto applicativo con mapping, gestori, ecc. Solo il contesto dell'applicazione root caricato da ContextLoaderListener, se presente, verrà condiviso. Quindi può avere un numero qualsiasi di contenitori per bambini.