Springboot快速上手

分手后的思念是犯贱 2022-05-07 23:38 278阅读 0赞

**基于Springboot 2.0.0.RELEASE 版本**

# **1. System Requirement** #

**1. Java8 or higher**

**2. Spring Framework 5.0.4.RELEASE or higher□**

**3. Maven3.2 or higher**

**4. Servlet Container： Springboot embedded：**

<table style="margin-left:6.25pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#dddddd;vertical-align:top;width:330px;"> name </td> 
 <td style="border-color:#dddddd;vertical-align:top;width:518px;"> Servlet Version </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f7f7f9;border-color:#dddddd;width:330px;"> Tomcat8.5(general) </td> 
 <td style="background-color:#f7f7f9;width:518px;"> 3.1 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#dddddd;vertical-align:top;width:330px;"> Jetty9.4 </td> 
 <td style="vertical-align:top;width:518px;"> 3.1 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f7f7f9;border-color:#dddddd;width:330px;"> Undertow1.4 </td> 
 <td style="background-color:#f7f7f9;width:518px;"> 3.1 </td> 
 </tr> 
 </tbody> 
</table>

同时也支持部署到其它**Servlet3.0+**的容器中

# **2. 从hello world开始** #

1. 创建**maven**项目

2. **springboot**起步依赖

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑parent</artifactId>
 <version>2.0.0.RELEASE</version>
 </parent>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑test</artifactId>
 </dependency>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑maven‑plugin</artifactId>
 </plugin>

3. 构建项目结构

![70][]

4. DemoApplication(启动类)

@SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {  
           SpringApplication.run(DemoApplication.class,args);
        }
    }

5. HelloController

@RestController
 public class HelloController {
 
 @GetMapping("/hello")
 public ResponseEntity<String> hello(){
 return new ResponseEntity<>("hello world", HttpStatus.OK);
 }
 }

# **3. **配置文件 #

同时支持**yml**和**properties**格式配置文件

支持通配符：**application\*.yml**或**application\*.properties** 加载顺序：

**1.**在命令行中传入的参数

**2.SPRING\_APPLICATION\_JSON**中的属性。**SPRING\_APPLICATION\_JSON**是以**JSON**格式配置在系统环境变量中的

**3. j****a****v****a****:****c****om****p****/****e****n****v**中的**J****N****D****I**属性

**4. Java**的系统属性，可以通过**System.getProperties()**获得的内容

**5. **操作系统的环境变量

**6. **通过**random.\***配置的随机属性

***7******. ****位于当前应用****j******a******r****包之外**，**针对不同****\{*** ***p******r******o******ﬁ******l******e******\}****环境的配置文件内容**，**例如****a******pp******li******c******a******t******i******o******n******‑******\{*** ***p******r******o******ﬁ******l******e******\}******.******p******r******o******p******e******r******t******i******e******s****或是****YAML****定义的配置文件*

***8******. ****位于当前应用****j******a******r****包之内**，**针对不同****\{*** ***p******r******o******ﬁ******l******e******\}****环境的配置文件内容**，**例如****a******pp******li******c******a******t******i******o******n******‑******\{*** ***p******r******o******ﬁ******l******e******\}******.******p******r******o******p******e******r******t******i******e******s****或是****YAML****定义的配置文件*

***9. ****位于当前应用****jar****包之外的****application.properties****和****YAML****配置内容*

***10. ****位于当前应用****jar****包之内的****application.properties****和****YAML****配置内容*

**11. @Conﬁguration**注解修改的类中，通过**@PropertySource**注解定义的属性

**12. **应用默认属性，使用**SpringApplication.setDefaultProperties**定义的内容

# **4. **日志 #

**Springboot**默认集成的是**logback**，只会输出到控制台

可以在**application**配置文件中配置输出为日志文件**(**简单配置**)**

如果想进行日志文件切割等复杂配置，可以自定义**logback**配置文件

在**resource**下写入**logback‑spring.xml**文件，即可以被**springboot**加载

# **5. **配置数据库连接池与**ORM**框架 #

**Springboot2.0**以后，默认集成**HikariCP**数据库连接池 引入**druid**连接池和**mybatis**框架

添加依赖：

<dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>druid‑spring‑boot‑starter</artifactId>
 <version>1.1.9</version>
 </dependency>
 <dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis‑spring‑boot‑starter</artifactId>
 <version>1.3.2</version>
 </dependency>
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql‑connector‑java</artifactId>
 </dependency>

配置文件：

spring:

datasource:

url: jdbc:mysql://localhost:3306/toon?useSSL=false

username: root

password: 123456

driver‑class‑name: com.mysql.jdbc.Driver

mybatis:

conﬁg‑location: classpath:mybatis/mybatis‑conﬁg.xml

mapper‑locations: classpath:mapper/\*Mapper.xml

# **6. **事务 #

通过注解**@Transactional**开启事务

可以加在类上，表示整个类的方法都是开启事务的，一般是更细粒度的加在方法**(public    ** 方法**)**上，表示这个方法是开启事务的

**@Transactional**的参数：

<table style="margin-left:6.25pt;"> 
 <tbody> 
 <tr> 
 <td style="border-color:#dddddd;vertical-align:top;width:258px;"> name </td> 
 <td style="border-color:#dddddd;vertical-align:top;width:590px;"> description </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f7f7f9;width:258px;"> &nbsp; readOnly </td> 
 <td style="background-color:#f7f7f9;width:590px;"> 该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读 写，默认值为false。例如：@Transactional(readOnly=true) </td> 
 </tr> 
 </tbody> 
</table>

<table style="margin-left:6.25pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#f7f7f9;border-color:#dddddd;width:126.95pt;"> &nbsp; </td> 
 <td style="background-color:#f7f7f9;width:329.75pt;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="border-color:#dddddd;vertical-align:top;width:126.95pt;"> &nbsp; &nbsp; rollbackFor </td> 
 <td style="vertical-align:top;width:329.75pt;"> 该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如： 指定单一异常类：@Transactional(rollbackFor=RuntimeException.class) 指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class}) </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f7f7f9;border-color:#dddddd;width:126.95pt;"> &nbsp; &nbsp; &nbsp; rollbackForClassName </td> 
 <td style="background-color:#f7f7f9;width:329.75pt;"> 该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。例如： 指定单一异常类名称： @Transactional(rollbackForClassName="RuntimeException") 指定多个异常类名称：@Transactional(rollbackForClassName= {"RuntimeException","Exception"}) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#dddddd;vertical-align:top;width:126.95pt;"> &nbsp; &nbsp; &nbsp; noRollbackFor </td> 
 <td style="vertical-align:top;width:329.75pt;"> 该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚。例如： 指定单一异常类： @Transactional(noRollbackFor=RuntimeException.class) 指定多个异常类：@Transactional(noRollbackFor= {RuntimeException.class, Exception.class}) </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f7f7f9;border-color:#dddddd;width:126.95pt;"> &nbsp; &nbsp; &nbsp; noRollbackForClassName </td> 
 <td style="background-color:#f7f7f9;width:329.75pt;"> 该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。例如： 指定单一异常类名称： @Transactional(noRollbackForClassName="RuntimeException") 指定多个异常类名称： @Transactional(noRollbackForClassName= {"RuntimeException","Exception"}) </td> 
 </tr> 
 <tr> 
 <td style="border-color:#dddddd;vertical-align:top;width:126.95pt;"> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; propagation </td> 
 <td style="vertical-align:top;width:329.75pt;"> 指定事务的传播行为： @Transactional(propagation=Propagation.REQUIRED) ：如果有事务, 那么加 入 事 务 , 没 有 的 话 新 建 一 个 ( 默 认 情 况 下 ) @Transactional(propagation=Propagation.NOT_SUPPORTED) ： 容 器 不 为这个方法开启事务@Transactional(propagation=Propagation.REQUIRES_NEW)&nbsp; ：不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务@Transactional(propagation=Propagation.MANDATORY) ：必须在一个已有的事务中执行,否则抛出异常@Transactional(propagation=Propagation.NEVER) ：必须在一个没有的事务 中 执 行 , 否 则 抛 出 异 常 ( 与 Propagation.MANDATORY 相 反 ) @Transactional(propagation=Propagation.SUPPORTS)&nbsp; ：如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就&nbsp; 不用事务. </td> 
 </tr> 
 <tr> 
 <td style="background-color:#f7f7f9;width:126.95pt;"> &nbsp; &nbsp; &nbsp; &nbsp; isolation </td> 
 <td style="background-color:#f7f7f9;width:329.75pt;"> 该属性用于设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况，通常使用数据库的默认隔离级别即可，基本不需要进行设置 &nbsp; @Transactional(isolation = Isolation.READ_UNCOMMITTED)：读取未提交数据(会出现脏读, 不可重复读) 基本不使用 @Transactional(isolation = Isolation.READ_COMMITTED)：读取已提交数据(会出现不可重复读和幻读) </td> 
 </tr> 
 </tbody> 
</table>

<table style="margin-left:6.25pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#f7f7f9;border-color:#dddddd;width:256px;"> &nbsp; </td> 
 <td style="background-color:#f7f7f9;width:592px;"> @Transactional(isolation = Isolation.REPEATABLE_READ)：可重复读(会出现幻读) @Transactional(isolation = Isolation.SERIALIZABLE)：串行化 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#dddddd;vertical-align:top;width:256px;"> timeout </td> 
 <td style="vertical-align:top;width:592px;"> 该属性用于设置事务的超时秒数，默认值为‑1表示永不超时 </td> 
 </tr> 
 </tbody> 
</table>

# **7. **统一全局异常处理 #

通过注解**@ControllerAdvice**标注一个类为全局异常处理类

通过**@ExceptionHandler**标注一个方法为处理某异常的**handler**方法在方法中，可以自定义返回参数格式和内容

@ControllerAdvice
 public class GlobalExceptionHandler {
 
 @ExceptionHandler({UserInvalidException.class})
 public ResponseEntity<Response> handlerUserValidException(UserInvalidException e){
 return new ResponseEntity<>(new Response(HttpStatus.BAD_REQUEST.value(),e.getMessage()),HttpStatus.BAD_RE
 }
 }

# **8.** 依赖注入 #

**Springboot**使用**JavaConﬁg**的方式将指定的**bean**注入到**IOC**容器中，而不再使用**xml**配置的方式

**JavaConﬁg**方式通过注解**@Conﬁguration**和**@Bean**来实现

任何一个标注了**@Bean**的方法，其返回值将作为一个**bean**定义注册到**Spring**的**IoC**容器，方法名将默认成该**bean**定义 的**id**

可以类比于**spring**中**xml**的：

# **9. **依赖注入**springboot**提供的线程池通 #

过**@EnableAsync**开启异步

通过@Bean将ThreadPoolTaskExecutor注入

@Conﬁguration @EnableAsync
    public class ExecutorConﬁg {
    
        @Bean
        public ThreadPoolTaskExecutor asyncServiceExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();   
            executor.setCorePoolSize(5);
            executor.setMaxPoolSize(10); executor.setQueueCapacity(5000);         
            executor.setThreadNamePreﬁx("async‑service‑");
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());         
            executor.initialize();
            return executor;
        }
    }

# **10. **容器 #

Springboot默认内置Servlet容器Tomcat8.5

![70 1][]

可以通过下面的方式替换为其他的容器**:**

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑web</artifactId>
 <exclusions>
 <exclusion>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑tomcat</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑jetty</artifactId>
 </dependency>

在使用内置容器后，可以直接打包成可以运行的**jar**，引入下面的插件：

<plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑maven‑plugin</artifactId>
 </plugin>

同时也可以打成**war**包，部署到外置的**Servlet**容器中

1. **POM**中增加配置：

<packaging>war</packaging>
 ...
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑web</artifactId>
 <exclusions>
 <exclusion>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑tomcat</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring‑boot‑starter‑tomcat</artifactId>
 </dependency>

2. 增加**ServletInitializer**，将启动类引导注册，外部**Web Application Context**构建时，会添加启动类

public class ServletInitializer extends SpringBootServletInitializer { 
        @Override
        protected SpringApplicationBuilder conﬁgure(SpringApplicationBuilder application) { 
            return application.sources(DemoApplication.class);
        }
    }

# **11. **起步依赖和自动配置 #

启动类注解**@SpringbootApplication**：

**组合注解，相当于三个： @SpringbootConﬁguration @EnableAutoConﬁguration@ComponentScan**

**@SpringbootConﬁguration 相当于@Conﬁguration**

**1. @Conﬁguration**

**JavaConﬁg**的配置方式，被标注的类就被认为是**IoC**容器的配置类进行加载 所以启动类也就是一个**IoC**容器配置类

**2. ComponentScan**

组件扫描配置，将符合要求的组件扫描然后加入**IoC**容器中

可以通过属性**scanBasePackages**来更细粒度的指定扫描范围

默认情况是扫描子包下的组件，所以启动类一般就放在**rootpackage**下

**3. EnableAutoConﬁguration**

通过**@Import**注解，将所有符合自动配置条件的**bean**加载到**IoC**容器中：

**@Import(\{AutoConﬁgurationImportSelector.class\})**

自动配置的关键就是 **AutoConﬁgurationImportSelector**借助于**Spring**的工具类**SpringFactoriesLoader**

**S****pr****i****ng****F****a****c****t****o****r****i****e****s****L****o****a****d****e****r**主要功能就是从指定的配置文件**M****E****T****A****‑****I****N****F****/****s****pr****i****ng****.****f****a****c****t****o****r****i****e****s**加载配置

配合**@EnableAutoConﬁguration**使用的话，它更多是提供一种配置查找的功能支持，即根据

**@EnableAutoConﬁguration的完整类名org.springframework.boot.autoconﬁgure.EnableAutoConﬁguration**

作为查找的**Key,**获取对应的一组**@Conﬁguration**类

![70 2][]

整个过程大致为：

从**c****l****a****ss****p****a****t****h**中搜寻所有的**M****E****T****A****‑****I****N****F****/****s****pr****i****ng****.****f****a****c****t****o****r****i****e****s**配置文件，并将其中

**org.springframework.boot.autoconﬁgure.EnableutoConﬁguration**对应的配置项通过反射实例化为对应的标注了**@Conﬁguration**的**JavaConﬁg**形式的**IoC**容器配置类，然后汇总为一个并加载到**IoC**容器

![70 3][]

**SpringApplication.run()**方法基本过程：

1. 方法中首先要创建一个**SpringApplication**对象实例，然后调用这个创建好的**SpringApplication**的实例方法。在

**SpringApplication**实例初始化的时候，它会提前做：

**    1> **根据**classpath**里面是否存在某个特征类

**    （org.springframework.web.context.ConﬁgurableWebApplicationContext）来决定是否应该创建一个为Web      应用使用的ApplicationContext类型**

**    2> **使用**SpringFactoriesLoader**在应用的**classpath**中查找并加载所有可用的**ApplicationContextInitializer**

**    3> **使用**SpringFactoriesLoader**在应用的**classpath**中查找并加载所有可用的**ApplicationListener**

**    4> **推断并设置**main**方法的定义类

2. **SpringApplication**实例初始化完成并且完成设置后，执行**run**方法的逻辑，首先遍历执行所有通过

**SpringFactoriesLoader**可以查找到并加载的**SpringApplicationRunListener**。调用它们的**started()**方法，相当于通知它们**Springboot**要准备开始启动了

3. 创建并配置当前**Spring Boot**应用将要使用的**Environment**（包括配置要使用的**PropertySource**以及**Proﬁle**）

4. 遍历调用所有**SpringApplicationRunListener**的**environmentPrepared()**的方法，通知它们**Springboot**的**Enviroment**已经准备好了

5. 如果**SpringApplication**的**showBanner**属性被设置为**true**，则打印**banner**

6. 根据用户是否明确设置了**applicationContextClass**类型以及初始化阶段的推断结果，决定该为当前**SpringBoot**应用创建什么类型的**ApplicationContext**并创建完成，然后根据条件决定是否添加**ShutdownHook**，决定是否使用自定义的**BeanNameGenerator**，决定是否使用自定义的**ResourceLoader**；最重要的是将之前准备好的**Environment**设      置给创建好的**ApplicationContext**使用。

7. **ApplicationContext**创建好之后，**SpringApplication**会再次借助**SpringFactoriesLoader**，查找并加载**classpath**中所有可用的**ApplicationContext‑Initializer**，然后遍历调用这些**ApplicationContextInitializer**的**initialize**（**applicationContext**）方法来对已经创建好的**ApplicationContext**进行进一步的处理

**8. 遍历调用所有SpringApplicationRunListener的contextPrepared()方法**

*9. **整个启动中最关键的步骤**：**将之前通过****@EnableAutoConﬁguration****获取的所有配置以及其他形式的****IoC****容器配置加**载到已经准备完毕的****ApplicationContext***

10.  遍历调用所有**SpringApplicationRunListener**的**contextLoaded()**方法

11. 调用**ApplicationContext**的**refresh()**方法，完成**IoC**容器可用的最后一道工序

12. 查找当前**ApplicationContext**中是否注册有**CommandLineRunner**，如果有，则遍历执行

13. 正常情况下，遍历执行**SpringApplicationRunListener**的**ﬁnished()**方法，如果整个过程出现异常，则依然调用所       有**SpringApplicationRunListener**的**ﬁnished()**方法，只不过这种情况下会将异常信息一并传入处理

说明：官方文档永远是最好的入门教程。

--------------------

如果您觉得博主写的文章对您有帮助，可以请博主喝杯茶哦，O(∩\_∩)O~

![70 4][]

博主：[诸葛本不亮][Link 1]

简介：毕业后做过多年程序猿、架构设计、项目经理、部门总监，待过传统软件公司，也在大型互联网公司负责过平台研发部，在这个行业浸淫十多年，在系统架构、SaaS平台搭建、项目管理以及部门管理等方面有着多年的一线实践经验。

目前与好友合伙创办了一个软件工作室，提供各类系统解决方案、咨询服务及技术合作，企业软件（SaaS平台、企业应用、商城、微信公众号及小程序开发）定制开发服务，大数据服务（数据采集及清洗、数据分析等），以及程序猿职业规划及转型咨询服务（程序猿转架构师、转项目管理、转技术管理等，可以提供相应的一线资料帮助您成功转型，获得大厂offer）。

微信号：danwang2138

![70 5][]

[70]: /images/20220508/20372328843c4509b741efdf6128df4d.png
[70 1]: /images/20220508/4cc2060a355c461d99bae186deb431fc.png
[70 2]: /images/20220508/4af048ab08dd433c8e0eebf9a1449c37.png
[70 3]: /images/20220508/eddc7ac360784fde9696bad875347e68.png
[70 4]: /images/20220508/8d0f5a18411642e7b9b846e217041b2b.png
[Link 1]: https://blog.csdn.net/david_pfw
[70 5]: /images/20220508/9912e77454644d71b7f2111974728bbe.png