专辑：Spring教程_父子容器-Java充电社【公众号：Java充电社】

又一次被面试官带到坑里面了。

面试官：springmvc用过么？

我：用过啊，经常用呢

面试官：springmvc中为什么需要用父子容器？

我：嗯。。。没听明白你说的什么。

面试官：就是controller层交给一个spring容器加载，其他的service和dao层交给另外一个spring容器加载，web.xml中有这块配置，这两个容器组成了父子容器的关系。

我：哦，原来是这块啊，我想起来了，我看大家都这么用，所以我也这么用

面试官：有没有考虑过为什么？

我：我在网上看大家都这么用，所以我也这么用了，具体也不知道为什么，不过用起来还挺顺手的

面试官：如果只用一个容器可以么，所有的配置都交给一个spring容器加载？

我：应该不行吧！

面试官：确定不行么？

我：让我想一会。。。。。我感觉是可以的，也可以正常运行。

面试官：那我们又回到了开头的问题，为什么要用父子容器呢？

我：我叫你哥好么，别这么玩我了，被你绕晕了？

面试官：好吧，你回去试试看吧，下次再来告诉我，出门右转，不送！

我：脸色变绿了，灰头土脸的走了。

回去之后，我好好研究了一番。

## 主要的问题

1. 什么是父子容器？
2. 为什么需要用父子容器？
3. 父子容器如何使用？

下面我们就来探讨探讨。

## 我们先来看一个案例

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

### 模块1

放在module1包中，有3个类

#### Service1

```java
package com.javacode2018.lesson002.demo17.module1;

import org.springframework.stereotype.Component;

@Component
public class Service1 {
    public String m1() {
        return "我是module1中的Servce1中的m1方法";
    }
}
```

#### Service2

```java
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方法。

#### 来个spring配置类：Module1Config

```java
package com.javacode2018.lesson002.demo17.module1;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class Module1Config {
}
```

> 上面使用了@CompontentScan注解，会自动扫描当前类所在的包中的所有类，将标注有@Compontent注解的类注册到spring容器，即Service1和Service2会被注册到spring容器。

### 再来看模块2

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

#### Service1

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

```java
package com.javacode2018.lesson002.demo17.module2;

import org.springframework.stereotype.Component;

@Component
public class Service1 {
    public String m2() {
        return "我是module2中的Servce1中的m2方法";
    }
}
```

#### Service3

```java
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名称会冲突，导致注册失败。

#### 来个测试类，看一下效果

```java
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输出

下面是部分输出：

```java
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的方式

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

### ApplicationContext的方式

```java
//创建父容器
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，原因是第2点**

## 使用父子容器解决开头的问题

### 关键代码

```java
@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());
}
```

### 运行输出

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

这次正常了。

## 父子容器使用注意点

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

```java
org.springframework.beans.factory.BeanFactory
org.springframework.beans.factory.ListableBeanFactory
```

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

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

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

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

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

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

```java
@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

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

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

结果和分析的一致。

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

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

```java
org.springframework.beans.factory.BeanFactoryUtils
```

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

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

```java
//层次查找所有符合类型的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));
```

运行输出

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

查找过程是按照层次查找所有满足条件的bean。

## 回头看一下springmvc父子容器的问题

**问题1：springmvc中只使用一个容器是否可以？**

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

**问题2：那么springmvc中为什么需要用到父子容器？**

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

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

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

## 总结

1. 本文需掌握父子容器的用法，了解父子容器的特点：子容器可以访问父容器中bean，父容器无法访问子容器中的bean
2. BeanFactory接口支持层次查找
3. ListableBeanFactory接口不支持层次查找
4. BeanFactoryUtils工具类中提供了一些非常实用的方法，比如支持bean层次查找的方法等等

## 案例源码

```java
https://gitee.com/javacode2018/spring-series
```

**路人所有案例代码以后都会放到这个上面，大家watch一下，可以持续关注动态。**

<a style="display:none" target="_blank" href="https://mp.weixin.qq.com/s/_S1DD2JADnXvpexxaBwLLg" style="color:red; font-size:20px; font-weight:bold">继续收门徒，亲手带，月薪 4W 以下的可以来找我</a>

## 最新资料

1. <a href="https://mp.weixin.qq.com/s?__biz=MzkzOTI3Nzc0Mg==&mid=2247484964&idx=2&sn=c81bce2f26015ee0f9632ddc6c67df03&scene=21#wechat_redirect" target="_blank">尚硅谷 Java 学科全套教程（总 207.77GB）</a>
2. <a href="https://mp.weixin.qq.com/s?__biz=MzkwOTAyMTY2NA==&mid=2247484192&idx=1&sn=505f2faaa4cc911f553850667749bcbb&scene=21#wechat_redirect" target="_blank">2021 最新版 Java 微服务学习线路图 + 视频</a>
3. <a href="https://mp.weixin.qq.com/s?__biz=MzkwOTAyMTY2NA==&mid=2247484573&idx=1&sn=7f3d83892186c16c57bc0b99f03f1ffd&scene=21#wechat_redirect" target="_blank">阿里技术大佬整理的《Spring 学习笔记.pdf》</a>
4. <a href="https://mp.weixin.qq.com/s?__biz=MzkwOTAyMTY2NA==&mid=2247484544&idx=2&sn=c1dfe907cfaa5b9ae8e66fc247ccbe84&scene=21#wechat_redirect" target="_blank">阿里大佬的《MySQL 学习笔记高清.pdf》</a>
5. <a href="https://mp.weixin.qq.com/s?__biz=MzkwOTAyMTY2NA==&mid=2247485167&idx=1&sn=48d75c8e93e748235a3547f34921dfb7&scene=21#wechat_redirect" target="_blank">2021 版 java 高并发常见面试题汇总.pdf</a>
6. <a href="https://mp.weixin.qq.com/s?__biz=MzkwOTAyMTY2NA==&mid=2247485664&idx=1&sn=435f9f515a8f881642820d7790ad20ce&scene=21#wechat_redirect" target="_blank">Idea 快捷键大全.pdf</a>

![](https://itsoku.oss-cn-hangzhou.aliyuncs.com/itsoku/blog/article/1/2883e86e-3eff-404a-8943-0066e5e2b454.png)