又一次被面试官带到坑里面了。
面试官：springmvc用过么？
我：用过啊，经常用呢
面试官：springmvc中为什么需要用父子容器？
我：嗯。。。没听明白你说的什么。
面试官：就是controller层交给一个spring容器加载，其他的service和dao层交给另外一个spring容器加载，web.xml中有这块配置，这两个容器组成了父子容器的关系。
我：哦，原来是这块啊，我想起来了，我看大家都这么用，所以我也这么用
面试官：有没有考虑过为什么？
我：我在网上看大家都这么用，所以我也这么用了，具体也不知道为什么，不过用起来还挺顺手的
面试官：如果只用一个容器可以么，所有的配置都交给一个spring容器加载？
我：应该不行吧！
面试官：确定不行么？
我：让我想一会。。。。。我感觉是可以的，也可以正常运行。
面试官：那我们又回到了开头的问题，为什么要用父子容器呢？
我：我叫你哥好么，别这么玩我了，被你绕晕了？
面试官：好吧，你回去试试看吧，下次再来告诉我，出门右转，不送！
我：脸色变绿了，灰头土脸的走了。
回去之后，我好好研究了一番，下次准备再去给面试官一点颜色看看。
主要的问题
什么是父子容器？
为什么需要用父子容器？
父子容器如何使用？
下面我们就来探讨探讨。
我们先来看一个案例
系统中有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
-
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方法，如下：
-
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();
上面代码还是比较简单的，大家都可以看懂。
我们需要了解父子容器的特点，这些是比较关键的，如下。
父子容器特点
父容器和子容器是相互隔离的，他们内部可以存在名称相同的bean
子容器可以访问父容器中的bean，而父容器不能访问子容器中的bean
调用子容器的getBean方法获取bean的时候，会沿着当前容器开始向上面的容器进行查找，直到找到对应的bean为止
子容器中可以通过任何注入方式注入父容器中的bean，而父容器中是无法注入子容器中的bean，原因是第2点
使用父子容器解决开头的问题
关键代码
-
@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}]
查找过程是按照层次查找所有满足条件的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父容器中同样是不会用到的，也是不关心一些东西，将这些相互不关心的东西隔开，可以有效的避免一些不必要的错误，而父子容器加载的速度也会快一些。
总结
本文需掌握父子容器的用法，了解父子容器的特点：子容器可以访问父容器中bean，父容器无法访问子容器中的bean
BeanFactory接口支持层次查找
ListableBeanFactory接口不支持层次查找
BeanFactoryUtils工具类中提供了一些非常实用的方法，比如支持bean层次查找的方法等等
案例源码
https://gitee.com/javacode2018/spring-series
路人甲java所有案例代码以后都会放到这个上面，大家watch一下，可以持续关注动态。
Spring系列
更多好文章
感谢大家的阅读，也欢迎您把这篇文章分享给更多的朋友一起阅读！谢谢！
路人甲java
▲长按图片识别二维码关注
路人甲Java：工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活！
转载：https://blog.csdn.net/likun557/article/details/105608851