面试题：SpringMVC 父子容器是什么知道吗？

Spring MVC 中的 父子容器 是一种容器层次结构的设计，主要用于 Web 应用程序中。它由两个容器组成：

1. 父容器：通常是 ApplicationContext，负责管理业务逻辑层的 Bean（如 Service、Repository 等）。
2. 子容器：通常是 WebApplicationContext，负责管理 Web 层的 Bean（如 Controller、视图解析器等）。

---

父子容器的关系

• 父容器 是 子容器 的父级，子容器可以访问父容器中的 Bean，但父容器不能访问子容器中的 Bean。
• 这种设计实现了 分层管理，将业务逻辑和 Web 层逻辑分离，提高了代码的模块化和可维护性。

---

父子容器的配置

在 Spring MVC 中，父子容器的配置通常是通过 DispatcherServlet 和 ContextLoaderListener 来实现的。

1. 父容器

• 通过 ContextLoaderListener 加载，通常配置在 web.xml 中。
• 父容器加载的配置文件通常是 applicationContext.xml，用于管理业务层的 Bean。

   <context-param>
       <param-name>contextConfigLocation</param-name>
       <param-value>classpath:applicationContext.xml</param-value>
   </context-param>

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

2. 子容器

• 通过 DispatcherServlet 加载，每个 DispatcherServlet 都有自己的子容器。
• 子容器加载的配置文件通常是 spring-mvc.xml，用于管理 Web 层的 Bean。

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

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

---

父子容器的工作机制

1. 父容器 先启动，加载业务层的 Bean（如 Service、DAO 等）。
2. 子容器 启动时，会检查是否存在父容器。如果存在，子容器会将父容器作为自己的父级。
3. 子容器加载 Web 层的 Bean（如 Controller、视图解析器等），并可以访问父容器中的 Bean。

---

父子容器的优点

1. 分层管理：将业务逻辑和 Web 层逻辑分离，便于维护和扩展。
2. Bean 的隔离：子容器可以定义与父容器同名的 Bean，子容器的 Bean 会覆盖父容器的 Bean，但仅限于子容器内部。
3. 资源共享：子容器可以访问父容器的 Bean，避免了重复定义。

---

注意事项

1. 避免重复定义 Bean：如果父容器和子容器中定义了同名的 Bean，可能会导致混淆或错误。
2. 依赖注入问题：子容器中的 Bean 可以注入父容器中的 Bean，但父容器中的 Bean 不能注入子容器中的 Bean。
3. 性能问题：父子容器的层次结构可能会增加启动时间和内存消耗。

---

总结

Spring MVC 的父子容器是一种分层设计，通过 ContextLoaderListener 和 DispatcherServlet 实现：

• 父容器：管理业务层的 Bean。
• 子容器：管理 Web 层的 Bean，并可以访问父容器的 Bean。

这种设计提高了代码的模块化和可维护性，但在使用时需要注意 Bean 的命名和依赖注入问题。