Vai trò / Mục đích của ContextLoaderListener trong Spring?

Tôi đang học Spring Framework đang được sử dụng trong dự án của tôi. Tôi đã tìm thấy mục ContextLoaderListener trong tệp web.xml của mình . Nhưng không thể tìm ra chính xác nó giúp nhà phát triển như thế nào?

Trong tài liệu chính thức của ContextLoaderListener, nó nói rằng nó sẽ bắt đầu WebApplicationContext . Về WebApplicationContext JavaDocs nói:

Giao diện để cung cấp cấu hình cho một ứng dụng web.

Nhưng tôi không thể hiểu những gì tôi đang đạt được với ContextLoaderListener mà khởi tạo bên trong WebApplicationContext ?

Theo hiểu biết của tôi , ContextLoaderListener đọc tệp cấu hình Spring (với giá trị được đưa ra so với bối cảnhConfigLocation trong web.xml ), phân tích cú pháp và tải bean singleton được định nghĩa trong tệp cấu hình đó. Tương tự như vậy khi chúng ta muốn tải bean nguyên mẫu , chúng ta sẽ sử dụng bối cảnh ứng dụng web tương tự để tải nó. Vì vậy, chúng tôi khởi tạo ứng dụng web với ContextLoaderListener để chúng tôi đọc / phân tích / xác thực tệp cấu hình trước và bất cứ khi nào chúng tôi muốn tiêm phụ thuộc, chúng tôi có thể thực hiện ngay mà không bị chậm trễ. Sự hiểu biết này có đúng không?

Sự am hiểu của bạn đa đung đăn. Đây ApplicationContextlà nơi đậu mùa xuân của bạn sống. Mục đích của ContextLoaderListenerhai lần:

1. để buộc vòng đời của ApplicationContextđến vòng đời của ServletContextvà

2. để tự động hóa việc tạo ApplicationContext, vì vậy bạn không phải viết mã rõ ràng để tạo mã - đó là một chức năng tiện lợi.

Một điều thuận tiện khác ContextLoaderListenerlà nó tạo ra WebApplicationContextvà WebApplicationContextcung cấp quyền truy cập ServletContextthông qua các ServletContextAwarebean và getServletContextphương thức.

ContextLoaderListenerlà tùy chọn . Chỉ cần đưa ra quan điểm ở đây: bạn có thể khởi động ứng dụng Spring mà không cần cấu hình ContextLoaderListener, chỉ là mức tối thiểu cơ bản web.xmlvới DispatcherServlet.

Đây là những gì nó sẽ trông như:

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>

Tạo một tập tin được gọi dispatcher-servlet.xmlvà lưu trữ nó dưới WEB-INF. Vì chúng tôi đã đề cập index.jsptrong danh sách chào mừng, hãy thêm tệp này vào WEB-INF.

bộ điều phối-servlet.xml

Trong dispatcher-servlet.xmlđịnh nghĩa đậu của bạn:

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

Đối với một ứng dụng Spring đơn giản, bạn không cần phải xác định ContextLoaderListenertrong web.xml; bạn chỉ có thể đặt tất cả các tệp cấu hình Spring của mình vào <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>

Đối với một ứng dụng Spring phức tạp hơn, nơi bạn có nhiều DispatcherServletđịnh nghĩa, bạn có thể có các tệp cấu hình Spring chung được chia sẻ bởi tất cả các DispatcherServletđịnh nghĩa trong 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>

Chỉ cần ghi nhớ, ContextLoaderListenerthực hiện công việc khởi tạo thực tế cho bối cảnh ứng dụng gốc .

Tôi thấy bài viết này giúp ích rất nhiều: Spring MVC - Bối cảnh ứng dụng và Bối cảnh ứng dụng Web

Blog " Mục đích của ContextLoaderListener - Spring MVC " đưa ra một lời giải thích rất tốt.

Theo đó, bối cảnh ứng dụng là phân cấp và do đó bối cảnh của DispatcherSerlvet trở thành con của bối cảnh ContextLoaderListener. Do đó, công nghệ đang được sử dụng trong lớp trình điều khiển (Struts hoặc Spring MVC) có thể độc lập với bối cảnh gốc được tạo ra ContextLoaderListener.

Khi bạn muốn đặt tệp Servlet của mình vào vị trí tùy chỉnh hoặc với tên tùy chỉnh, thay vì quy ước đặt tên mặc định [servletname]-servlet.xmlvà đường dẫn bên dưới Web-INF/, thì bạn có thể sử dụng ContextLoaderListener.

ContextLoaderListner là một trình nghe Servlet tải tất cả các tệp cấu hình khác nhau (cấu hình lớp dịch vụ, cấu hình lớp liên tục, v.v.) vào ngữ cảnh ứng dụng lò xo đơn.

Điều này giúp phân chia các cấu hình mùa xuân trên nhiều tệp XML.

Khi các tệp ngữ cảnh được tải, Spring tạo một đối tượng WebApplicationContext dựa trên định nghĩa bean và lưu trữ nó trong ServletContext của ứng dụng web của bạn.

Trình nghe Bootstrap này là để khởi động và tắt WebApplicationContext gốc của Spring . Vì một ứng dụng web có thể có nhiều servlet bộ điều phối và mỗi ứng dụng có bối cảnh ứng dụng riêng chứa bộ điều khiển, trình phân giải xem, ánh xạ xử lý, v.v. bối cảnh ứng dụng được tạo bởi các servlet bộ điều phối).

Lần sử dụng thứ 2 của trình nghe này là khi bạn muốn sử dụng bảo mật mùa xuân.

Bối cảnh gốc và con Trước khi đọc thêm, xin vui lòng hiểu rằng -

Mùa xuân có thể có nhiều bối cảnh cùng một lúc. Một trong số đó sẽ là bối cảnh gốc, và tất cả các bối cảnh khác sẽ là bối cảnh con.

Tất cả các bối cảnh con có thể truy cập vào các bean được xác định trong bối cảnh gốc; nhưng ngược lại là không đúng sự thật. Bối cảnh gốc không thể truy cập bối cảnh con đậu.

Ứng dụng Nội dung:

applicationContext.xml là cấu hình bối cảnh gốc cho mọi ứng dụng web. Spring tải tệp applicationContext.xml và tạo ApplicationContext cho toàn bộ ứng dụng. Sẽ chỉ có một bối cảnh ứng dụng cho mỗi ứng dụng web. Nếu bạn không khai báo rõ ràng tên tệp cấu hình ngữ cảnh trong web.xml bằng cách sử dụng paramConfigLocation, Spring sẽ tìm kiếm applicationContext.xml trong thư mục WEB-INF và ném FileNotFoundException nếu nó không thể tìm thấy tệp này.

ContextLoaderListener Thực hiện công việc khởi tạo thực tế cho bối cảnh ứng dụng gốc. Đọc một bối cảnh củaConConigigLocation, bối cảnh-param và chuyển giá trị của nó cho thể hiện bối cảnh, phân tích nó thành nhiều đường dẫn tệp có thể được phân tách bằng bất kỳ số dấu phẩy và khoảng trắng nào, ví dụ: WEB WEB-INF / applicationContext1.xml, WEB-INF / applicationContext2.xml. ContextLoaderListener là tùy chọn. Chỉ cần đưa ra một điểm ở đây: bạn có thể khởi động một ứng dụng Spring mà không cần cấu hình ContextLoaderListener, chỉ là một tệp web.xml tối thiểu cơ bản với DispatcherServlet.

DispatcherServlet DispatcherServlet về cơ bản là một Servlet (nó mở rộng httpServlet) với mục đích chính là xử lý các yêu cầu web đến phù hợp với mẫu URL được định cấu hình. Nó nhận một URI đến và tìm sự kết hợp đúng của bộ điều khiển và khung nhìn. Vì vậy, nó là bộ điều khiển phía trước.

Khi bạn xác định một DispatcherServlet trong cấu hình mùa xuân, bạn cung cấp một tệp XML với các mục của các lớp trình điều khiển, xem ánh xạ, v.v. bằng cách sử dụng thuộc tính contextConfigLocation.

WebApplicationContext Ngoài ApplicationContext, có thể có nhiều WebApplicationContext trong một ứng dụng web. Nói một cách đơn giản, mỗi DispatcherServlet được liên kết với một WebApplicationContext. Tệp xxx-servlet.xml dành riêng cho DispatcherServlet và một ứng dụng web có thể có nhiều hơn một DispatcherServlet được cấu hình để xử lý các yêu cầu. Trong các trường hợp như vậy, mỗi DispatcherServlet sẽ có một xxx-servlet.xml riêng được định cấu hình. Nhưng, applicationContext.xml sẽ phổ biến cho tất cả các tệp cấu hình servlet. Theo mặc định, Spring sẽ tải tệp có tên là xxx xxx-servlet.xml. Từ thư mục WEB-INF của ứng dụng web trong đó xxx là tên servlet trong web.xml. Nếu bạn muốn thay đổi tên của tên tệp đó hoặc thay đổi vị trí, hãy thêm init-param với bối cảnhConfigLocation làm tên param.

So sánh và mối quan hệ giữa chúng:

ContextLoaderListener vs DispatcherServlet

ContextLoaderListener tạo bối cảnh ứng dụng gốc. Các mục nhập của DispatcherServlet tạo một bối cảnh ứng dụng con cho mỗi mục nhập servlet. Bối cảnh con có thể truy cập các đậu được xác định trong bối cảnh gốc. Đậu trong bối cảnh gốc không thể truy cập đậu trong bối cảnh trẻ em (trực tiếp). Tất cả các bối cảnh được thêm vào ServletContext. Bạn có thể truy cập ngữ cảnh gốc bằng lớp WebApplicationContextUtils.

Sau khi đọc tài liệu về Spring, sau đây là cách hiểu:

a) Các bối cảnh ứng dụng được phân cấp và WebApplicationContexts cũng vậy. Tham khảo tài liệu tại đây.

b) ContextLoaderListener tạo bối cảnh ứng dụng web gốc cho ứng dụng web và đặt nó vào ServletContext. Bối cảnh này có thể được sử dụng để tải và dỡ các bean được quản lý mùa xuân tương ứng với những gì công nghệ đang được sử dụng trong lớp điều khiển (Struts hoặc Spring MVC).

c) DispatcherServlet tạo WebApplicationContext của riêng mình và trình xử lý / bộ điều khiển / trình phân giải khung nhìn được quản lý theo ngữ cảnh này.

d) Khi ContextLoaderListener được sử dụng song song với DispatcherServlet, bối cảnh ứng dụng web gốc được tạo trước tiên như đã nói trước đó và bối cảnh con cũng được tạo bởi DispatcherSerlvet và được gắn vào bối cảnh ứng dụng gốc. Tham khảo tài liệu tại đây.

Khi chúng tôi đang làm việc với Spring MVC và cũng đang sử dụng Spring trong lớp dịch vụ, chúng tôi cung cấp hai bối cảnh ứng dụng. Cái đầu tiên được cấu hình bằng ContextLoaderListener và cái còn lại với DispatcherServlet

Nói chung, bạn sẽ xác định tất cả các bean liên quan đến MVC (bộ điều khiển và khung nhìn, v.v.) trong ngữ cảnh của DispatcherServlet và tất cả các bean cắt chéo như bảo mật, giao dịch, dịch vụ, v.v. trong bối cảnh gốc của ContextLoaderListener.

Tham khảo điều này để biết thêm chi tiết: https://siddharthnawani.blogspot.com/2019/10/contextloaderlistener-vs.html

Về cơ bản, bạn có thể cô lập bối cảnh ứng dụng gốc và bối cảnh ứng dụng web bằng ContextLoaderListner.

Tệp cấu hình được ánh xạ với param param sẽ hoạt động như cấu hình bối cảnh của ứng dụng gốc. Và tập tin cấu hình được ánh xạ với bộ điều phối servlet sẽ hoạt động giống như bối cảnh ứng dụng web.

Trong bất kỳ ứng dụng web nào, chúng tôi có thể có nhiều máy chủ điều phối, do đó, nhiều bối cảnh ứng dụng web.

Nhưng trong bất kỳ ứng dụng web nào, chúng tôi có thể chỉ có một bối cảnh ứng dụng gốc được chia sẻ với tất cả các bối cảnh ứng dụng web.

Chúng ta nên xác định các dịch vụ chung, các thực thể, các khía cạnh, vv trong bối cảnh ứng dụng gốc. Và bộ điều khiển, đánh chặn, vv là trong bối cảnh ứng dụng web có liên quan.

Một tệp web.xml mẫu là

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

Ở đây lớp config example.config.AppConfig có thể được sử dụng để cấu hình các dịch vụ, thực thể, các khía cạnh, v.v. trong ngữ cảnh ứng dụng gốc sẽ được chia sẻ với tất cả các bối cảnh ứng dụng web khác (ví dụ ở đây chúng tôi có hai lớp cấu hình bối cảnh ứng dụng web RestConfig và WebConfig)

PS: Ở đây ContextLoaderListener là hoàn toàn tùy chọn. Nếu chúng tôi sẽ không đề cập đến ContextLoaderListener trong web.xml ở đây, AppConfig sẽ không hoạt động. Trong trường hợp đó, chúng tôi cần định cấu hình tất cả các dịch vụ và thực thể của chúng tôi trong WebConfig và Rest Config.

Nó sẽ cung cấp cho bạn điểm hook để đặt một số mã mà bạn muốn được thực thi trong thời gian triển khai ứng dụng web

Lớp người nghe - Lắng nghe một sự kiện (Ví dụ: Khởi động / tắt máy chủ)

ContextLoaderListener -

1. Nghe trong khi máy chủ khởi động / tắt máy
2. Lấy các tệp cấu hình Spring làm đầu vào và tạo các bean theo cấu hình và làm cho nó sẵn sàng (phá hủy các bean trong khi tắt máy)

3. Các tệp cấu hình có thể được cung cấp như thế này trong web.xml

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

Trong bối cảnh mục đích khung mùa xuân của ContextLoaderListener là tải các bean khác trong ứng dụng của bạn, chẳng hạn như các thành phần tầng trung và tầng dữ liệu điều khiển phần cuối của ứng dụng.

Sự am hiểu của bạn đa đung đăn. Tôi tự hỏi tại sao bạn không thấy bất kỳ lợi thế nào trong ContextLoaderListener. Ví dụ: bạn cần xây dựng một nhà máy phiên (để quản lý cơ sở dữ liệu). Thao tác này có thể mất một chút thời gian, vì vậy tốt hơn là thực hiện khi khởi động. Tất nhiên bạn có thể làm điều đó với init servlets hoặc một cái gì đó khác, nhưng lợi thế của cách tiếp cận của Spring là bạn tạo cấu hình mà không cần viết mã.

Nếu chúng ta viết web.xml mà không có ContextLoaderListener thì chúng ta không thể cung cấp cho vận động viên bằng cách sử dụng customAuthenticationProvider trong bảo mật mùa xuân. Vì DispatcherServelet là bối cảnh con của ContextLoaderListener, customAuthenticationProvider là một phần của ParentContext là ContextLoaderListener. Vì vậy, bối cảnh cha mẹ không thể có sự phụ thuộc của bối cảnh con. Và vì vậy, cách tốt nhất là viết spring-bối cảnh trong ngữ cảnh thay vì viết nó trong initparam.

Tôi tin rằng việc sử dụng thực sự của nó xuất hiện khi bạn muốn có nhiều hơn một tệp cấu hình hoặc bạn có tệp xyz.xml thay vì applicationcontext.xml chẳng hạn

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

Một cách tiếp cận khác với ContextLoaderListener là sử dụng ContextLoaderServlet như bên dưới

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