java-spring什么是父子容器

主要的问题

1. 什么是父子容器？

2. 为什么需要用父子容器？

3. 父子容器如何使用？

下面我们就来探讨探讨。

我们先来看一个案例

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

模块1

放在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方法。

来个spring配置类：Module1Config

1. package com.javacode2018.lesson002.demo17.module1;

2.  

3. import org.springframework.context.annotation.ComponentScan;

4.  

5. @ComponentScan

6. public class Module1Config {

7. }

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

再来看模块2

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

Service1

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

1. package com.javacode2018.lesson002.demo17.module2;

2.  

3. import org.springframework.stereotype.Component;

4.  

5. @Component

6. public class Service1 {

7.     public String m2() {

8.         return "我是module2中的Servce1中的m2方法";

9.     }

10. }

Service3

1. package com.javacode2018.lesson002.demo17.module2;

2.  

3. import com.javacode2018.lesson002.demo17.module1.Service2;

4. import org.springframework.beans.factory.annotation.Autowired;

5. import org.springframework.stereotype.Component;

6.  

7. @Component

8. public class Service3 {

9.     //使用模块2中的Service1

10.     @Autowired

11.     private com.javacode2018.lesson002.demo17.module2.Service1 service1; //@1

12.     //使用模块1中的Service2

13.     @Autowired

14.     private com.javacode2018.lesson002.demo17.module1.Service2 service2; //@2

15.  

16.     public String m1() {

17.         return this.service2.m1();

18.     }

19.  

20.     public String m2() {

21.         return this.service1.m2();

22.     }

23.  

24. }

@1：使用module2中的Service1

@2：使用module1中的Service2

先来思考一个问题

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

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

来个测试类，看一下效果

1. package com.javacode2018.lesson002.demo17;

2.  

3. import com.javacode2018.lesson001.demo21.Config;

4. import com.javacode2018.lesson002.demo17.module1.Module1Config;

5. import com.javacode2018.lesson002.demo17.module2.Module2Config;

6. import org.junit.Test;

7. import org.springframework.context.annotation.AnnotationConfigApplicationContext;

8.  

9. public class ParentFactoryTest {

10.  

11.     @Test

12.     public void test1() {

13.         //定义容器

14.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();

15.         //注册bean

16.         context.register(Module1Config.class, Module2Config.class); //@1

17.         //启动容器

18.         context.refresh();

19.     }

20. }

@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的方式

1. //创建父容器parentFactory

2. DefaultListableBeanFactory parentFactory = new DefaultListableBeanFactory();

3. //创建一个子容器childFactory

4. DefaultListableBeanFactory childFactory = new DefaultListableBeanFactory();

5. //调用setParentBeanFactory指定父容器

6. childFactory.setParentBeanFactory(parentFactory);

ApplicationContext的方式

1. //创建父容器

2. AnnotationConfigApplicationContext parentContext = new AnnotationConfigApplicationContext();

3. //启动父容器

4. parentContext.refresh();

5.  

6. //创建子容器

7. AnnotationConfigApplicationContext childContext = new AnnotationConfigApplicationContext();

8. //给子容器设置父容器

9. childContext.setParent(parentContext);

10. //启动子容器

11. childContext.refresh();

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

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

父子容器特点

1. 父容器和子容器是相互隔离的，他们内部可以存在名称相同的bean

2. 子容器可以访问父容器中的bean，而父容器不能访问子容器中的bean

3. 调用子容器的getBean方法获取bean的时候，会沿着当前容器开始向上面的容器进行查找，直到找到对应的bean为止

4. 子容器中可以通过任何注入方式注入父容器中的bean，而父容器中是无法注入子容器中的bean，原因是第2点

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

关键代码

1. @Test

2. public void test2() {

3.     //创建父容器

4.     AnnotationConfigApplicationContext parentContext = new AnnotationConfigApplicationContext();

5.     //向父容器中注册Module1Config配置类

6.     parentContext.register(Module1Config.class);

7.     //启动父容器

8.     parentContext.refresh();

9.  

10.     //创建子容器

11.     AnnotationConfigApplicationContext childContext = new AnnotationConfigApplicationContext();

12.     //向子容器中注册Module2Config配置类

13.     childContext.register(Module2Config.class);

14.     //给子容器设置父容器

15.     childContext.setParent(parentContext);

16.     //启动子容器

17.     childContext.refresh();

18.  

19.     //从子容器中获取Service3

20.     Service3 service3 = childContext.getBean(Service3.class);

21.     System.out.println(service3.m1());

22.     System.out.println(service3.m2());

23. }

运行输出

1. 我是module1中的Servce1中的m1方法

2. 我是module2中的Servce1中的m2方法

这次正常了。

父子容器使用注意点

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

1. org.springframework.beans.factory.BeanFactory

2. org.springframework.beans.factory.ListableBeanFactory

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

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

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

String[] getBeanNamesForType(@Nullable Class type)

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

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

1. @Test

2. public void test3() {

3.     //创建父容器parentFactory

4.     DefaultListableBeanFactory parentFactory = new DefaultListableBeanFactory();

5.     //向父容器parentFactory注册一个bean[userName->"路人甲Java"]

6.     parentFactory.registerBeanDefinition("userName",

7.             BeanDefinitionBuilder.

8.                     genericBeanDefinition(String.class).

9.                     addConstructorArgValue("路人甲Java").

10.                     getBeanDefinition());

11.  

12.     //创建一个子容器childFactory

13.     DefaultListableBeanFactory childFactory = new DefaultListableBeanFactory();

14.     //调用setParentBeanFactory指定父容器

15.     childFactory.setParentBeanFactory(parentFactory);

16.     //向子容器parentFactory注册一个bean[address->"上海"]

17.     childFactory.registerBeanDefinition("address",

18.             BeanDefinitionBuilder.

19.                     genericBeanDefinition(String.class).

20.                     addConstructorArgValue("上海").

21.                     getBeanDefinition());

22.  

23.     System.out.println("获取bean【userName】：" + childFactory.getBean("userName"));//@1

24.  

25.     System.out.println(Arrays.asList(childFactory.getBeanNamesForType(String.class))); //@2

26. }

上面定义了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

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

1. 获取bean【userName】：路人甲Java

2. [address]

结果和分析的一致。

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

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

org.springframework.beans.factory.BeanFactoryUtils

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

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

1. //层次查找所有符合类型的bean名称

2. String[] beanNamesForTypeIncludingAncestors = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(childFactory, String.class);

3. System.out.println(Arrays.asList(beanNamesForTypeIncludingAncestors));

4.  

5. Map beansOfTypeIncludingAncestors = BeanFactoryUtils.beansOfTypeIncludingAncestors(childFactory, String.class);

6. System.out.println(Arrays.asList(beansOfTypeIncludingAncestors));

运行输出

1. [address, userName]

2. [{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层次查找的方法等等

案例源码

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

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

Spring系列

1. Spring系列第1篇：为何要学spring？

2. Spring系列第2篇：控制反转（IoC）与依赖注入（DI）

3. Spring系列第3篇：Spring容器基本使用及原理

4. Spring系列第4篇：xml中bean定义详解(-)

5. Spring系列第5篇：创建bean实例这些方式你们都知道？

6. Spring系列第6篇：玩转bean scope，避免跳坑里！

7. Spring系列第7篇：依赖注入之手动注入

8. Spring系列第8篇：自动注入（autowire）详解，高手在于坚持

9. Spring系列第9篇：depend-on到底是干什么的？

10. Spring系列第10篇：primary可以解决什么问题？

11. Spring系列第11篇：bean中的autowire-candidate又是干什么的？

12. Spring系列第12篇：lazy-init：bean延迟初始化

13. Spring系列第13篇：使用继承简化bean配置(abstract & parent)

14. Spring系列第14篇：lookup-method和replaced-method比较陌生，怎么玩的？

15. Spring系列第15篇：代理详解（Java动态代理&cglib代理）？

16. Spring系列第16篇：深入理解java注解及spring对注解的增强（预备知识）

17. Spring系列第17篇：@Configration和@Bean注解详解(bean批量注册)

18. Spring系列第18篇：@ComponentScan、@ComponentScans详解(bean批量注册)

19. Spring系列第18篇：@import详解(bean批量注册)

20. Spring系列第20篇：@Conditional通过条件来控制bean的注册

21. Spring系列第21篇：注解实现依赖注入（@Autowired、@Resource、@Primary、@Qulifier）

22. Spring系列第22篇：@Scope、@DependsOn、@ImportResource、@Lazy 详解

23. Spring系列第23篇：Bean生命周期详解

更多好文章

1. Java高并发系列（共34篇）

2. MySql高手系列（共27篇）

3. Maven高手系列（共10篇）

4. Mybatis系列（共12篇）

5. 聊聊db和缓存一致性常见的实现方式

6. 接口幂等性这么重要，它是什么？怎么实现？

7. 泛型，有点难度，会让很多人懵逼，那是因为你没有看这篇文章！