springBoot从入门到源码分析

时间:2023-03-08 16:19:41

先分享一个springBoot搭建学习项目,和springboot多数据源项目的传送门:https://github.com/1057234721/springBoot

1. SpringBoot快速入门

该项目分为几个模块:

1,集成了mybatis。

2,事务支持

3,全局异常处理

4,静态资源访问。

静态资源:js, css, html, 图片,音视频等

静态资源路径:是指系统可以直接访问的路径,且路径下的所有文件均可被用户直接读取。

Spring Boot默认提供静态资源目录位置需置于classpath下,目录名需符合如下规则:

/static

/public

/resources

/META-INF/resources

在resources目录下面建立static文件夹,在文件夹里面任意放张图片。

命名为:enjoy.jpg

springBoot从入门到源码分析

在地址栏上输入localhost:8080/enjoy.jpg,可以看到图片

5,jsp集成

一般来说springboot不建议直接使用jsp页面,但不排除有些公司的项目依然使用jsp做前端界面。

springboot内置的tomcat并没有集成对jsp的支持,也没有对EL表达式的支持,因此要使用jsp应该先把相关的依赖集成进来

在pom文件里面新增

<!--JavaServer Pages Standard Tag Library,JSP标准标签库-->

<dependency>

<groupId>javax.servlet</groupId>

<artifactId>jstl</artifactId>

</dependency>

<!--内置tocat对Jsp支持的依赖,用于编译Jsp-->

<dependency>

<groupId>org.apache.tomcat.embed</groupId>

<artifactId>tomcat-embed-jasper</artifactId>

</dependency>

由于要springmvc解析jsp,要配置试图解析器,在applicaiton.properties 里面新增

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

spring.mvc.view.suffix=.jsp

在resources里面新建WEB-INF文件夹,在里面放一个index.jsp页面

最后新建一个controller,注意这里的注解是@Controller,千万不能用@RestController

在浏览器上输入:localhost:8080/jsp/hi,可以看到JSP页面。

6, 模板引擎

SpringBoot 推荐使用模板引擎来渲染html,如果你不是历史遗留项目,一定不要使用JSP,常用的模板引擎很多,有freemark,thymeleaf等,其实都大同小异

其中springboot 强烈推荐的是用thymeleaf

pom文件种添加thymeleaf的支持,并且删除JSP的支持

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-thymeleaf</artifactId>

</dependency>

<!--<!–JavaServer Pages Standard Tag Library,JSP标准标签库–>-->

<!--<dependency>-->

<!--<groupId>javax.servlet</groupId>-->

<!--<artifactId>jstl</artifactId>-->

<!--</dependency>-->

<!--<!–内置tocat对Jsp支持的依赖,用于编译Jsp–>-->

<!--<dependency>-->

<!--<groupId>org.apache.tomcat.embed</groupId>-->

<!--<artifactId>tomcat-embed-jasper</artifactId>-->

<!--</dependency>-->

删除application.properties文件里面视图解析器内容

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

#spring.mvc.view.suffix=.jsp

Springboot默认的模板配置路径为:src/main/resources/templates

在resources目录里面新建一个templates目录,在目录里面新建testThymeleaf.html文件

在浏览器上输入:localhost:8080/tpl/testThymeleaf,可以看到页面。

7,集成swagger2构建api文档

Swagger2 的作用

l随项目自动生成强大RESTful API文档,减少工作量

lAPI文档与代码整合在一起,便于同步更新API说明

页面测试功能来调试每个RESTful API

访问:http://localhost:8080/swagger-ui.html

8,集成日志

java有许多的日志组件,比如 log4j,log4j2,logback还有java自生提供的Java Util Logging,其实在springboot中对这些组件都提供了支持,log4j,log4j2和logback都提供相应的组件支持。

Logback

在springboot中默认使用的日志工具是logback,不过在提及具体的日志工具之前要提一个名词,这个名词就是slf4j(Simple Logging Facade For Java)

百度百科解释https://baike.baidu.com/item/slf4j/6408868

slf4j不是具体的日志解决方案,它有点类似于jdbc,使用了门面模式,是一个针对各类日志的抽象实现,既然是抽象的日志实现,在springboot中肯定不需要额外导入。

注意:spring-boot-starter中就提供了对spring-boot-starter-logging的依赖

在spring-boot-starter-logging中可以看到以及集成了slf4j与具体实现logback的默认支持

日志级别:

修改controller 把日志的输出改成logger.debug("这个一个hello日志");这个时候重启,再调用,发现后台并不会有任何输出,这原因是日志级别在作祟

默认情况下,Spring Boot 配置的是INFO 日志级别,也就是会输出INFO级别以上的日志(ERROR, WARN, INFO)。如果需要 Debug 级别的日志。

在 src/main/resources/application.properties 中配置。debug=true 此外,配置 logging.level.* 来具体输出哪些包的日志级别。

例如

logging.level.root=INFO

logging.level.org.springframework.web=DEBUG

logging.level.cn.enjoy.controller=DEBUG

日志文件

一般情况下,springboot日志只会输出到控制台,并不会写入到日志文件,但是,在一些正式环境的应用中,我们需要通过在 application.properites 文件中配置 logging.file 文件名称和 logging.path 文件路径,将日志输出到日志文件中。

logging.path = /var/tmp

logging.file = xxx.log

logging.level.root = info

注意:

如果只配置 logging.path,在 /var/tmp文件夹生成一个日志文件为 spring.log。如果只配置 logging.file,会在项目的当前路径下生成一个 xxx.log 日志文件

log4j2

在spring-boot-dependencies POMs中搜索spring-boot-starter-log4j2

发现Spring boot父Pom中自己提供了这个依赖,于是我们加入如下jar依赖:

修改pom.xml文件

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

<exclusions>

<exclusion>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-logging</artifactId>

</exclusion>

</exclusions>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-log4j2</artifactId>

</dependency>

注意: 由于默认使用logback在扩展log4j2之前先要把logback移除

日志使用跟上面logback一样。

使用AOP统一日志处理

为了防止在工作中经常在代码中加入大量的日志处理代码,在实际项目开发中,一般使用AOP统一完成日志处理工作。

9,springBoot热加载部署

热部署不会用在生产环境,但对于程序员开发的效率,还是有一定帮助的,所谓的热部署,就是在应用程序在不停止的情况下,实现新的部署

spring-boot-devtools 是一个为开发者服务的一个模块,其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现代码有更改之后,重新启动应用,但是速度比手动停止后再启动还要更快,更快指的不是节省出来的手工操作的时间。

其深层原理是使用了两个ClassLoader,一个Classloader加载那些不会改变的类(第三方Jar包),另一个ClassLoader加载会更改的类,称为  restart ClassLoader

,这样在有代码更改的时候,原来的restart ClassLoader 被丢弃,重新创建一个restart ClassLoader,由于需要加载的类相比较少,所以实现了较快的重启时间

修改pom文件,增加

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

</dependency>

修改properties文件

如果使用的  Thymeleaf  模板,那么请直接在application.properties中添加

spring.thymeleaf.cache=false

如果使用的 FreeMarker 模板,那么请直接在application.properties中添加

spring.freemarker.cache=false

idea中使用

如果你是使用eclipse,请忽略,但如果你是使用IDEA,由于idea 没有保存修改的,也就是说在idea中并不会因为你ctrl+s 就重新编译代码。

那么就需要额外的配置

在pom文件中,增加编译插件,让代码有变动的时候也编译

<build>

<plugins>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

<configuration>

<!-- 如果不设置fork,那么不会restart,devtools热部署不会起作用-->

<fork>true</fork>

</configuration>

</plugin>

</plugins>

</build>

1、手动:修改完代码,按快捷键Ctrl+F9,手动构建项目,或者只修改单个类文件的话,按Ctrl+Shift+F9,重新编译该类文件,即可触发重启服务。

2、自动

1)File -> Settings -> Compiler,勾选 Build Project automatically

springBoot从入门到源码分析

2)按快捷键Ctrl+Shift+Alt+/,选择1.Registry...

springBoot从入门到源码分析

3)勾选 compiler.automake.allow.when.app.running 即可

springBoot从入门到源码分析

这个时候修改JAVA文件或者模板文件都自动会生效

10,编译,打包

快速入门进行到这里,其实已经差不多了,能应对绝大多数开发常见,接下来就是导包部署。

在pom文件中新增

<build>

<plugins>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>

<configuration>

<source>1.8</source>

<target>1.8</target>

</configuration>

</plugin>

<plugin>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

<configuration>

<!-- 如果不设置fork,那么不会restart,devtools热部署不会起作用-->

<fork>true</fork>

</configuration>

<executions>

<execution>

<goals>

<goal>repackage</goal>

</goals>

</execution>

</executions>

</plugin>

</plugins>

</build>

使用mvn clean  package 打包

java –jar 运行

11, war部署

如果并不希望使用内置的tomcat,希望部署到其他tomcat服务器,那么就需要使用war包部署了。

修改pom文件,打包方式改成war

修改在pom文件,剔除内置tomcat的支持,否则会和外面的tomcat冲突

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-tomcat</artifactId>

<!--打包的时候可以不用包进去,别的设施会提供。事实上该依赖理论上可以参与编译,测试,运行等周期。

相当于compile,但是打包阶段做了exclude操作-->

<scope>provided</scope>

</dependency>

修改启动类,使其继承

@SpringBootApplication

@MapperScan("cn.enjoy.dao")

public class App  extends SpringBootServletInitializer  {

public static void main(String[] args) throws Exception {

SpringApplication.run(App.class, args);

}

@Override

protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {

return builder.sources(App.class);

}

}

使用mvn clean  package 打包

把war包拷贝到tomcat webapps中

12,集成redis

13,集成RabbitMq

14,Actuator监控管理

Actuator是spring boot的一个附加功能,可帮助你在应用程序生产环境时监视和管理应用程序。可以使用HTTP的各种请求来监管,审计,收集应用的运行情况.特别对于微服务管理十分有意义

缺点:没有可视化界面(Spring cloud 还会用到这功能,就可以看到界面了)

修改pom文件,添加依赖

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-actuator</artifactId>

</dependency>

修改application.properties文件,启动监控端点

# 加载所有的端点/默认只加载了 info / health

management.endpoints.web.exposure.include=*

# 描述信息

info.blog-url=http://xiangxueketang.cn

info.author=enjoy

info.version=@project.version@

重新启动,在地址栏输入

http://localhost:8080/actuator/info

Actuator访问路径

通过actuator/+端点名就可以获取相应的信息。

路径

作用

/actuator/beans

显示应用程序中所有Spring bean的完整列表。

/actuator/configprops

显示所有配置信息。

/actuator/env

陈列所有的环境变量。

/actuator/mappings

显示所有@RequestMapping的url整理列表。

/actuator/health

显示应用程序运行状况信息 up表示成功 down失败

/actuator/info

查看自定义应用信息

15,多数据源与jta+atomikos分布式事务

2. SpringBoot启动流程分析

创建SpringApplication

public static ConfigurableApplicationContext run(Class<?>[] primarySources,

String[] args) {

return new SpringApplication(primarySources).run(args);

}

其实SpringBoot启动就着两个步骤,先创建ConfigurableApplicationContext ,然后再调用Run方法。

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {

this.resourceLoader = resourceLoader;

Assert.notNull(primarySources, "PrimarySources must not be null");

//保存主类

this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

//判断当前是什么类型项目

this.webApplicationType = WebApplicationType.deduceFromClasspath();

//从类路径下找到META-INF/spring.factories配置的所有ApplicationContextInitializer

setInitializers((Collection) getSpringFactoriesInstances(

ApplicationContextInitializer.class));

//从类路径下找到META-INF/spring.factories配置的所有ApplicationListener

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

this.mainApplicationClass = deduceMainApplicationClass();

}

可见着一步非常简单,只是把一些相关的类都加载了而已,并没执行。

Run方法

真的重要是run方法

public ConfigurableApplicationContext run(String... args) {

StopWatch stopWatch = new StopWatch();

stopWatch.start();

ConfigurableApplicationContext context = null;

Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();

configureHeadlessProperty();

//从类路径下META‐INF/spring.factories,取得SpringApplicationRunListeners;

SpringApplicationRunListeners listeners = getRunListeners(args);

//回调所有的获取SpringApplicationRunListener.starting()方法

listeners.starting();

try {

//封装命令行参数

ApplicationArguments applicationArguments = new DefaultApplicationArguments(

args);

//准备环境

ConfigurableEnvironment environment = prepareEnvironment(listeners,

applicationArguments);

configureIgnoreBeanInfo(environment);

//创回调SpringApplicationRunListener.environmentPrepared();

//表示环境准备完成

//打印Banner

Banner printedBanner = printBanner(environment);

//根据环境创建context

context = createApplicationContext();

//错误的异常报表

exceptionReporters = getSpringFactoriesInstances(

SpringBootExceptionReporter.class,

new Class[] { ConfigurableApplicationContext.class }, context);

//准备上下文环境;

//将environment保存到ioc中;

//applyInitializers()调用所有的ApplicationContextInitializer的initialize方法

//调用所有的SpringApplicationRunListener的contextPrepared();

prepareContext(context, environment, listeners, applicationArguments,

printedBanner);

//SpringApplicationRunListener的contextLoaded

//刷新容器

//扫描,创建,加载所有组件;

refreshContext(context);

afterRefresh(context, applicationArguments);

stopWatch.stop();

if (this.logStartupInfo) {

new StartupInfoLogger(this.mainApplicationClass)

.logStarted(getApplicationLog(), stopWatch);

}

//所有的SpringApplicationRunListener回调started方法

listeners.started(context);

//获取所有的ApplicationRunner和CommandLineRunner进行调用

callRunners(context, applicationArguments);

}

catch (Throwable ex) {

handleRunFailure(context, ex, exceptionReporters, listeners);

throw new IllegalStateException(ex);

}

try {

//所有的SpringApplicationRunListener的running();

listeners.running(context);

}

catch (Throwable ex) {

handleRunFailure(context, ex, exceptionReporters, null);

throw new IllegalStateException(ex);

}

return context;

}