IDE:IntelliJ IDEA 2019.2.4 x64
操作系统:win10 x64 位 家庭版
Maven版本:apache-maven-3.6.3
看一段正常的springboot启动类
代码如下所示
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ServiceCmnApplication {
public static void main(String[] args) {
SpringApplication.run(ServiceCmnApplication.class, args);
}
}
首先准备两个模块
① FcSpringApplication类代码如下所示
package org.springboot;
import org.apache.catalina.*;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardEngine;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.startup.Tomcat;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
public class FcSpringApplication {
//自定义run方法
public static void run(Class clazz) {
//1.启动tomcat
startTomcat();
}
//对Tomcat进行属性配置
private static void startTomcat() {
Tomcat tomcat = new Tomcat();
Server server = tomcat.getServer();
Service service = server.findService("Tomcat");
Connector connector = new Connector();
connector.setPort(8081);
Engine engine = new StandardEngine();
engine.setDefaultHost("localhost");
Host host = new StandardHost();
host.setName("localhost");
String contextPath = "";
Context context = new StandardContext();
context.setPath(contextPath);
context.addLifecycleListener(new Tomcat.FixContextListener());
host.addChild(context);
engine.addChild(host);
service.setContainer(engine);
service.addConnector(connector);
try {
tomcat.start();
} catch (LifecycleException e) {
e.printStackTrace();
}
}
②自定义注解FcSpringBootApplication代码如下所示
package org.springboot;
public @interface FcSpringBootApplication {
}
①启动类UserApplication代码如下
import org.springboot.FcSpringApplication;
import org.springboot.FcSpringBootApplication;
@FcSpringBootApplication
public class UserApplication {
public static void main(String[] args) {
FcSpringApplication.run(UserApplication.class);
}
}
这里先抛出一个问题
为何要将User模块的启动类作为值传入FcSpringApplication.run()方法中?
在传值之前,有个很重要的前提–需要启动Tomcat服务器
②UserController类代码如下
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@GetMapping("/test")
public String test(){
return "success";
}
}
启动User模块,可以发现
它报错了!!!
为什么会报错?
因为自定义springboot模块没有实现“根据指定请求路径去寻找controller中对应的请求方法并返回结果”的功能,而这一功能正好是springmvc技术。故而我们只需在自定义springboot模块里的run()中整合springmvc技术即可
整合springmvc代码如下所示
tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet(webApplicationContext));
context.addServletMappingDecoded("/*", "dispatcher");
复制上述代码到run方法中
代码爆红了
通过查阅追踪SpringMvc中new DispatcherServlet()中的源码可知
public DispatcherServlet(WebApplicationContext webApplicationContext) {
super(webApplicationContext);
this.setDispatchOptionsRequest(true);
}
发现
它需要一个WebApplicationContext类型的对象,而这个WebApplicationContext类型是一个接口,它继承于ApplicationContext接口,而这个ApplicationContext接口实际上就是Spring容器。
从这就不难猜到,DispatcherServlet需要从一个spring容器中去找请求路径相映射的处理方法并返回结果
结论
tomcat需要从传入的spring容器中去找UserController所对应的bean,进而找到对应请求路径映射的方法test
优化后整体代码示例如下
import org.apache.catalina.*;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardEngine;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.startup.Tomcat;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
public class FcSpringApplication {
public static void run(Class clazz) {
//启动Tomcat之前,需要创建spring容器(找到UserController这个Bean)
AnnotationConfigWebApplicationContext webApplicationContext = new AnnotationConfigWebApplicationContext(); //通过注解形式配置spring容器
//启动tomcat
startTomcat(webApplicationContext);
}
//对Tomcat进行属性配置
private static void startTomcat(WebApplicationContext webApplicationContext) {
Tomcat tomcat = new Tomcat();
Server server = tomcat.getServer();
Service service = server.findService("Tomcat");
Connector connector = new Connector();
connector.setPort(8081);
Engine engine = new StandardEngine();
engine.setDefaultHost("localhost");
Host host = new StandardHost();
host.setName("localhost");
String contextPath = "";
Context context = new StandardContext();
context.setPath(contextPath);
context.addLifecycleListener(new Tomcat.FixContextListener());
host.addChild(context);
engine.addChild(host);
service.setContainer(engine);
service.addConnector(connector);
tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet(webApplicationContext));
context.addServletMappingDecoded("/*", "dispatcher");
try {
tomcat.start();
} catch (LifecycleException e) {
e.printStackTrace();
}
}
}
①运行User模块
它还是显示这个报错界面!!!
分析
上述界面表明Tomcat服务器已经接收到了请求,但它找不到对应相映射的请求方法并返回结果
疑问
DispatcherServlet明明已经整合进了Tomcat里,为何tomcat还是找不到?
原因
虽然启动Tomcat服务器之前已经构建好了一个Spring容器,但是这个spring容器此时是一个空的容器,它里面没有包含"/test"相映射的请求方法的bean
[UserController],没有bean,自然无从查起。
遂优化代码,如下所示
①在自定义SpringBoot模块中run方法里添加如下代码
public static void run(Class clazz) {
//启动Tomcat之前,需要创建spring容器(找到UserController这个Bean)
AnnotationConfigWebApplicationContext webApplicationContext = new AnnotationConfigWebApplicationContext(); //通过注解形式配置spring容器
//将传入的类注册为spring容器的配置类
webApplicationContext.register(clazz);
//刷新spring容器
webApplicationContext.refresh();
//一旦刷新spring容器,便开始解析容器 --> 根据@ComponentScan中的包路径下去扫描,就会扫描到UserController这个bean,如果不写路径,默认扫描传入类的所在的包路径
//启动tomcat
startTomcat(webApplicationContext);
}
释义
上述代码是将传入的类作为配置类在Spring容器中注册,当执行 webApplicationContext.register(clazz);webApplicationContext.refresh()时,就会刷新并解析spring容器,根据传入的配置类上方的“@ComponentScan(“com.fc.user”) ”注解,便会去扫描【com.fc.user】该包路径下的bean【UserController】,进而找到与"/test"相映射的请求方法,最终将返回方法的结果给前端页面
这里便回答了1.2中抛出的问题!!!
②在User模块中启动类上加上@ComponentScan(“com.fc.user”) – 扫描该包下所有的bean
import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@ComponentScan("com.fc,user")
public class UserController {
@GetMapping("/test")
public String test(){
return "success";
}
}
运行
总结
大致的执行流程就是用户在浏览器上发出的请求被tomcat服务器所接收,tomcat服务器便将请求交由Dispatcherservlet,Dispatcherservlet便会根据“/test"去Spring容器中去找UserController这个bean,在这个bean中去寻找“/test"相映射的执行方法,最后返回”success“给用户。
上述代码虽然实现了SpringBoot框架的基本功能,但也有很多不足
User模块中的启动类上不必再写上@ComponentScan,在自定义注解@FcSpringBootApplication中可以集成它
对比
- 且看如下真正的SpringBoot里@SpringBoot注解写法
- 自己写的User模块启动类
import org.springboot.FcSpringApplication;
import org.springboot.FcSpringBootApplication;
@FcSpringBootApplication
@ComponentScan("com.fc.user")
public class UserApplication {
public static void main(String[] args) {
FcSpringApplication.run(UserApplication.class);
}
}
改进优化代码如下所示
①User模块中的启动类上不再写上注解@ComponentScan()
@FcSpringBootApplication
public class UserApplication {
public static void main(String[] args) {
FcSpringApplication.run(UserApplication.class);
}
}
②在自定义注解@FcSpringBootApplication中可以集成@ComponentScan()
import org.springframework.context.annotation.ComponentScan;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@ComponentScan
public @interface FcSpringBootApplication {
}
释义
Target(ElementType.TYPE)
和 @Retention(RetentionPolicy.RUNTIME)
是两个常用的注解属性。
@Target(ElementType.TYPE)
: 这个属性表示该注解可以用于类、接口(包括注解类型本身)、枚举声明以及注解类型的成员变量和方法,但不包括类的成员方法。换句话说,这个注解只能用于代码级别的注解,不能用于元注解(即注解的注解)。@Retention(RetentionPolicy.RUNTIME)
: 这个属性表示该注解在运行时仍然有效。RetentionPolicy
是一个枚举类型,它有四个值:SOURCE
(注解只在源码中保留,编译时会被丢弃),CLASS
(注解在源码和字节码中都保留,运行时可以通过反射获取到),RUNTIME
(注解在源码和字节码中都保留,运行时可以通过反射获取到,且可以通过动态代理等方式使用),PROTECTED
(注解只在源码中保留,通过反射可以访问,但是不能通过动态代理等方式使用)。运行
注意
如果@ComponentScan中没有写明扫描路径,Spring会默认解析扫描传入run方法中的那个类【配置类】所在的包路径,尽管我们在日常开发中习惯将启动类作为配置类传入run()中,但配置类不一定是启动类,因为我们完全可以再定义一个类作为配置类传入run()中,效果等同
不信?请看如下所示
案例:在User模块中自定义配置类MyApplocation并传入run()中,演示其效果
①定义自定义配置类MyApplocation
import org.springboot.FcSpringBootApplication;
@FcSpringBootApplication
public class MyApplication {
}
②将MyApplocation传入run()中
import com.fc.user.controller.MyApplication;
import org.springboot.FcSpringApplication;
import org.springboot.FcSpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
@FcSpringBootApplication
public class UserApplication {
public static void main(String[] args) {
FcSpringApplication.run(MyApplication.class);
}
}
运行
自定义SpringBoot模块中只能运行Tomcat服务器,不能运行Jetty服务器,扩展性较差;而Spring Boot支持三种内嵌式服务器:Tomcat、Jetty和Undertow。其中,Tomcat是Spring Boot中默认的内嵌服务器,但是开发者可以在application.properties文件中更改它。如果想使用其他服务器,可以在pom.xml文件中添加相应的依赖项,然后在application.properties文件中配置它。
优化版1.0
可通过定义Bean的方式来决定Tomcat或jetty的使用
代码示例如下
1.在自定义SpringBoot模块中使用 webServer.start()以启动服务器
import org.apache.catalina.*;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardEngine;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.startup.Tomcat;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
import java.util.Map;
public class FcSpringApplication {
public static void run(Class clazz){
//启动Tomcat之前,需要创建spring容器(找到UserController这个Bean)
AnnotationConfigWebApplicationContext annotationConfigWebApplicationContext = new AnnotationConfigWebApplicationContext(); //通过注解形式配置spring容器
//将传入的类注册为spring容器的配置类
annotationConfigWebApplicationContext.register(clazz);
//刷新spring容器
annotationConfigWebApplicationContext.refresh();
//一旦刷新spring容器,便开始解析容器 --> 根据@ComponentScan中的包路径下去扫描,如果不写路径,默认扫描传入类的所在的包路径
//启动Tomcat
//startTomcat(annotationConfigWebApplicationContext);
//以上写法写死了嵌定Tomcat容器,过于单元,但是真正的springboot中内嵌支持不止一种容器,有Tomcat,jetty和Undertow
WebServer webServer = getWebServer(annotationConfigWebApplicationContext);
webServer.start();
}
private static WebServer getWebServer(WebApplicationContext webApplicationContext) {
//在spring容器中去找容器对应的bean,有且只有一个容器【Tomcat/Jetty】可以使用
//key为beanName,value为Bean对象
Map<String, WebServer> webServers = webApplicationContext.getBeansOfType(WebServer.class);
if (webServers.isEmpty()){
throw new NullPointerException();
}
if (webServers.size()>1){
throw new IllegalStateException();
}
return webServers.values().stream().findFirst().get();
}
2.定义接口WebServer,接口WebServer的实现类TomcatWebServer与JettyWebServer
//接口WebServer
import org.springframework.web.context.WebApplicationContext;
public interface WebServer {
void start(WebApplicationContext webApplicationContext);
}
//接口WebServer的实现类TomcatWebServer
import org.apache.catalina.*;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardEngine;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.startup.Tomcat;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
public class TomcatWebServer implements WebServer {
@Override
//对Tomcat进行属性配置
public void start(WebApplicationContext webApplicationContext) {
System.out.println("开启Tomcat");
Tomcat tomcat = new Tomcat();
Server server = tomcat.getServer();
Service service = server.findService("Tomcat");
Connector connector = new Connector();
connector.setPort(8081);
Engine engine = new StandardEngine();
engine.setDefaultHost("localhost");
Host host = new StandardHost();
host.setName("localhost");
String contextPath = "";
Context context = new StandardContext();
context.setPath(contextPath);
context.addLifecycleListener(new Tomcat.FixContextListener());
host.addChild(context);
engine.addChild(host);
service.setContainer(engine);
service.addConnector(connector);
tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet(webApplicationContext));
context.addServletMappingDecoded("/*", "dispatcher");
try {
tomcat.start();
} catch (LifecycleException e) {
e.printStackTrace();
}
}
}
//接口WebServer的实现类JettyWebServer
import org.apache.catalina.*;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardEngine;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.startup.Tomcat;
import org.eclipse.jetty.util.Jetty;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
public class JettyWebServer implements WebServer {
@Override
public void start(WebApplicationContext webApplicationContext) {
System.out.println("启动Jetty");
}
}
3.在User模块中启动类上定义TomcatWebserver的bean
import com.fc.user.controller.MyApplication;
import org.springboot.FcSpringApplication;
import org.springboot.FcSpringBootApplication;
import org.springboot.TomcatWebServer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
@FcSpringBootApplication
public class UserApplication {
@Bean
public TomcatWebServer tomcatWebServer(){
return new TomcatWebServer();
}
public static void main(String[] args) {
FcSpringApplication.run(UserApplication.class);
}
}
运行
这样,就可以通过定义Bean的形式来切换Tomcat或jetty的使用!!!
优化版2.0
可通过pom文件定义依赖的方式来决定Tomcat或jetty的使用,且默认使用Tomcat
代码示例如下
1.在自定义SpringBoot模块中定义一个SpringBoot自动装配的配置类
@Configuration
public class WebServerAutoConfiguration {
@Bean
//如果pom文件中存在jetty的依赖,便产生这个bean
@Conditional(JettyCondition.class)
public JettyWebServer jettyWebServer(){
return new JettyWebServer();
}
@Bean
@Conditional(TomcatCondition.class) //只有满足类中的条件,才能产生bean
public TomcatWebServer tomcatWebServer(){
return new TomcatWebServer();
}
}
2.定义JettyCondition类与TomcatCondition类,以设置产生bean的条件
//定义TomcatCondition类
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class TomcatCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
try {
context.getClassLoader().loadClass("org.apache.catalina.startup.Tomcat");
return true;
} catch (ClassNotFoundException e) {
return false;
}
}
}
//--------------------------------------------------------------------------------
//定义JettyCondition类
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class JettyCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//如何判定pom文件中添加了jetty的依赖?如果jetty类存在,说明添加了jetty的依赖
try {
context.getClassLoader().loadClass("org.eclipse.jetty.util.Jetty");
return true;
} catch (Exception e) {
return false;
}
}
}
运行
为什么会触发空指针异常?
原因
因为上述定义的WebServerAutoConfiguration类没有被传入run方法中的容器配置类所扫描到,尽管上述类中定义的两个bean都满足条件并产生了。但由于没有被扫描到,两个bean没有被装载到spring容器中,故触发了空指针异常。
解决方案
在所传入run()方法中的容器配置类上导入WebServerAutoConfiguration类,使其可以被扫描到
代码示例如下
@FcSpringBootApplication
//导入WebServerAutoConfiguration类,使其可以被扫描到
@Import(WebServerAutoConfiguration.class)
public class UserApplication {
/*
@Bean
public TomcatWebServer tomcatWebServer(){
return new TomcatWebServer();
}
*/
public static void main(String[] args) {
FcSpringApplication.run(UserApplication.class);
}
}
再次运行
报错了!!!
why?
原因
请看如下两个模块的maven依赖关系图
解决方案
将自定义springboot模块pom文件中jetty的依赖属性option设为true
设置如下所示
<dependency>
<groupId>org.eclipse.jettygroupId>
<artifactId>jetty-serverartifactId>
<version>9.4.48.v20220622version>
<optional>trueoptional>
dependency>
运行测试
这与真正的SpringBoot框架“如果不指定服务器,默认调用Tomcat服务器”的特性相一致
如果想切换jetty服务器,则须在User模块中使用exclusions标签排除tomcat容器的依赖,然后引入jetty的依赖,最后记得刷新maven,重新运行User模块即可。
代码示例如下
<artifactId>userartifactId>
<dependencies>
<dependency>
<groupId>com.fcgroupId>
<artifactId>springbootartifactId>
<version>1.0-SNAPSHOTversion>
<scope>compilescope>
<exclusions>
<exclusion>
<groupId>org.apache.tomcat.embedgroupId>
<artifactId>tomcat-embed-coreartifactId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>org.eclipse.jettygroupId>
<artifactId>jetty-serverartifactId>
<version>9.4.48.v20220622version>
dependency>
dependencies>
运行测试
再看此时如下两个模块的maven依赖关系
上述代码成功排除了tomcat的依赖,而只包含jetty的依赖!!!
打开一个基于SpringBoot的web应用项目的pom文件,如下所示
众所周知,spring-boot-starter-web
是Spring Boot提供的一个依赖,它包含了开发Web应用所需的基本依赖库。使用该依赖可以快速搭建一个基于Spring Boot的Web应用,且无需手动配置大量的依赖库。
该依赖主要包括以下组件:
spring-boot-starter-tomcat
: 内嵌的Tomcat服务器,用于运行Spring Boot Web应用。spring-boot-starter-web
: Spring MVC核心组件,提供了创建Web应用所需的基本功能,如控制器、视图解析器等。spring-boot-starter-data-jpa
: Spring Data JPA支持,简化了数据访问层的开发。spring-boot-starter-security
: Spring Security支持,提供了安全的Web应用开发能力。spring-boot-starter-test
: Spring Test框架支持,简化了单元测试和集成测试的开发。使用Ctrl + 鼠标左键点击追踪进入该文件,可以发现该文件只引入Tomcat容器的依赖,而无jetty的依赖
接着点进spring-boot-starter-tomcat的依赖里,如下所示
可以看到spring-boot-starter-tomcat包含了开发Web应用所需Tomcat的基本依赖库
该依赖主要包括以下组件:
spring-boot-starter-web
: Spring MVC核心组件,提供了创建Web应用所需的基本功能,如控制器、视图解析器等。spring-boot-starter-data-jpa
: Spring Data JPA支持,简化了数据访问层的开发。spring-boot-starter-security
: Spring Security支持,提供了安全的Web应用开发能力。spring-boot-starter-test
: Spring Test框架支持,简化了单元测试和集成测试的开发。综上,因为springboot工程中只嵌入了一个Tomcat,而无jetty;如果想要使用别的容器,例如jetty,可以使用exclusions标签排除tomcat的依赖,并引入jetty的依赖,刷新maven重启项目即可。