十一、SpringBoot之使用外置的Servlet容器及启动原理

最新推荐文章于 2023-02-01 16:20:20 发布

代码搬运工

最新推荐文章于 2023-02-01 16:20:20 发布

阅读量189

点赞数

分类专栏： spring boot 文章标签： SpringBoot 使用外置的Servlet容器使用外置的Servlet容器启动原理

spring boot 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、嵌入式和外置Servlet容器对比

嵌入式Servlet容器：应用打成可执行的jar

优点：简单、便携；

缺点：默认不支持JSP、优化定制比较复杂；

外置的Servlet容器：外面安装Tomcat---应用war包的方式打包；

二、使用外置的Servlet容器步骤

1、必须创建一个war项目；（利用idea创建好目录结构）

2、生成web目录和web.xml

3.配置和启动tomcat

4.将嵌入式的Tomcat指定为provided；

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-tomcat</artifactId>
   <scope>provided</scope>
</dependency>

5.必须编写一个SpringBootServletInitializer的子类，并调用configure方法

public class ServletInitializer extends SpringBootServletInitializer {
 
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
       //传入SpringBoot应用的主程序
      return application.sources(SpringBoot04WebJspApplication.class);
   }
 
}

6.启动服务器就可以使用；

访问地址：http://localhost:8899/hello.jsp

controller

@Controller
public class HelloController {
    @GetMapping("/abc")
    public  String hello(Model model){
        model.addAttribute("msg","你好");
        return "success";
    }
}

application.properties

spring.mvc.view.prefix=/WEB-INF/
spring.mvc.view.suffix=.jsp

JSP

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>Hello JSP</h1>
    <a href="abc">abc</a>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>SUCCESS</h1>
    <h3>${msg}</h3>
</body>
</html>

三、外置Servlet启动原理

jar包启动步骤：执行SpringBoot主类的main方法，启动ioc容器，创建嵌入式的Servlet容器；

war包启动步骤：启动服务器，服务器启动SpringBoot应用【SpringBootServletInitializer】，启动ioc容器；

servlet3.0的8.2.4 Shared libraries / runtimes pluggability章节定义了一个规则

1、规则：

1.服务器启动（web应用启动）会创建当前web应用里面每一个jar包里面ServletContainerInitializer实例;
2.ServletContainerInitializer的实现放在jar包的META-INF/services文件夹下，有一个名为javax.servlet.ServletContainerInitializer的文件，内容就是ServletContainerInitializer的实现类的全类名
3.还可以使用@HandlesTypes，在应用启动的时候加载我们感兴趣的类；

2、流程：启动Servlet容器，再启动SpringBoot应用

1.启动Tomcat
2.应用启动ServletContainerInitializer

Spring的web模块里面有这个文件：org.springframework.web.SpringServletContainerInitializer

3.为这些WebApplicationInitializer类型的类创建实例；

@HandlesTypes({WebApplicationInitializer.class})
public class SpringServletContainerInitializer implements ServletContainerInitializer {
    public SpringServletContainerInitializer() {
    }
    
    //SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)
   //标注的所有这个类型的类都传入到onStartup方法的Set<Class<?>>集合里面,
    public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {
        List<WebApplicationInitializer> initializers = new LinkedList();
        Iterator var4;
        if (webAppInitializerClasses != null) {
            var4 = webAppInitializerClasses.iterator();
 
            while(var4.hasNext()) {
                Class<?> waiClass = (Class)var4.next();
                if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                    try {
                     //为这些WebApplicationInitializer类型的类创建实例；  
                     initializers.add((WebApplicationInitializer)ReflectionUtils.accessibleConstructor(waiClass, new Class[0]).newInstance());
                    } catch (Throwable var7) {
                        throw new ServletException("Failed to instantiate WebApplicationInitializer class", var7);
                    }
                }
            }
        }
 
        if (initializers.isEmpty()) {
            servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
        } else {
            servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
            AnnotationAwareOrderComparator.sort(initializers);
            var4 = initializers.iterator();
 
            while(var4.hasNext()) {
                WebApplicationInitializer initializer = (WebApplicationInitializer)var4.next();
                //每一个实例调用自己的onStartup()方法
                initializer.onStartup(servletContext);
            }
 
        }
    }
}

4.每一个WebApplicationInitializer都调用自己的onStartup；

5.相当于我们的SpringBootServletInitializer的类会被创建对象，并执行onStartup方法
6.SpringBootServletInitializer实例执行onStartup的时候会createRootApplicationContext；创建容器

public abstract class SpringBootServletInitializer implements WebApplicationInitializer {
 
    public void onStartup(ServletContext servletContext) throws ServletException {
        this.logger = LogFactory.getLog(this.getClass());
        //createRootApplicationContext；创建容器
        WebApplicationContext rootAppContext = this.createRootApplicationContext(servletContext);
        if (rootAppContext != null) {
            servletContext.addListener(new ContextLoaderListener(rootAppContext) {
                public void contextInitialized(ServletContextEvent event) {
                }
            });
        } else {
            this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not return an application context");
        }
 
    }

protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
        //1、创建SpringApplicationBuilder
        SpringApplicationBuilder builder = this.createSpringApplicationBuilder();
        builder.main(this.getClass());
        ApplicationContext parent = this.getExistingRootWebApplicationContext(servletContext);
        if (parent != null) {
            this.logger.info("Root context already created (using as parent).");
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, (Object)null);
            builder.initializers(new ApplicationContextInitializer[]{new ParentContextApplicationContextInitializer(parent)});
        }
 
        builder.initializers(new ApplicationContextInitializer[]{new ServletContextApplicationContextInitializer(servletContext)});
        builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);
        //调用configure方法，子类重写了这个方法，将SpringBoot的主程序类传入了进来
        builder = this.configure(builder);
        builder.listeners(new ApplicationListener[]{new SpringBootServletInitializer.WebEnvironmentPropertySourceInitializer(servletContext)});
        //使用builder创建一个spring应用
        SpringApplication application = builder.build();
        if (application.getAllSources().isEmpty() && AnnotationUtils.findAnnotation(this.getClass(), Configuration.class) != null) {
            application.addPrimarySources(Collections.singleton(this.getClass()));
        }
 
        Assert.state(!application.getAllSources().isEmpty(), "No SpringApplication sources have been defined. Either override the configure method or add an @Configuration annotation");
        if (this.registerErrorPageFilter) {
            application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
        }
        //启动Spring应用
        return this.run(application);
    }

7.Spring的应用就启动并且创建IOKOC容器

 public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting();
 
        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            Banner printedBanner = this.printBanner(environment);
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //刷新IOC容器
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
 
            listeners.started(context);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }
 
        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }

代码搬运工

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
十一、SpringBoot之使用外置的Servlet容器及启动原理

一、嵌入式和外置Servlet容器对比嵌入式Servlet容器：应用打成可执行的jar优点：简单、便携；缺点：默认不支持JSP、优化定制比较复杂；外置的Servlet容器：外面安装Tomcat---应用war包的方式打包；二、使用外置的Servlet容器步骤1、必须创建一个war项目；（利用idea创建好目录结构）2、生成web目录和web.xml3...
复制链接

扫一扫