先分享一个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
在地址栏上输入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
2）按快捷键Ctrl+Shift+Alt+/，选择1.Registry...
3）勾选 compiler.automake.allow.when.app.running 即可
这个时候修改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;
}