根路径是在这里配的，tomcat的配置自己百度下，很简单
## Java的SPI机制
> 下面会用到SPI，这里先讲一下
### 项目目录
```java
spi-demo
├── api-db-impl-mysql/
| ├── api-db-impl-mysql.iml
| ├── pom.xml
| ├── src/
| | ├── main/
| | | ├── java/
| | | | └── com/
| | | | └── imlql/
| | | | └── mysql/
| | | | └── MySQLSaveService.java
| | | └── resources/
| | | └── META-INF/
| | | └── services/
| | | └── cn.imlql.data.DataSaveService
| | └── test/
| | └── java/
| └── target/
| ├── classes/
| | ├── com/
| | | └── imlql/
| | | └── mysql/
| | | └── MySQLSaveService.class
| | └── META-INF/
| | └── services/
| | └── cn.imlql.data.DataSaveService
| └── generated-sources/
| └── annotations/
├── api-db-impl-redis/
| ├── api-db-impl-redis.iml
| ├── pom.xml
| ├── src/
| | ├── main/
| | | ├── java/
| | | | └── com/
| | | | └── imlql/
| | | | └── redis/
| | | | └── RedisSaveService.java
| | | └── resources/
| | | └── META-INF/
| | | └── services/
| | | └── cn.imlql.data.DataSaveService
| | └── test/
| | └── java/
| └── target/
| ├── classes/
| | ├── com/
| | | └── imlql/
| | | └── redis/
| | | └── RedisSaveService.class
| | └── META-INF/
| | └── services/
| | └── cn.imlql.data.DataSaveService
| └── generated-sources/
| └── annotations/
├── api-db-interface/
| ├── api-db-interface.iml
| ├── pom.xml
| ├── src/
| | ├── main/
| | | ├── java/
| | | | └── com/
| | | | └── imlql/
| | | | └── data/
| | | | └── DataSaveService.java
| | | └── resources/
| | └── test/
| | └── java/
| └── target/
| ├── classes/
| | └── com/
| | └── imlql/
| | └── data/
| | └── DataSaveService.class
| └── generated-sources/
| └── annotations/
├── app/
| ├── app.iml
| ├── pom.xml
| ├── src/
| | ├── main/
| | | ├── java/
| | | | └── com/
| | | | └── imlql/
| | | | └── redis/
| | | | └── MainTest.java
| | | └── resources/
| | └── test/
| | └── java/
| └── target/
| ├── classes/
| | └── com/
| | └── imlql/
| | └── redis/
| | └── MainTest.class
| └── generated-sources/
| └── annotations/
├── pom.xml
└── spi-demo.iml
```
### MainTest
```java
import cn.imlql.data.DataSaveService;
import java.util.ServiceLoader;
/**
* 1、 ServiceLoader：load（）指定一个接口，
* 他就会加载当前系统里面所有的这个接口的【指定实现】
* 2、SPI（Service Provider Interface）
* 接口工程---提供接口
* ---- 实现工程1 ： 实现接口 【META-INF/services 创建文件 接口名作为文件名 实现类全路径作为文件内容】
* ---- 实现工程2 ： 实现接口
*
*
* 客户端----引用 工程1、或者 工程2
*
*
*
*/
public class MainTest {
public static void main(String[] args) {
//1、加载 可用的接口实现
ServiceLoader
```java
@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {...}
```
### ServletContainerInitializer#onStartup()
```java
public interface ServletContainerInitializer {
public void onStartup(Set
相当于tomcat一启动会加载SpringServletContainerInitializer
### SpringServletContainerInitializer#onStartup()
```java
/**
* Servlet 3.0 {@link ServletContainerInitializer} designed to support code-based
* configuration of the servlet container using Spring's {@link WebApplicationInitializer}
* SPI as opposed to (or possibly in combination with) the traditional
* {@code web.xml}-based approach.
*
* See Also
* See {@link WebApplicationInitializer} Javadoc for examples and detailed usage * recommendations.* * @author Chris Beams * @author Juergen Hoeller * @author Rossen Stoyanchev * @since 3.1 * @see #onStartup(Set, ServletContext) * @see WebApplicationInitializer */ @HandlesTypes(WebApplicationInitializer.class) public class SpringServletContainerInitializer implements ServletContainerInitializer { /** * Delegate the {@code ServletContext} to any {@link WebApplicationInitializer} * implementations present on the application classpath. *
Because this class declares @{@code HandlesTypes(WebApplicationInitializer.class)}, * Servlet 3.0+ containers will automatically scan the classpath for implementations * of Spring's {@code WebApplicationInitializer} interface and provide the set of all * such types to the {@code webAppInitializerClasses} parameter of this method. *
If no {@code WebApplicationInitializer} implementations are found on the classpath, * this method is effectively a no-op. An INFO-level log message will be issued notifying * the user that the {@code ServletContainerInitializer} has indeed been invoked but that * no {@code WebApplicationInitializer} implementations were found. *
Assuming that one or more {@code WebApplicationInitializer} types are detected,
* they will be instantiated (and sorted if the @{@link
* org.springframework.core.annotation.Order @Order} annotation is present or
* the {@link org.springframework.core.Ordered Ordered} interface has been
* implemented). Then the {@link WebApplicationInitializer#onStartup(ServletContext)}
* method will be invoked on each instance, delegating the {@code ServletContext} such
* that each instance may register and configure servlets such as Spring's
* {@code DispatcherServlet}, listeners such as Spring's {@code ContextLoaderListener},
* or any other Servlet API componentry such as filters.
* @param webAppInitializerClasses all implementations of
* {@link WebApplicationInitializer} found on the application classpath
* @param servletContext the servlet context to be initialized
* @see WebApplicationInitializer#onStartup(ServletContext)
* @see AnnotationAwareOrderComparator
*/
public void onStartup(@Nullable Set All ServletContextListeners are notified of context
* initialization before any filters or servlets in the web
* application are initialized.
*
* @param sce the ServletContextEvent containing the ServletContext
* that is being initialized
*
* @implSpec
* The default implementation takes no action.
*/
default public void contextInitialized(ServletContextEvent sce) {}
/**
* Receives notification that the ServletContext is about to be
* shut down.
*
* ......
*/
default public void contextDestroyed(ServletContextEvent sce) {}
}
```
## SpringMVC父子容器的启动过程
### 保存父子容器相关信息
#### SpringServletContainerInitializer#onStartup()
接着在最底下的for循环执行所有实现了WebApplicationInitializer的类的onStartup(),然后就走到了我们的AppStarter
到这一步，ioc容器都没有创建，我们给refresh()打个断点，看什么时候启动的ioc
放行
我看的时候debug断点没有看到从AppStarter的哪一步跳到refresh()的。然后我一步一步走的时候发现不是在这个方法里调用的，注意看下面的图，DispatcherServlet已经new完了，但是debug依然没有跳到refresh()，说明不是在new DispatcherServlet()的时候创建的容器
不过我凭经验猜测Springmvc里最重要的是DispatcherServlet，会不会是DispatcherServlet的那一步启动了IOC，我们开始进行下面的尝试
### Servlet相关
1. tomcat会遵循sun公司的规范给每一个Servlet创建对象
2. 所以DispatcherServlet肯定也会创建对象
3. Servlet的规范
1. Servlet创建对象
2. Servlet调用Init初始化
3. 每次请求调用service处理
4. tomcat停止的时候调用destroy进行销毁
4. Serlvet是被谁调用开始初始化的属于tomcat的源码，我们这里不研究，我们这里只需要知道，每一个Servlet都会被初始化就可以了。
### DispatcherServlet
spring-web中有一个叫DispatcherServlet的类，很明显他是一个Servlet，所以tomcat启动的时候就会加载它，加载它的话当然是从父类一层一层加载的
1. 想要启动IOC容器，只可能是创建DispatcherServlet对象或者调用init()的时候来搞。上面我们也看到了，创建DispatcherServlet对象的时候debug调用栈并没有显示跳到了refresh方法，所以显然不是创建对象的时候
2. 那就只有可能是调用init()的时候开始启动的IOC容器
Servlet规范的init我看了下都是空的，从Spring的HttpServletBean才开始有东西，HttpServletBean的父类和接口对于init()都是空实现，下面我们就从HttpServletBean开始分析。
### HttpServletBean#init()
```java
public final void init() throws ServletException {
// Set bean properties from init parameters.
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
if (!pvs.isEmpty()) {
try {
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
initBeanWrapper(bw);
bw.setPropertyValues(pvs, true);
}
catch (BeansException ex) {
if (logger.isErrorEnabled()) {
logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
}
throw ex;
}
}
//模板方法模式。给子类留的喜欢干的事 Let subclasses do whatever initialization they like.
initServletBean();
}
```
### FrameworkServlet#initServletBean()
```java
/** 追踪看web应用启动做了什么。
* Overridden method of {@link HttpServletBean}, invoked after any bean properties
* have been set. Creates this servlet's WebApplicationContext.
*/
@Override
protected final void initServletBean() throws ServletException {
getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'");
if (logger.isInfoEnabled()) {
logger.info("Initializing Servlet '" + getServletName() + "'");
}
long startTime = System.currentTimeMillis();
try {
this.webApplicationContext = initWebApplicationContext(); //初始化WebIOC容器，那我们想一下大概率是在这里启动的IOC容器
initFrameworkServlet(); //这又是留给子类的
}
catch (ServletException | RuntimeException ex) {
logger.error("Context initialization failed", ex);
throw ex;
}
if (logger.isDebugEnabled()) {
String value = this.enableLoggingRequestDetails ?
"shown which may lead to unsafe logging of potentially sensitive data" :
"masked to prevent unsafe logging of potentially sensitive data";
logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails +
"': request parameters and headers will be " + value);
}
if (logger.isInfoEnabled()) {
logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
}
}
```
DispatcherServlet没有重写initFrameworkServlet()
最后得到结论
```java
this.webApplicationContext = initWebApplicationContext(); //初始化WebIOC容器，那我们想一下大概率是在这里启动的IOC容器
```
下面开始具体分析
## 小补充
### XML版如何配置父子容器关系？
#### web.xml
```xml
### AbstractAnnotationConfigDispatcherServletInitializer能更快的整合Spring和SpringMVC
AbstractAnnotationConfigDispatcherServletInitializer能更快的整合Spring和SpringMVC
> 后面的讲解都用这个测试类
#### 测试类
##### QuickAppStarter
```java
/**
* 最快速的整合注解版SpringMVC和Spring的
*/
public class QuickAppStarter extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override //根容器的配置（Spring的配置文件===Spring的配置类）
protected Class[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
@Override //web容器的配置（SpringMVC的配置文件===SpringMVC的配置类）
protected Class[] getServletConfigClasses() {
return new Class[]{SpringMVCConfig.class};
}
@Override //Servlet的映射，DispatcherServlet的映射路径
protected String[] getServletMappings() {
return new String[]{"/"};
}
@Override
protected void customizeRegistration(ServletRegistration.Dynamic registration) {
// super.customizeRegistration(registration);
// registration.addMapping("");//
}
}
```
##### SpringMVCConfig
```java
/**
* SpringMVC只扫描controller组件，可以不指定父容器类，让MVC扫所有。@Component+@RequestMapping就生效了
*/
@ComponentScan(value = "cn.imlql.web", includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class)
}, useDefaultFilters = false)
public class SpringMVCConfig {
//SpringMVC的子容器，能扫描的Spring容器中的组件
}
```
##### SpringConfig
```java
/**
* Spring不扫描controller组件
*/
@ComponentScan(value = "cn.imlql.web",excludeFilters = {
@ComponentScan.Filter(type= FilterType.ANNOTATION,value = Controller.class)
})
public class SpringConfig {
//Spring的父容器
}
```
父子容器隔离，因为有这句话webloc.setParent(springloc)，springmvc这个子容器可以扫描到父容器Spring里面的组件，反之Spring父容器扫描不到springmvc这个子容器的组件。
##### HelloController
```java
//@Controller; 如果有父子容器 @Component，默认是在父容器中，还找不到
//@Component+@RequestMapping
@RestController
public class HelloController {
public HelloController(){
System.out.println("HelloController.....");
}
@Autowired
HelloService helloService;
@GetMapping("/hello") // 所有的xxxMapping都是RequestMapping
public String sayHello(){
String mvc = helloService.say("MVC");
return mvc;
}
}
```
##### HelloService
```java
@Service
public class HelloService {
public HelloService(){
System.out.println("HelloService.....");
}
public String say(String name){
return "Hello,"+name;
}
}
```
```java
public interface ServletContextListener extends EventListener {
/**
* Receives notification that the web application initialization
* process is starting.【翻译：在当前web应用启动以后（Tomcat把web应用加载了以后），调用contextInitialized方法】
*
* 
```java
public void onStartup(@Nullable Set
因为咱们的QuickAppStarter没有onStarup()所以就调用了父类AbstractDispatcherServletInitializer的，没想到AbstractDispatcherServletInitializer也是继续调用父类的
```java
public void onStartup(ServletContext servletContext) throws ServletException {
super.onStartup(servletContext);
registerDispatcherServlet(servletContext);
}
```
#### AbstractContextLoaderInitializer#onStartup()
```java
public abstract class AbstractContextLoaderInitializer implements WebApplicationInitializer {
/** Logger available to subclasses. */
protected final Log logger = LogFactory.getLog(getClass());
@Override //注册ContextLoaderListener；contextInitialized
public void onStartup(ServletContext servletContext) throws ServletException {
registerContextLoaderListener(servletContext);
}
protected void registerContextLoaderListener(ServletContext servletContext) {
WebApplicationContext rootAppContext = createRootApplicationContext(); //创建一个根容器
if (rootAppContext != null) {
ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
listener.setContextInitializers(getRootApplicationContextInitializers());
servletContext.addListener(listener);
}
else {
logger.debug("No ContextLoaderListener registered, as " +
"createRootApplicationContext() did not return an application context");
}
}
}
```
#### AbstractAnnotationConfigDispatcherServletInitializer#createRootApplicationContext()创建Spring-IOC父容器
```java
@Nullable //重写了爷爷类的创建根容器方法
protected WebApplicationContext createRootApplicationContext() {
Class[] configClasses = getRootConfigClasses(); //获取根配置
if (!ObjectUtils.isEmpty(configClasses)) {
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
context.register(configClasses); //创建了一个IOC容器并把配置类注册进来
return context;
}
else {
return null;
}
}
```
getRootConfigClasses()正好是咱们QuickAppStarter这个子类重写的，debug F7进入
#### QuickAppStarter#getRootConfigClasses()拿自定义的配置类
果不其然，调用了QuickAppStarter#getRootConfigClasses()
继续往下走创建Web容器，这是Spring父容器，因为你看它getRootConfigClasses()获取的是父容器配置
然后返回
图片上面写错了。应该改为：**保存了上面创建的Spring-IOC父容器**。Web子容器的创建在下面
#### ContextLoaderListener创建一个监听器准备后续启动容器进行回调
```java
public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
//在当前web应用启动以后（Tomcat把web应用加载了以后），调用contextInitialized方法
public ContextLoaderListener(WebApplicationContext context) {
super(context);
}
/**
* Initialize the root web application context.
*/
@Override
public void contextInitialized(ServletContextEvent event) { //根容器初始化
initWebApplicationContext(event.getServletContext()); //初始化webioc容器
}
}
```
上面是利用Servlet标准
#### 返回到AbstractDispatcherServletInitializer#onStartup()
接着就继续返回
下面才是创建Web子容器（也叫做Servlet容器）
```java
protected void registerDispatcherServlet(ServletContext servletContext) {
String servletName = getServletName();
Assert.hasLength(servletName, "getServletName() must not return null or empty");
WebApplicationContext servletAppContext = createServletApplicationContext(); //创建Servlet容器
Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");
FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());
ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
if (registration == null) {
throw new IllegalStateException("Failed to register servlet with name '" + servletName + "'. " +
"Check if there is another servlet registered under the same name.");
}
registration.setLoadOnStartup(1);
registration.addMapping(getServletMappings()); //根据我们指定的DispatcherServlet的路径进行注册
registration.setAsyncSupported(isAsyncSupported());
Filter[] filters = getServletFilters();
if (!ObjectUtils.isEmpty(filters)) {
for (Filter filter : filters) {
registerServletFilter(servletContext, filter);
}
}
// 这个是留给我们自定义的方法，模板模式
customizeRegistration(registration);
}
```
#### AbstractAnnotationConfigDispatcherServletInitializer#createServletApplicationContext()创建Web子容器(Servelt容器)
```java
protected WebApplicationContext createServletApplicationContext() {
//
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
Class[] configClasses = getServletConfigClasses(); //获取web应用的配置
if (!ObjectUtils.isEmpty(configClasses)) {
context.register(configClasses);
}
return context;
}
```
这里又new了一个容器，和上面那个容器一样都没有初始化。这里也是调用咱们QuickAppStarter重写的方法，因为这里调用的是getServletConfigClasses()，所以很明显这里的容器是Web子容器
然后就一路往回返，走到这里
继续F7进入
这里就是保存咱们上面刚创建的Web子容器，然后再返回
#### 返回到SpringServletContainerInitializer#onStartup()
1. 这里应用就加载完了，接下来干嘛呢？
2. 你往前看看，咱们的Spring容器和Web子容器都是只是创建完了，都还没有初始化，甚至都没有webloc.setParent(springloc)这样产生父子容器的关系
3. 回想下前面讲的，是不是有一个监听器，那你说把容器保存到监听器里，它能是干嘛的？猜想一下不就是应用加载完之后，发送一个什么事件，然后根据这个事件触发监听器初始化两大容器等等。
咱们就把那个监听器的初始化方法打个断点，然后F8放行试试呗
### ContextLoaderListener回调-开始refresh刷新Spring的根容器(父容器)
#### ContextLoaderListener#contextInitialized()
#### 简单看一下Tomcat里的调用源码
然后真的走到了这里。tomcat里的代码位置是乱的，乱的意思就是比如说上面写的是4766行的调用，但实际上那里是个`}`大括号。也不知道是什么问题，所以我们就大致看下tomcat的代码，不细究。
这里的调用还是对的
应该就是类似这样的调用
走的应该是第一个if
大致就是tomcat里的一个监听器基于事件回调的原理，咱们就不深究了。
#### ContextLoader#initWebApplicationContext()
F7进入，这里因为我重新启动了一次，所以你看到根容器是@3661
终于要调用refresh了
这里直接放行到容器refresh完毕看下父容器
父容器只扫描了，springconfig和helloService，我们继续放行看下Web子容器.
### Servlet初始化-进而开始refresh刷新Spring的web子容器
#### HttpServletBean#init()
跳到了这里，为什么会跳到这里呢？记不记得之前我们用DispatcherServlet保存了Web子容器，这里就要调用DispatcherServlet的相关初始化方法
#### FrameworkServlet#initWebApplicationContext()
一路放行
上面父子容器关系形成了，并且父容器已经refresh完毕
```java
protected WebApplicationContext initWebApplicationContext() {
WebApplicationContext rootContext =
WebApplicationContextUtils.getWebApplicationContext(getServletContext()); //父容器
WebApplicationContext wac = null; //先会获取之前的 WebApplicationContext（构建父子容器）
if (this.webApplicationContext != null) {
// A context instance was injected at construction time -> use it
wac = this.webApplicationContext; //当前的web-ioc容器
if (wac instanceof ConfigurableWebApplicationContext) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
if (!cwac.isActive()) {
// The context has not yet been refreshed -> provide services such as
// setting the parent context, setting the application context id, etc
if (cwac.getParent() == null) {
// The context instance was injected without an explicit parent -> set
// the root application context (if any; may be null) as the parent
cwac.setParent(rootContext); //父子容器的体现，
}
configureAndRefreshWebApplicationContext(cwac); //配置并且刷新容器
}
}
}
if (wac == null) {
// No context instance was injected at construction time -> see if one
// has been registered in the servlet context. If one exists, it is assumed
// that the parent context (if any) has already been set and that the
// user has performed any initialization such as setting the context id
wac = findWebApplicationContext();
}
if (wac == null) {
// No context instance is defined for this servlet -> create a local one
wac = createWebApplicationContext(rootContext);
}
if (!this.refreshEventReceived) {
// Either the context is not a ConfigurableApplicationContext with refresh
// support or the context injected at construction time had already been
// refreshed -> trigger initial onRefresh manually here.
synchronized (this.onRefreshMonitor) {
onRefresh(wac);
}
}
if (this.publishContext) {
// Publish the context as a servlet context attribute.
String attrName = getServletContextAttributeName();
getServletContext().setAttribute(attrName, wac);
}
return wac;
}
```
#### FrameworkServlet#createWebApplicationContext()
再次来到Web子容器的刷新
1. 然后我们看到子容器只有它自己的东西
2. 虽然子容器只有controller，但是因为它保存了父容器。所以它是可以拿到HelloService的，也就是我们可以在HelloController里装配HelloService
```java
public class HelloController {
@Autowired
HelloService helloService;
}
```
3. 但是如果想在父容器里装配HelloController就会报错，父容器没有保存子容器。
```java
public class HelloService {
@Autowired
HelloController helloController;
}
```
4. 这样就很好的实现容器隔离，避免Service乱引用Controller
5. 实现父子容器隔离的前提就是前面写的SpringConfig不扫描controller，交给Web子容器
```java
/**
* Spring不扫描controller组件
*/
@ComponentScan(value = "cn.imlql.web",excludeFilters = {
@ComponentScan.Filter(type= FilterType.ANNOTATION,value = Controller.class)
})
public class SpringConfig {
//Spring的父容器
}
```
```java
/**
* SpringMVC只扫描controller组件，可以不指定父容器类，让MVC扫所有。@Component+@RequestMapping就生效了
*/
@ComponentScan(value = "cn.imlql.web", includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class)
}, useDefaultFilters = false)
public class SpringMVCConfig {
//SpringMVC的子容器，能扫描的Spring容器中的组件
}
```
注意找组件的过程是先找自己的容器，自己没有再到父容器里找
> 1. 总的来说Spring父容器和SpringMVC子容器启动过程是来自于tomcat的两个回调
> 2. Serlvet应用启动，监听器回调刷新Spring父容器
> 3. Servlet初始化，回调刷新SpringMVC子容器