第一个Spring Boot应用

我们新建一个的工程，创建标准的Maven目录结构如下：

其中，在src/main/resources目录下，注意到几个文件：

这是Spring Boot默认的配置文件，它采用格式而不是.properties格式，文件名必须是application.yml而不是其他名称。

YAML格式比key=value格式的.properties文件更易读。比较一下两者的写法：

使用.properties格式：

  1. # application.properties
  3. spring.application.name=${APP_NAME:unnamed}
  5. spring.datasource.url=jdbc:hsqldb:file:testdb
  6. spring.datasource.username=sa
  7. spring.datasource.password=
  8. spring.datasource.dirver-class-name=org.hsqldb.jdbc.JDBCDriver
  10. spring.datasource.hikari.auto-commit=false
  11. spring.datasource.hikari.connection-timeout=3000
  12. spring.datasource.hikari.validation-timeout=3000
  13. spring.datasource.hikari.max-lifetime=60000
  14. spring.datasource.hikari.maximum-pool-size=20
  15. spring.datasource.hikari.minimum-idle=1

使用YAML格式：

  1. # application.yml
  3. spring:
  4.   application:
  5.     name: ${APP_NAME:unnamed}
  6.   datasource:
  7.     url: jdbc:hsqldb:file:testdb
  8.     username: sa
  9.     password:
  10.     dirver-class-name: org.hsqldb.jdbc.JDBCDriver
  11.     hikari:
  12.       auto-commit: false
  13.       connection-timeout: 3000
  14.       validation-timeout: 3000
  15.       max-lifetime: 60000
  16.       maximum-pool-size: 20
  17.       minimum-idle: 1

可见，YAML是一种层级格式，它和.properties很容易互相转换，它的优点是去掉了大量重复的前缀，并且更加易读。

也可以使用application.properties作为配置文件，但不如YAML格式简单。

使用环境变量

在配置文件中，我们经常使用如下的格式对某个key进行配置：

  1. app:
  2.   db:
  3.     host: ${DB_HOST:localhost}
  4.     user: ${DB_USER:root}
  5.     password: ${DB_PASSWORD:password}

这种${DB_HOST:localhost}意思是，首先从环境变量查找DB_HOST，如果环境变量定义了，那么使用环境变量的值，否则，使用默认值localhost。

这使得我们在开发和部署时更加方便，因为开发时无需设定任何环境变量，直接使用默认值即本地数据库，而实际线上运行的时候，只需要传入环境变量即可：

  1. $ DB_HOST=10.0.1.123 DB_USER=prod DB_PASSWORD=xxxx java -jar xxx.jar

这是Spring Boot的logback配置文件名称（也可以使用logback.xml），一个标准的写法如下：

它主要通过<include resource="..." />引入了Spring Boot的一个缺省配置，这样我们就可以引用类似${CONSOLE_LOG_PATTERN}这样的变量。上述配置定义了一个控制台输出和文件输出，可根据需要修改。

static是静态文件目录，templates是模板文件目录，注意它们不再存放在src/main/webapp下，而是直接放到src/main/resources这个classpath目录，因为在Spring Boot中已经不需要专门的webapp目录了。

我们再来看源码目录结构：

  1. src/main/java
  2. └── com
  3.     └── itranswarp
  4.         └── learnjava
  5.             ├── Application.java
  6.             ├── entity
  7.             │   └── User.java
  8.             ├── service
  9.             │   └── UserService.java
  10.             └── web
  11.                 └── UserController.java

在存放源码的src/main/java目录中，Spring Boot对Java包的层级结构有一个要求。注意到我们的根package是com.itranswarp.learnjava，下面还有entity、service、web等子package。Spring Boot要求main()方法所在的启动类必须放到根package下，命名不做要求，这里我们以Application.java命名，它的内容如下：

  1. @SpringBootApplication
  2. public class Application {
  3.     public static void main(String[] args) throws Exception {
  4.         SpringApplication.run(Application.class, args);
  5.     }
  6. }

启动Spring Boot应用程序只需要一行代码加上一个注解@SpringBootApplication，该注解实际上又包含了：

  • @EnableAutoConfiguration
    • @AutoConfigurationPackage
  • @ComponentScan

这样一个注解就相当于启动了自动配置和自动扫描。

我们再观察pom.xml，它的内容如下：

  2.     <parent>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-parent</artifactId>
  5.         <version>2.3.0.RELEASE</version>
  6.     </parent>
  8.     <modelVersion>4.0.0</modelVersion>
  9.     <groupId>com.itranswarp.learnjava</groupId>
  10.     <artifactId>springboot-hello</artifactId>
  11.     <version>1.0-SNAPSHOT</version>
  13.     <properties>
  14.         <maven.compiler.source>11</maven.compiler.source>
  15.         <maven.compiler.target>11</maven.compiler.target>
  16.         <java.version>11</java.version>
  17.         <pebble.version>3.1.2</pebble.version>
  18.     </properties>
  20.     <dependencies>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>org.springframework.boot</groupId>
  28.             <artifactId>spring-boot-starter-jdbc</artifactId>
  29.         </dependency>
  31.         <!-- 集成Pebble View -->
  32.         <dependency>
  33.             <groupId>io.pebbletemplates</groupId>
  34.             <artifactId>pebble-spring-boot-starter</artifactId>
  35.             <version>${pebble.version}</version>
  36.         </dependency>
  38.         <!-- JDBC驱动 -->
  39.         <dependency>
  40.             <groupId>org.hsqldb</groupId>
  41.             <artifactId>hsqldb</artifactId>
  42.         </dependency>
  43.     </dependencies>
  44. </project>

使用Spring Boot时，强烈推荐从spring-boot-starter-parent继承，因为这样就可以引入Spring Boot的预置配置。

紧接着，我们引入了依赖spring-boot-starter-web和spring-boot-starter-jdbc，它们分别引入了Spring MVC相关依赖和Spring JDBC相关依赖，无需指定版本号，因为引入的<parent>内已经指定了，只有我们自己引入的某些第三方jar包需要指定版本号。这里我们引入pebble-spring-boot-starter作为View，以及hsqldb作为嵌入式数据库。hsqldb已在spring-boot-starter-jdbc中预置了版本号2.5.0，因此此处无需指定版本号。

根据pebble-spring-boot-starter的文档，加入如下配置到application.yml：

  1. pebble:
  2.   # 默认为".pebble"，改为"":
  3.   suffix:
  4.   # 开发阶段禁用模板缓存:
  5.   cache: false

对Application稍作改动，添加WebMvcConfigurer这个Bean：

现在就可以直接运行Application，启动后观察Spring Boot的日志：

  2.   .   ____          _            __ _ _
  3.  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
  4. ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
  5.  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  6.   '  |____| .__|_| |_|_| |_\__, | / / / /
  7.  =========|_|==============|___/=/_/_/_/
  8.  :: Spring Boot ::        (v2.3.0.RELEASE)
  9. 2020-06-08 08:47:23.152  INFO 32585 --- [           main] com.itranswarp.learnjava.Application     : Starting Application on xxx with PID 32585 (...)
  10. 2020-06-08 08:47:23.154  INFO 32585 --- [           main] com.itranswarp.learnjava.Application     : No active profile set, falling back to default profiles: default
  11. 2020-06-08 08:47:24.224  INFO 32585 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
  12. 2020-06-08 08:47:24.235  INFO 32585 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
  13. 2020-06-08 08:47:24.235  INFO 32585 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet engine: [Apache Tomcat/9.0.35]
  14. 2020-06-08 08:47:24.309  INFO 32585 --- [           main] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
  15. 2020-06-08 08:47:24.309  INFO 32585 --- [           main] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 1110 ms
  16. 2020-06-08 08:47:24.446  WARN 32585 --- [           main] com.zaxxer.hikari.HikariConfig           : HikariPool-1 - idleTimeout is close to or more than maxLifetime, disabling it.
  17. 2020-06-08 08:47:24.448  INFO 32585 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
  18. 2020-06-08 08:47:24.753  INFO 32585 --- [           main] hsqldb.db.HSQLDB729157DF9B.ENGINE        : checkpointClose start
  20. 2020-06-08 08:47:24.759  INFO 32585 --- [           main] hsqldb.db.HSQLDB729157DF9B.ENGINE        : checkpointClose script done
  21. 2020-06-08 08:47:24.763  INFO 32585 --- [           main] hsqldb.db.HSQLDB729157DF9B.ENGINE        : checkpointClose end
  22. 2020-06-08 08:47:24.767  INFO 32585 --- [           main] com.zaxxer.hikari.pool.PoolBase          : HikariPool-1 - Driver does not support get/set network timeout for connections. (feature not supported)
  23. 2020-06-08 08:47:24.770  INFO 32585 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
  24. 2020-06-08 08:47:24.971  INFO 32585 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
  25. 2020-06-08 08:47:25.130  INFO 32585 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
  26. 2020-06-08 08:47:25.138  INFO 32585 --- [           main] com.itranswarp.learnjava.Application     : Started Application in 2.68 seconds (JVM running for 3.097)

Spring Boot自动启动了嵌入式Tomcat，当看到Started Application in xxx seconds时，Spring Boot应用启动成功。

现在，我们在浏览器输入localhost:8080就可以直接访问页面。那么问题来了：

前面我们定义的数据源、声明式事务、JdbcTemplate在哪创建的？怎么就可以直接注入到自己编写的UserService中呢？

这些自动创建的Bean就是Spring Boot的特色：AutoConfiguration。

  • DataSourceAutoConfiguration：自动创建一个DataSource，其中配置项从application.yml的spring.datasource读取；
  • DataSourceTransactionManagerAutoConfiguration：自动创建了一个基于JDBC的事务管理器；
  • JdbcTemplateAutoConfiguration：自动创建了一个JdbcTemplate。

因此，我们自动得到了一个DataSource、一个DataSourceTransactionManager和一个JdbcTemplate。

类似的，当我们引入spring-boot-starter-web时，自动创建了：

  • ServletWebServerFactoryAutoConfiguration：自动创建一个嵌入式Web服务器，默认是Tomcat；
  • DispatcherServletAutoConfiguration：自动创建一个DispatcherServlet；
  • HttpEncodingAutoConfiguration：自动创建一个CharacterEncodingFilter；
  • WebMvcAutoConfiguration：自动创建若干与MVC相关的Bean。
  • …

引入第三方pebble-spring-boot-starter时，自动创建了：

  • PebbleAutoConfiguration：自动创建了一个PebbleViewResolver。

Spring Boot大量使用XxxAutoConfiguration来使得许多组件被自动化配置并创建，而这些创建过程又大量使用了Spring的Conditional功能。例如，我们观察JdbcTemplateAutoConfiguration，它的代码如下：

  1. @Configuration(proxyBeanMethods = false)
  2. @ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
  3. @ConditionalOnSingleCandidate(DataSource.class)
  4. @AutoConfigureAfter(DataSourceAutoConfiguration.class)
  5. @EnableConfigurationProperties(JdbcProperties.class)
  6. @Import({ JdbcTemplateConfiguration.class, NamedParameterJdbcTemplateConfiguration.class })
  7. public class JdbcTemplateAutoConfiguration {
  8. }

当满足条件：

  • @ConditionalOnClass：在classpath中能找到DataSource和JdbcTemplate；
  • @ConditionalOnSingleCandidate(DataSource.class)：在当前Bean的定义中能找到唯一的DataSource；

该JdbcTemplateAutoConfiguration就会起作用。实际创建由导入的JdbcTemplateConfiguration完成：

  1. @Configuration(proxyBeanMethods = false)
  2. @ConditionalOnMissingBean(JdbcOperations.class)
  3. class JdbcTemplateConfiguration {
  4.     @Bean
  5.     @Primary
  6.     JdbcTemplate jdbcTemplate(DataSource dataSource, JdbcProperties properties) {
  7.         JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
  8.         JdbcProperties.Template template = properties.getTemplate();
  9.         jdbcTemplate.setFetchSize(template.getFetchSize());
  10.         jdbcTemplate.setMaxRows(template.getMaxRows());
  11.         if (template.getQueryTimeout() != null) {
  12.             jdbcTemplate.setQueryTimeout((int) template.getQueryTimeout().getSeconds());
  13.         }
  14.         return jdbcTemplate;
  15.     }
  16. }

创建JdbcTemplate之前，要满足@ConditionalOnMissingBean(JdbcOperations.class)，即不存在JdbcOperations的Bean。

如果我们自己创建了一个JdbcTemplate，例如，在Application中自己写个方法：

  1. @SpringBootApplication
  2. public class Application {
  3.     ...
  4.     @Bean
  5.     JdbcTemplate createJdbcTemplate(@Autowired DataSource dataSource) {
  6.         return new JdbcTemplate(dataSource);
  7.     }
  8. }

那么根据条件@ConditionalOnMissingBean(JdbcOperations.class)，Spring Boot就不会再创建一个重复的JdbcTemplate（因为JdbcOperations是的父类）。

可见，Spring Boot自动装配功能是通过自动扫描+条件装配实现的，这一套机制在默认情况下工作得很好，但是，如果我们要手动控制某个Bean的创建，就需要详细地了解Spring Boot自动创建的原理，很多时候还要跟踪XxxAutoConfiguration，以便设定条件使得某个Bean不会被自动创建。

练习

从下载练习：使用Spring Boot编写hello应用程序 （推荐使用快速下载）

Spring Boot是一个基于Spring提供了开箱即用的一组套件，它可以让我们基于很少的配置和代码快速搭建出一个完整的应用程序。

Spring Boot有非常强大的AutoConfiguration功能，它是通过自动扫描+条件装配实现的。

读后有收获可以支付宝请作者喝咖啡，读后有疑问请加微信群讨论：

第一个Spring Boot应用 - 图1