SpringMVC父子容器

spring与springmvc父子容器_Spring教程_田守枝Java技术博客 (tianshouzhi.com)

父子容器是什么

父子容器并非SpringMVC的专利，在普通Spring环境下，Spring就已经设计出具有层次结构的容器了，这种设计方式也并非Spring独创，起工作方式和ClassLoader很相似，每个容器有一个自己容器的父容器，但是与ClassLoader不同的是，通过容器查找bean时是优先从子容器里查找，如果找不到才会从父容器里查找。当应用中存在多个容器时，这种设计方式可以将公共的bean放到父容器中，如果父容器中的bean不适用，之日起还可以覆盖父容器的bean。

Spring的容器有俩种，一种是常用的ApplicationContext，父子容器相关的层次结构如下。

BeanFactory最终的视线是DefaultListableBeanFactory，其查找bean的部分源码如下，从中可以看出Spring是优先从子容器中查找bean的，如果查找不到会再次从父类容器中找。

案例

系统中有2个模块：module1和module2，两个模块是独立开发的，module2会使用到module1中的一些类，module1会将自己打包为jar提供给module2使用，我们来看一下这2个模块的代码。

放在module1包中，有3个类

Service1

package com.javacode2018.lesson002.demo17.module1;
 
import org.springframework.stereotype.Component;
 
@Component
public class Service1 {
    public String m1() {
        return "我是module1中的Servce1中的m1方法";
    }
}

service2

package com.javacode2018.lesson002.demo17.module1;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
@Component
public class Service2 {
 
    @Autowired
    private com.javacode2018.lesson002.demo17.module1.Service1 service1; //@1
 
    public String m1() { //@2
        return this.service1.m1();
    }
 
}

上面2个类，都标注了@Compontent注解，会被spring注册到容器中。

@1：Service2中需要用到Service1，标注了@Autowired注解，会通过spring容器注入进来

@2：Service2中有个m1方法，内部会调用service的m1方法。

再来看模块2

放在module2包中，也是有3个类，和模块1中的有点类似。

Service1

模块2中也定义了一个Service1，内部提供了一个m2方法，如下：

package com.javacode2018.lesson002.demo17.module2;
 
import org.springframework.stereotype.Component;
 
@Component
public class Service1 {
    public String m2() {
        return "我是module2中的Servce1中的m2方法";
    }
}

Service3

package com.javacode2018.lesson002.demo17.module2;
 
import com.javacode2018.lesson002.demo17.module1.Service2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
@Component
public class Service3 {
    //使用模块2中的Service1
    @Autowired
    private com.javacode2018.lesson002.demo17.module2.Service1 service1; //@1
    //使用模块1中的Service2
    @Autowired
    private com.javacode2018.lesson002.demo17.module1.Service2 service2; //@2
 
    public String m1() {
        return this.service2.m1();
    }
 
    public String m2() {
        return this.service1.m2();
    }
 
}

@1：使用module2中的Service1

@2：使用module1中的Service2

先来思考一个问题

上面的这些类使用spring来操作会不会有问题？会有什么问题？

这个问题还是比较简单的，大部分人都可以看出来，会报错，因为两个模块中都有Service1，被注册到spring容器的时候，bean名称会冲突，导致注册失败。

来个测试类，看一下效果

package com.javacode2018.lesson002.demo17;
 
import com.javacode2018.lesson001.demo21.Config;
import com.javacode2018.lesson002.demo17.module1.Module1Config;
import com.javacode2018.lesson002.demo17.module2.Module2Config;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
public class ParentFactoryTest {
 
    @Test
    public void test1() {
        //定义容器
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        //注册bean
        context.register(Module1Config.class, Module2Config.class); //@1
        //启动容器
        context.refresh();
    }
}

@1：将Module1Config、Module2Config注册到容器，spring内部会自动解析这两个类上面的注解，即：@CompontentScan注解，然后会进行包扫描，将标注了@Compontent的类注册到spring容器。

运行test1输出

下面是部分输出：

Caused by: org.springframework.context.annotation.ConflictingBeanDefinitionException: Annotation-
specified bean name 'service1' for bean class [com.javacode2018.lesson002.demo17.module2.Service1] conflicts with existing, non-compatible bean 
definition of same name and class [com.javacode2018.lesson002.demo17.module1.Service1]

service1这个bean的名称冲突了。

那么我们如何解决？

对module1中的Service1进行修改？这个估计是行不通的，module1是别人以jar的方式提供给我们的，源码我们是无法修改的。

而module2是我们自己的开发的，里面的东西我们可以随意调整，那么我们可以去修改一下module2中的Service1，可以修改一下类名，或者修改一下这个bean的名称，此时是可以解决问题的。

不过大家有没有想过一个问题：如果我们的模块中有很多类都出现了这种问题，此时我们一个个去重构，还是比较痛苦的，并且代码重构之后，还涉及到重新测试的问题，工作量也是蛮大的，这些都是风险。

而spring中的父子容器就可以很好的解决上面这种问题。

什么是父子容器

创建spring容器的时候，可以给当前容器指定一个父容器。

BeanFactory的方式

//创建父容器parentFactory
DefaultListableBeanFactory parentFactory = new DefaultListableBeanFactory();
//创建一个子容器childFactory
DefaultListableBeanFactory childFactory = new DefaultListableBeanFactory();
//调用setParentBeanFactory指定父容器
childFactory.setParentBeanFactory(parentFactory);

ApplicationContext

//创建父容器
AnnotationConfigApplicationContext parentContext = new AnnotationConfigApplicationContext();
//启动父容器
parentContext.refresh();
 
//创建子容器
AnnotationConfigApplicationContext childContext = new AnnotationConfigApplicationContext();
//给子容器设置父容器
childContext.setParent(parentContext);
//启动子容器
childContext.refresh();

上面代码还是比较简单的，大家都可以看懂。

我们需要了解父子容器的特点，这些是比较关键的，如下。

父子容器特点

  1. 父容器和子容器是相互隔离的，他们内部可以存在名称相同的bean
  2. 子容器可以访问父类容器的bean，而父类容器不能访问子类容器的bean
  3. 调用子类容器的getBean方法获取bean的时候，会沿着当前容器开始向上面的容器进行查找，直到找到对应的bean为止
  4. 子类容器中可以通过任何方式注入父类容器的bean，而父类容器无法注入子类容器的bean，原因是第二点

使用父子容器解决开头的问题
关键代码

@Test
public void test2() {
    //创建父容器
    AnnotationConfigApplicationContext parentContext = new AnnotationConfigApplicationContext();
    //向父容器中注册Module1Config配置类
    parentContext.register(Module1Config.class);
    //启动父容器
    parentContext.refresh();
 
    //创建子容器
    AnnotationConfigApplicationContext childContext = new AnnotationConfigApplicationContext();
    //向子容器中注册Module2Config配置类
    childContext.register(Module2Config.class);
    //给子容器设置父容器
    childContext.setParent(parentContext);
    //启动子容器
    childContext.refresh();
 
    //从子容器中获取Service3
    Service3 service3 = childContext.getBean(Service3.class);
    System.out.println(service3.m1());
    System.out.println(service3.m2());
}

运行输出

我是module1中的Servce1中的m1方法
我是module2中的Servce1中的m2方法

注意点

我们使用容器的过程中，经常会使用到的一些方法，这些方法通常会在下面的两个接口中

org.springframework.beans.factory.BeanFactory
org.springframework.beans.factory.ListableBeanFactory

这两个接口中有很多方法，这里就不列出来了，大家可以去看一下源码，这里要说的是使用父子容器的时候，有些需要注意的地方。

BeanFactory接口，是spring容器的顶层接口，这个接口中的方法是支持容器嵌套结构查找的，比如我们常用的getBean方法，就是这个接口中定义的，调用getBean方法的时候，会从沿着当前容器向上查找，直到找到满足条件的bean为止。

而ListableBeanFactory这个接口中的方法是不支持容器嵌套结构查找的，比如下面这个方法

String[] getBeanNamesForType(@Nullable Class<?> type)

获取指定类型的所有bean名称，调用这个方法的时候只会返回当前容器中符合条件的bean，而不会去递归查找其父容器中的bean。

来看一下案例代码，感受一下：

@Test
public void test3() {
    //创建父容器parentFactory
    DefaultListableBeanFactory parentFactory = new DefaultListableBeanFactory();
    //向父容器parentFactory注册一个bean[userName->"路人甲Java"]
    parentFactory.registerBeanDefinition("userName",
            BeanDefinitionBuilder.
                    genericBeanDefinition(String.class).
                    addConstructorArgValue("路人甲Java").
                    getBeanDefinition());
 
    //创建一个子容器childFactory
    DefaultListableBeanFactory childFactory = new DefaultListableBeanFactory();
    //调用setParentBeanFactory指定父容器
    childFactory.setParentBeanFactory(parentFactory);
    //向子容器parentFactory注册一个bean[address->"上海"]
    childFactory.registerBeanDefinition("address",
            BeanDefinitionBuilder.
                    genericBeanDefinition(String.class).
                    addConstructorArgValue("上海").
                    getBeanDefinition());
 
    System.out.println("获取bean【userName】：" + childFactory.getBean("userName"));//@1
 
    System.out.println(Arrays.asList(childFactory.getBeanNamesForType(String.class))); //@2
}

上面定义了2个容器

父容器：parentFactory，内部定义了一个String类型的bean：userName->路人甲Java

子容器：childFactory，内部也定义了一个String类型的bean：address->上海

@1：调用子容器的getBean方法，获取名称为userName的bean，userName这个bean是在父容器中定义的，而getBean方法是BeanFactory接口中定义的，支持容器层次查找，所以getBean是可以找到userName这个bean的

@2：调用子容器的getBeanNamesForType方法，获取所有String类型的bean名称，而getBeanNamesForType方法是ListableBeanFactory接口中定义的，这个接口中方法不支持层次查找，只会在当前容器中查找，所以这个方法只会返回子容器的address

我们来运行一下看看效果：

获取bean【userName】：路人甲Java
[address]

结果和分析的一致。

那么问题来了：有没有方式解决ListableBeanFactory接口不支持层次查找的问题？

spring中有个工具类就是解决这个问题的，如下：

org.springframework.beans.factory.BeanFactoryUtils

这个类中提供了很多静态方法，有很多支持层次查找的方法，源码你们可以去细看一下，名称中包含有Ancestors的都是支持层次查找的。

在test2方法中加入下面的代码：

//层次查找所有符合类型的bean名称
String[] beanNamesForTypeIncludingAncestors = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(childFactory, String.class);
System.out.println(Arrays.asList(beanNamesForTypeIncludingAncestors));
 
Map<String, String> beansOfTypeIncludingAncestors = BeanFactoryUtils.beansOfTypeIncludingAncestors(childFactory, String.class);
System.out.println(Arrays.asList(beansOfTypeIncludingAncestors));

输出

[address, userName]
[{address=上海, userName=路人甲Java}]

问题解答

springmvc中只使用一个容器是否可以？

只使用一个容器是可以正常运行的。

那么springmvc中为什么需要用到父子容器？

通常我们使用springmvc的时候，采用3层结构，controller层，service层，dao层；父容器中会包含dao层和service层，而子容器中包含的只有controller层；这2个容器组成了父子容器的关系，controller层通常会注入service层的bean。

采用父子容器可以避免有些人在service层去注入controller层的bean，导致整个依赖层次是比较混乱的。

父容器和子容器的需求也是不一样的，比如父容器中需要有事务的支持，会注入一些支持事务的扩展组件，而子容器中controller完全用不到这些，对这些并不关心，子容器中需要注入一下springmvc相关的bean，而这些bean父容器中同样是不会用到的，也是不关心一些东西，将这些相互不关心的东西隔开，可以有效的避免一些不必要的错误，而父子容器加载的速度也会快一些。

父子容器的主要作用应该是划分框架边界。有点单一职责的味道。在J2EE三层架构中，在service层我们一般使用spring框架来管理， 而在web层则有多种选择，如spring mvc、struts等。因此，通常对于web层我们会使用单独的配置文件。例如在上面的案例中，一开始我们使用spring-servlet.xml来配置web层，使用applicationContext.xml来配置service、dao层。如果现在我们想把web层从spring mvc替换成struts，那么只需要将spring-servlet.xml替换成Struts的配置文件struts.xml即可，而applicationContext.xml不需要改变。

概念

spring和SpringMVC进行整合的时候，一般情况下我们会使用不同的配置文件来配置spring和spirngmvc，因此我们应用中会存在至少2个ApplicationContext实例，由于是在web应用中，最终实例化的是ApplicationContext的子接口WebApplicationContext

下面的是父容器，上面的是子容器

上图中显示了2个WebApplicationContext实例，为了进行区分，分别称之为：Servlet WebApplicationContext、Root WebApplicationContext。 其中：

Servlet WebApplicationContext：这是对J2EE三层架构中的web层进行配置，如控制器(controller)、视图解析器(view resolvers)等相关的bean。通过spring mvc中提供的DispatchServlet来加载配置，通常情况下，配置文件的名称为spring-servlet.xml。

Root WebApplicationContext：这是对J2EE三层架构中的service层、dao层进行配置，如业务bean，数据源(DataSource)等。通常情况下，配置文件的名称为applicationContext.xml。在web应用中，其一般通过ContextLoaderListener来加载。

springboot

springboot在自动集成了SpringMVC后是否还有父子容器之分？

答案是没有

为什么springMVC弄了一个父子容器？

父子容器的访问规则：子容器可以访问父容器的对象，父容器不能访问子容器的对象

spring mvc中父子容器访问规则：子容器可以访问父容器的对象，父容器不能访问子容器的对象
1.ContextLoaderListener会被优先初始化时，其会根据元素中contextConfigLocation参数指定的配置文件路径"/resource/applicationContext.xml”，来创建WebApplicationContext实例。 并调用ServletContext的setAttribute方法，将其设置到ServletContext中，key为”org.springframework.web.context.WebApplicationContext.ROOT”，最后的”ROOT"字样表明这是一个 Root WebApplicationContext。
2.DispatcherServlet在初始化时调用init方法，会根据元素中contextConfigLocation参数指定的配置文件路径"/resource/spring-servlet.xml”，来创建Servlet WebApplicationContext。同时，其会调用ServletContext的getAttribute方法来判断是否存在Root WebApplicationContext。如果存在，则将其设置为自己的parent。这就是父子上下文(父子容器)的概念。

在Spring Boot中，并没有显式的父子容器的概念。Spring Boot使用了自动配置和自动装配的机制，这种机制简化了应用程序的配置和Bean的管理。Spring Boot应用程序通常只有一个应用程序上下文，而不涉及明确的父子容器。

Spring Boot的自动配置机制会自动加载和配置所需的Bean，这些Bean通常位于应用程序的类路径上。你可以自定义这些Bean，但通常不需要显式地管理父子容器关系。

尽管Spring Boot没有明确的父子容器，但它仍然允许你创建多个配置类和多个包含Bean定义的上下文。这些上下文之间可以有依赖关系，但通常情况下，你不需要显式地管理它们。Spring Boot的目标是简化配置和提供开箱即用的功能，以减少应用程序的复杂性。

为什么需要父子容器

1、父子容器的主要作用应该是划分框架边界。

父子容器的主要作用应该是划分框架边界。有点单一职责的味道。在J2EE三层架构中，在service层我们一般使用spring框架来管理， 而在web层则有多种选择，如spring mvc、struts等。因此，通常对于web层我们会使用单独的配置文件。例如在上面的案例中，一开始我们使用spring-servlet.xml来配置web层，使用applicationContext.xml来配置service、dao层。如果现在我们想把web层从spring mvc替换成struts，那么只需要将spring-servlet.xml替换成Struts的配置文件struts.xml即可，而applicationContext.xml不需要改变。

2、是否可以把所有类都通过Spring父容器来管理

Spring的applicationContext.xml中配置全局扫描，所有的类都通过父容器来管理的配置就是如下：
然后在SpringMvc的配置里面不配置扫描包路径。很显然这种方式是行不通的，这样会导致我们请求接口的时候产生404。因为在解析@ReqestMapping注解的过程中initHandlerMethods()函数只是对Spring MVC 容器中的bean进行处理的，并没有去查找父容器的bean， 因此不会对父容器中含有@RequestMapping注解的函数进行处理，更不会生成相应的handler。所以当请求过来时找不到处理的handler，导致404。

3、是否可以把我们所需的类都放入Spring-mvc子容器里面来管理（springmvc的spring-servlet.xml中配置全局扫描）

这个是把包的扫描配置spring-servlet.xml中这个是可行的。为什么可行因为无非就是把所有的东西全部交给子容器来管理了，子容器执行了refresh方法，把在它的配置文件里面的东西全部加载管理起来来了。虽然可以这么做不过一般应该是不推荐这么去做的，一般人也不会这么干的。如果你的项目里有用到事物、或者aop记得也需要把这部分配置需要放到Spring-mvc子容器的配置文件来，不然一部分内容在子容器和一部分内容在父容器,可能就会导致你的事物或者AOP不生效。（遇到事物不起作用的时候，其实这也是一种情况）

同时通过两个容器同时来管理所有的类？
会造成内存的浪费

父子容器造成的事务失效问题：

比如父容器在service层配置了事务注解，子容器controller在注册的时候就会从父容器拿到事务增强的service方法；但如果子容器中也扫描了service方法，那么controller注入的时候子容器中没有被事务增强的service方法就会被注入到controller方法中，导致事务失效。

Last modification：December 29, 2023
© Allow specification reprint
如果觉得我的文章对你有用，请随意赞赏