目录
1. Spring能做什么？
2. SpringBoot特点
3. 如何学习SpringBoot
4. 创建Spring Boot项目
Maven的配置
入门案例：
SpringBoot中几个重要的注解
5. 了解自动配置原理
依赖管理
自动配置
6. SpringBoot核心配置文件
多环境测试
自定义配置
7. SpringBoot中使用JSP（了解）
8. SpringBoot中使用ApplicationContext（上下文对象）
9. ***mandLineRunner接口 & ApplicationRunner接口
一：Spring Boot 入门
SpringBoot是Spring家族中的一个成员， 可以简化Spring、SpringMVC的使用。它的核心还是IOC容器，底层是Spring！
1. Spring能做什么？
微服务：将项目的工程拆分成一个个微小的功能模块，每一个微小的功能模块就是一个微服务。
- 微服务是一种架构风格；
- 一个应用拆分为一组小型服务；
- 每个服务运行在自己的进程内，也就是可独立部署和升级；
- 服务之间使用轻量级HTTP交互；
- 服务围绕业务功能拆分；
- 可以由全自动部署机制独立部署；
- 去中心化，服务自治。服务可以使用不同的语言、不同的存储技术；
响应式：基于异步非阻塞的方式，应用之间构建一个异步数据流的方式，异步数据流允许占用少量的线程资源，可以构建一个高吞吐量的开发。
分布式、云开发：将项目拆分成很多微小的服务就会产生分布式应用。
分布式的困难：远程调用、服务发现、负载均衡、服务容错、配置管理、服务监控、链路追踪、日志管理、任务调度。
分布式的困难：SpringBoot + SpringCloud。
无服务开发：函数式开发，上到云平台。
事件驱动：构建一个实时的数据流，有了实时数据流就可以通过响应的方式，让系统占用少量的资源，完成高吞吐量的业务。
批处理：自动化任务。
2. SpringBoot特点
特点如下：
①Create stand-alone Spring applications.
解释：创建一个独立spring应用（用SpringBoot实际上还是用spring，SpringBoot是一个高级框架，实际上底层是Spring）。
②Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files).
解释：内嵌Web服务器，如：Tomcat、Jetty或Undertow服务器（无需部署WAR文件）。
③Provide opinionated 'starter' dependencies to simplify your build configuration.
解释：提供了starter起步依赖，简化应用的配置。比如：使用MyBatis框架 ， 需要在Spring项目中，配置MyBatis的对象 SqlSessionFactory ， Dao的代理对象等；现在在SpringBoot项目中，在pom.xml里面, 只需要加入一个 mybatis-spring-boot-starter依赖，就表示上面两个等配置已经配置好了。
④Automatically configure Spring and 3rd party libraries whenever possible.
解释：自动配置Spring以及第三方功能（就是把spring中的，第三方库中的对象都提前创建好，放到容器中， 可以直接使用）。
⑤Provide production-ready features such as metrics, health checks, and externalized configuration
解释：提供生产级别的监控，健康检查及外部化配置（以前修改了代码需要重新打包部署，现在可以实时监控变化）。
⑥Absolutely no code generation and no requirement for XML configuration
解释：不用生成代码， 不用使用xml做配置。
3. 如何学习SpringBoot
SpringBoot的官方文档查找：Spring Boot
SpringBoot的官网架构：
查看版本更新了什么新特性： Home · spring-projects/spring-boot Wiki · GitHub
4. 创建Spring Boot项目
Maven的配置
找到Maven的配置文件的settngs.xml配置，C:\dev\maven_work\apache-maven-3.3.9\conf\settings.xml，配置成阿里云的镜像和JDK编译的版本。
<mirrors>
<mirror>
<id>nexus-aliyun</id>
<mirrorOf>central</mirrorOf>
<name>Nexus aliyun</name>
<url>http://maven.aliyun.***/nexus/content/groups/public</url>
</mirror>
</mirrors>
<profiles>
<profile>
<id>jdk-1.8</id>
<activation>
<activeByDefault>true</activeByDefault>
<jdk>1.8</jdk>
</activation>
<properties>
<maven.***piler.source>1.8</maven.***piler.source>
<maven.***piler.target>1.8</maven.***piler.target>
<maven.***piler.***pilerVersion>1.8</maven.***piler.***pilerVersion>
</properties>
</profile>
</profiles>第一种方式：https://start.spring.io，使用国外的地址，必须联网
①新建项目
②设置基本信息
③选择依赖的列表
④项目的结构
⑤生成的pom.xml配置
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!--SpringBoot项目的父项目-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.0.3</version>
<relativePath/>
</parent>
<!--当前项目的gav坐标-->
<groupId>***.zl</groupId>
<artifactId>study-springboot-002</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>study-springboot-002</name>
<description>study-springboot-002</description>
<!--JDK的版本-->
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--web依赖，版本号就是父的版本号-->
<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>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!--maven的插件-->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
第二种方式：https://start.springboot.io，使用国外的地址，必须联网，创建项目的步骤同上
①对于其他版本的高版本的IDEA是以下界面
②也可以在浏览器上直接输入https://start.springboot.io 进行设置
③选择好以后，点击生成GENERATE，会下载一个压缩包
④解压这个压缩包，就可以把项目导进去
第三种方式：使用 maven 向导创建项目
根据官方文档的提示：Getting Started
①创建一个普通的Maven项目
②手动添加父parent和web的依赖
添加父依赖：spring-boot-start-parent作为【版本仲裁中心】 统一控制导入依赖的版本信息。
web的依赖：spring-boot-start-web用来写web项目的起步依赖。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>***.zl</groupId>
<artifactId>study-springboot-004</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<!--手动添加SpringBoot项目的父项目-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.0.3</version>
<relativePath/>
</parent>
<!--手动添加依赖-->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<properties>
<maven.***piler.source>8</maven.***piler.source>
<maven.***piler.target>8</maven.***piler.target>
</properties>
</project>③手动添加项目缺失的目录
入门案例：
第一步：创建一个SpringBoot的web工程项目
第二步：创建一个Controller，发出请求
注：在使用springmvc框架的时候，在处理json的时候需要用到spring框架特有的注解@ResponseBody或者@RestController注解，这两个注解都会处理返回的数据格式，使用了该类型注解后返回的不再是视图，不会进行转跳，而是返回json或xml数据格式，输出在页面上。
①@ResponseBody注解，一般是使用在单独的方法上的，需要哪个方法返回json数据格式，就在哪个方法上使用，具有针对性。
②@RestController复合注解，一般是使用在类上的，它表示的意思其实就是结合了@Controller和@ResponseBody两个注解，如果哪个类下的所有方法需要返回json数据格式的，就在哪个类上使用该注解，具有统一性；需要注意的是，使用了@RestController注解之后，其本质相当于在该类的所有方法上都统一使用了@ResponseBody注解，所以该类下的所有方法都会返回json数据格式，输出在页面上，而不会再返回视图。
package ***.zl.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
// 以下两个注解写成一个
@RestController
// @Controller // 类要想当做controller使用，就添加这个注解
public class HelloSpringBoot {
@RequestMapping("/hello")
// @ResponseBody // 把返回的String字符串当做数据来用，返回给浏览器
public String helloSpringBoot(){
return "欢迎使用SpringBoot！";
}
}
第三步：启动入口类
（1）这个类是自动生成的，也可以自己创建；使用@SpringBootApplication注解就表明这是一个SpringBoot项目！
（2）在类中编写main方法，方法中只写一行代码，调用SpringApplication类的静态run()方法，表示主方法跑起来：参数一个是当前类的.class、一个是主方法中的参数args。
注：这个类的执行会启动内置的Tomcat服务器！
package ***.zl;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
第四步：进行访问
这里的端口号还可以在application.properties中进行更改
第五步：创建一个可执行的jar包（简化了部署）
默认的打包方式是jar包，对于web应用我们需要写上打包方式为war包，然后部署到Tomcat服务器上进行应用。现在可以通过一个插件直接就打成jar包，进行运行！
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>①找到生命周期进行打包
②得到以下.jar文件
③找到.jar文件的位置，使用cmd命令行执行打包的jar文件
④ 使用java -jar *.jar就可以运行
SpringBoot中几个重要的注解
①@SpringBootApplication注解： @SpringBootApplication注解其实是一个复合注解，是由 @SpringBootConfiguration注解、@EnableAutoConfiguration注解、@***ponentScan 联合在一起组成的；从源码中就可以看出：
②@SpringBootConfiguration注解： 这个注解就是@Configuration这个注解的功能，使用@SpringBootConfiguration这个注解的类就是当做配置文件作用，从源码中就可以看出：
注：既然有@Configuration功能，结合@Bean注解，就可以把一个对象放到Spring容器当中
package ***.zl;
import ***.zl.controller.Student;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
// 声明对象，把这个对象注入到Spring容器当中
@Bean
public Student myStudent(){
return new Student();
}
}
③@EnableAutoConfiguration注解：启用自动配置， 把java对象配置好，注入到spring容器中。例如：可以把mybatis的对象创建好，放入到容器中。
④@***ponentScan注解：组件扫描器， 扫描注解，根据注解的功能，创建java bean，给属性赋值等。组件扫描器默认扫描的包是 @***ponentScan 注解所在的类， 类所在的包和子包。 所以对于带有@SpringBootApplication注解的入口类Application建议放在主包下！
5. 了解自动配置原理
依赖管理
例如：我们引入父依赖后并写上版本号，后面在引入其它依赖（实际上采用了自动版本仲裁机制），就不需要写版本号，此时就是父依赖作为依赖管理！
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.4.RELEASE</version>
</parent>
<!--不需要写版本号-->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
实际上spring-boot-start-parent的父项目是spring-boot-dependencies
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.3.4.RELEASE</version>
</parent>点进去spring-boot-dependencies找到properties属性几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制！
<properties>
<activemq.version>5.15.13</activemq.version>
<antlr2.version>2.7.7</antlr2.version>
<appengine-sdk.version>1.9.82</appengine-sdk.version>
<artemis.version>2.12.0</artemis.version>
<aspectj.version>1.9.6</aspectj.version>
<assertj.version>3.16.1</assertj.version>
<atomikos.version>4.0.6</atomikos.version>
<awaitility.version>4.0.3</awaitility.version>
<bitronix.version>2.1.4</bitronix.version>
<build-helper-maven-plugin.version>3.1.0</build-helper-maven-plugin.version>
<byte-buddy.version>1.10.14</byte-buddy.version>
<caffeine.version>2.8.5</caffeine.version>
<cassandra-driver.version>4.6.1</cassandra-driver.version>
<classmate.version>1.5.1</classmate.version>
<***mons-codec.version>1.14</***mons-codec.version>
<***mons-dbcp2.version>2.7.0</***mons-dbcp2.version>
<***mons-lang3.version>3.10</***mons-lang3.version>
<***mons-pool.version>1.6</***mons-pool.version>
<***mons-pool2.version>2.8.1</***mons-pool2.version>
<couchbase-client.version>3.0.8</couchbase-client.version>
<db2-jdbc.version>11.5.4.0</db2-jdbc.version>
<dependency-management-plugin.version>1.0.10.RELEASE</dependency-management-plugin.version>
<derby.version>10.14.2.0</derby.version>
<dropwizard-metrics.version>4.1.12.1</dropwizard-metrics.version>
<ehcache.version>2.10.6</ehcache.version>
<ehcache3.version>3.8.1</ehcache3.version>
<elasticsearch.version>7.6.2</elasticsearch.version>
<embedded-mongo.version>2.2.0</embedded-mongo.version>
<exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
<flatten-maven-plugin.version>1.2.5</flatten-maven-plugin.version>
<flyway.version>6.4.4</flyway.version>
<freemarker.version>2.3.30</freemarker.version>
<git-***mit-id-plugin.version>3.0.1</git-***mit-id-plugin.version>
<glassfish-el.version>3.0.3</glassfish-el.version>
<glassfish-jaxb.version>2.3.3</glassfish-jaxb.version>
<groovy.version>2.5.13</groovy.version>
<gson.version>2.8.6</gson.version>
<h2.version>1.4.200</h2.version>
<hamcrest.version>2.2</hamcrest.version>
<hazelcast.version>3.12.9</hazelcast.version>
<hazelcast-hibernate5.version>1.3.2</hazelcast-hibernate5.version>
<hibernate.version>5.4.21.Final</hibernate.version>
<hibernate-validator.version>6.1.5.Final</hibernate-validator.version>
<hikaricp.version>3.4.5</hikaricp.version>
<hsqldb.version>2.5.1</hsqldb.version>
<htmlunit.version>2.40.0</htmlunit.version>
<httpasyn***lient.version>4.1.4</httpasyn***lient.version>
<httpclient.version>4.5.12</httpclient.version>
<httpcore.version>4.4.13</httpcore.version>
<infinispan.version>10.1.8.Final</infinispan.version>
<influxdb-java.version>2.18</influxdb-java.version>
<jackson-bom.version>2.11.2</jackson-bom.version>
<jakarta-activation.version>1.2.2</jakarta-activation.version>
<jakarta-annotation.version>1.3.5</jakarta-annotation.version>
<jakarta-jms.version>2.0.3</jakarta-jms.version>
<jakarta-json.version>1.1.6</jakarta-json.version>
<jakarta-json-bind.version>1.0.2</jakarta-json-bind.version>
<jakarta-mail.version>1.6.5</jakarta-mail.version>
<jakarta-persistence.version>2.2.3</jakarta-persistence.version>
<jakarta-servlet.version>4.0.4</jakarta-servlet.version>
<jakarta-servlet-jsp-jstl.version>1.2.7</jakarta-servlet-jsp-jstl.version>
<jakarta-transaction.version>1.3.3</jakarta-transaction.version>
<jakarta-validation.version>2.0.2</jakarta-validation.version>
<jakarta-websocket.version>1.1.2</jakarta-websocket.version>
<jakarta-ws-rs.version>2.1.6</jakarta-ws-rs.version>
<jakarta-xml-bind.version>2.3.3</jakarta-xml-bind.version>
<jakarta-xml-soap.version>1.4.2</jakarta-xml-soap.version>
<jakarta-xml-ws.version>2.3.3</jakarta-xml-ws.version>
<janino.version>3.1.2</janino.version>
<javax-activation.version>1.2.0</javax-activation.version>
<javax-annotation.version>1.3.2</javax-annotation.version>
<javax-cache.version>1.1.1</javax-cache.version>
<javax-jaxb.version>2.3.1</javax-jaxb.version>
<javax-jaxws.version>2.3.1</javax-jaxws.version>
<javax-jms.version>2.0.1</javax-jms.version>
<javax-json.version>1.1.4</javax-json.version>
<javax-jsonb.version>1.0</javax-jsonb.version>
<javax-mail.version>1.6.2</javax-mail.version>
<javax-money.version>1.0.3</javax-money.version>
<javax-persistence.version>2.2</javax-persistence.version>
<javax-transaction.version>1.3</javax-transaction.version>
<javax-validation.version>2.0.1.Final</javax-validation.version>
<javax-websocket.version>1.1</javax-websocket.version>
<jaxen.version>1.2.0</jaxen.version>
<jaybird.version>3.0.9</jaybird.version>
<jboss-logging.version>3.4.1.Final</jboss-logging.version>
<jboss-transaction-spi.version>7.6.0.Final</jboss-transaction-spi.version>
<jdom2.version>2.0.6</jdom2.version>
<jedis.version>3.3.0</jedis.version>
<jersey.version>2.30.1</jersey.version>
<jetty-el.version>8.5.54</jetty-el.version>
<jetty-jsp.version>2.2.0.v201112011158</jetty-jsp.version>
<jetty-reactive-httpclient.version>1.1.4</jetty-reactive-httpclient.version>
<jetty.version>9.4.31.v20200723</jetty.version>
<jmustache.version>1.15</jmustache.version>
<johnzon.version>1.2.8</johnzon.version>
<jolokia.version>1.6.2</jolokia.version>
<jooq.version>3.13.4</jooq.version>
<json-path.version>2.4.0</json-path.version>
<json-smart.version>2.3</json-smart.version>
<jsonassert.version>1.5.0</jsonassert.version>
<jstl.version>1.2</jstl.version>
<jtds.version>1.3.1</jtds.version>
<junit.version>4.13</junit.version>
<junit-jupiter.version>5.6.2</junit-jupiter.version>
<kafka.version>2.5.1</kafka.version>
<kotlin.version>1.3.72</kotlin.version>
<kotlin-coroutines.version>1.3.8</kotlin-coroutines.version>
<lettuce.version>5.3.4.RELEASE</lettuce.version>
<liquibase.version>3.8.9</liquibase.version>
<log4j2.version>2.13.3</log4j2.version>
<logback.version>1.2.3</logback.version>
<lombok.version>1.18.12</lombok.version>
<mariadb.version>2.6.2</mariadb.version>
<maven-antrun-plugin.version>1.8</maven-antrun-plugin.version>
<maven-assembly-plugin.version>3.3.0</maven-assembly-plugin.version>
<maven-clean-plugin.version>3.1.0</maven-clean-plugin.version>
<maven-***piler-plugin.version>3.8.1</maven-***piler-plugin.version>
<maven-dependency-plugin.version>3.1.2</maven-dependency-plugin.version>
<maven-deploy-plugin.version>2.8.2</maven-deploy-plugin.version>
<maven-enforcer-plugin.version>3.0.0-M3</maven-enforcer-plugin.version>
<maven-failsafe-plugin.version>2.22.2</maven-failsafe-plugin.version>
<maven-help-plugin.version>3.2.0</maven-help-plugin.version>
<maven-install-plugin.version>2.5.2</maven-install-plugin.version>
<maven-invoker-plugin.version>3.2.1</maven-invoker-plugin.version>
<maven-jar-plugin.version>3.2.0</maven-jar-plugin.version>
<maven-javadoc-plugin.version>3.2.0</maven-javadoc-plugin.version>
<maven-resources-plugin.version>3.1.0</maven-resources-plugin.version>
<maven-shade-plugin.version>3.2.4</maven-shade-plugin.version>
<maven-source-plugin.version>3.2.1</maven-source-plugin.version>
<maven-surefire-plugin.version>2.22.2</maven-surefire-plugin.version>
<maven-war-plugin.version>3.2.3</maven-war-plugin.version>
<micrometer.version>1.5.5</micrometer.version>
<mimepull.version>1.9.13</mimepull.version>
<mockito.version>3.3.3</mockito.version>
<mongodb.version>4.0.5</mongodb.version>
<mssql-jdbc.version>7.4.1.jre8</mssql-jdbc.version>
<mysql.version>8.0.21</mysql.version>
<nekohtml.version>1.9.22</nekohtml.version>
<neo4j-ogm.version>3.2.16</neo4j-ogm.version>
<***ty.version>4.1.52.Final</***ty.version>
<***ty-t***ative.version>2.0.34.Final</***ty-t***ative.version>
<nio-multipart-parser.version>1.1.0</nio-multipart-parser.version>
<oauth2-oidc-sdk.version>7.1.1</oauth2-oidc-sdk.version>
<nimbus-jose-jwt.version>8.19</nimbus-jose-jwt.version>
<ojdbc.version>19.3.0.0</ojdbc.version>
<okhttp3.version>3.14.9</okhttp3.version>
<oracle-database.version>19.3.0.0</oracle-database.version>
<pooled-jms.version>1.1.2</pooled-jms.version>
<postgresql.version>42.2.16</postgresql.version>
<prometheus-pushgateway.version>0.9.0</prometheus-pushgateway.version>
<quartz.version>2.3.2</quartz.version>
<querydsl.version>4.3.1</querydsl.version>
<r2dbc-bom.version>Arabba-SR7</r2dbc-bom.version>
<rabbit-amqp-client.version>5.9.0</rabbit-amqp-client.version>
<reactive-streams.version>1.0.3</reactive-streams.version>
<reactor-bom.version>Dysprosium-SR12</reactor-bom.version>
<rest-assured.version>3.3.0</rest-assured.version>
<rsocket.version>1.0.2</rsocket.version>
<rxjava.version>1.3.8</rxjava.version>
<rxjava-adapter.version>1.2.1</rxjava-adapter.version>
<rxjava2.version>2.2.19</rxjava2.version>
<saaj-impl.version>1.5.2</saaj-impl.version>
<selenium.version>3.141.59</selenium.version>
<selenium-htmlunit.version>2.40.0</selenium-htmlunit.version>
<sendgrid.version>4.4.8</sendgrid.version>
<servlet-api.version>4.0.1</servlet-api.version>
<slf4j.version>1.7.30</slf4j.version>
<snakeyaml.version>1.26</snakeyaml.version>
<solr.version>8.5.2</solr.version>
<spring-amqp.version>2.2.11.RELEASE</spring-amqp.version>
<spring-batch.version>4.2.4.RELEASE</spring-batch.version>
<spring-data-releasetrain.version>Neumann-SR4</spring-data-releasetrain.version>
<spring-framework.version>5.2.9.RELEASE</spring-framework.version>
<spring-hateoas.version>1.1.2.RELEASE</spring-hateoas.version>
<spring-integration.version>5.3.2.RELEASE</spring-integration.version>
<spring-kafka.version>2.5.6.RELEASE</spring-kafka.version>
<spring-ldap.version>2.3.3.RELEASE</spring-ldap.version>
<spring-restdocs.version>2.0.5.RELEASE</spring-restdocs.version>
<spring-retry.version>1.2.5.RELEASE</spring-retry.version>
<spring-security.version>5.3.4.RELEASE</spring-security.version>
<spring-session-bom.version>Dragonfruit-SR1</spring-session-bom.version>
<spring-ws.version>3.0.10.RELEASE</spring-ws.version>
<sqlite-jdbc.version>3.31.1</sqlite-jdbc.version>
<sun-mail.version>1.6.5</sun-mail.version>
<thymeleaf.version>3.0.11.RELEASE</thymeleaf.version>
<thymeleaf-extras-data-attribute.version>2.0.1</thymeleaf-extras-data-attribute.version>
<thymeleaf-extras-java8time.version>3.0.4.RELEASE</thymeleaf-extras-java8time.version>
<thymeleaf-extras-springsecurity.version>3.0.4.RELEASE</thymeleaf-extras-springsecurity.version>
<thymeleaf-layout-dialect.version>2.4.1</thymeleaf-layout-dialect.version>
<tomcat.version>9.0.38</tomcat.version>
<unboundid-ldapsdk.version>4.0.14</unboundid-ldapsdk.version>
<undertow.version>2.1.4.Final</undertow.version>
<versions-maven-plugin.version>2.7</versions-maven-plugin.version>
<webjars-hal-browser.version>3325375</webjars-hal-browser.version>
<webjars-locator-core.version>0.45</webjars-locator-core.version>
<wsdl4j.version>1.6.3</wsdl4j.version>
<xml-maven-plugin.version>1.0.2</xml-maven-plugin.version>
<xmlunit2.version>2.7.0</xmlunit2.version>
</properties>如果此时需要换版本号怎们办呢？
查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。就是用上面的properties标签对应的属性进行重写；实际上使用的是就近原则！
<properties>
<mysql.version>5.1.43</mysql.version>
</properties>开发导入starter场景启动器
（1）见到很多 spring-boot-starter-* ： *就某种场景；官方的启动器，只要引入starter，这个场景的所有常规需要的依赖我们都自动引入！SpringBoot所有支持的场景：Developing with Spring Boot
（2）见到的 *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
（3）所有场景启动器（start）最底层的依赖是spring-boot-start
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.3.4.RELEASE</version>
<scope>***pile</scope>
</dependency>自动配置
我们直接执行启动类就可以访问，实际上是自动进行了一系列的配置！
①自动配好Tomcat
（1）引入Tomcat依赖；
（2）配置Tomcat；
②自动配好SpringMVC常见功能，如：前端控制器DispatcherServlet、字符编码问题CharaterEncodingFilter、视图解析器ViewResolver
（1）引入SpringMVC全套组件；实际上启动类的SpringBootApplication类的静态方法放回的是IOC容器，通过这个IOC容器的getBeanDefinitionNames方法就可以查看容器里面的组件！
（2）自动配好SpringMVC常用组件（功能）；
package ***.zl;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
// 实际上返回的是IOC容器
ConfigurableApplicationContext applicationContext = SpringApplication.run(MyApplication.class, args);
// 查看容器里面的组件
String[] names = applicationContext.getBeanDefinitionNames();
for (String name : names) {
System.aout.println(name);
}
}
}
③默认的包结构
（1）主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来，不需要以前的包扫描配置；
（2）要想改变扫描路径，使用@SpringBootApplication注解的scanBasePackages属性去指定(scanBasePackages="***.zl")，或者使用@***ponentScan注解指定扫描路径；
（3）@SpringBootApplication是一个复合注解等同于以下三个注解：
@SpringBootConfiguration
@EnableAutoConfiguration
@***ponentScan("***.zl")④按需加载所有自动配置项
（1）在实际上开发中有非常多的场景（start），引入了哪些场景这个场景的自动配置才会开启；
（2）SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面；
6. SpringBoot核心配置文件
配置文件名称是：application，扩展名有：properties、yml；例如：application.properties或者application.yml。
注：使用properties扩展名配置是key=value的格式，使用yml扩展名配置是key:value的格式
第一步：创建一个controller
package ***.zl.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class SpringController {
@RequestMapping("/spring")
@ResponseBody
public String doSome(){
return "hello SpringBoot";
}
}
第二步：创建启动类，对于启动类我们可以删除自动生成的，自己手写一个
①类名随意，里面有一个主方法，在主方法中调用SpringApplication的run方法，一个参数是本类.class，另一个参数是上面main方法的参数args。
②给本类增加上@SpringBootApplication注解。
package ***.zl;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class,args);
}
}
第三步：使用application.properties/yml配置文件，配置端口号、上下文的路径等
①采用默认的
②自己进行配置application.properties，#代表注释
#设置端口号
server.port=8082
#设置访问应用上下文路径，contextpath
server.servlet.context-path=/myboot③使用yml的配置方式，application.yml
yml是一种yaml格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。 yaml是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类似于xml，但是语法比xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 缀也可以使用 yaml 后缀。
server:
port: 8082
servlet:
context-path: /myboot注意： 当两种格式配置文件同时存在，默认使用的是properties，在SpringBoot2.4开始，使用的是yml配置文件，推荐使用 yml格式配置文件。
多环境测试
在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同，例如：端口、上下文根、数据库等，那么这个时候为了方便在不同的环境之间切换，SpringBoot 提供了多环境配置，具体步骤如下：
注：为每个环境创建一个配置文件，命名必须以application-环境标识.properties或yml！
开发环境application-dev.properties：
#配置端口号
server.port=8081
#配置应用根路径
server.servlet.context-path=/mydev测试环境application-test.properties：
#配置端口号
server.port=8082
#配置应用根路径
server.servlet.context-path=/mytest上线环境application-onlion.properties：
#配置端口号
server.port=8083
#配置应用根路径
server.servlet.context-path=/myonlion在application.properties中指定要使用的配置文件
#激活使用哪个配置文件
spring.profiles.active=dev
spring.profiles.active=test
spring.profiles.active=onlion自定义配置
（1）@Value注解
注：在application.properties中添加自定义的配置项，然后在类中需要时，使用@Value(${变量名})注解进行引入。
application.properties配置
#配置端口号
server.port=8082
#context-path
server.servlet.context-path=/myboot
#自定义key=value
school.name=大连大学
school.website=www.baidu.***
school.address=辽宁省大连市
site=www.sina.***.***
在controller中联合@Value注解获取数据
注：这例也可以使用@ConfigurationProperties注解指定配置的前缀，后缀与实体类的属性名相同也可以完成属性的赋值。
package ***.zl.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class DataController {
// 定义变量接收赋值
@Value("${server.port}")
private Integer port;
@Value("${server.servlet.context-path}")
private String contextPath;
// 自定义的
@Value("${school.name}")
private String name;
@Value("${site}")
private String site;
@RequestMapping("/data")
@ResponseBody
public String queryData(){
return name+","+site+",项目访问的地址"+contextPath+",使用的端口"+port;
}
}
执行结果：
（2）@ConfigurationProperties注解
前面我们是一个个取出值，现在我们将整个文件映射成一个Java对象，用于自定义配置项比较多的情况！
工作原理：定义一个类使用@ConfigurationProperties注解，并指定前缀prefix，它会根据这个前缀到配置中找以这个前缀开头的属性；如果以这个前缀开头的后面的属性与我们定义的Java对象的属性相同就赋上值！
定义一个School类
关键点：配置文件的数据与School类中的属性怎么对应上？
使用@ConfigurationProperties注解，指定一个前缀！
package ***.zl.vo;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.***ponent;
@***ponent // 创建对象
@ConfigurationProperties(prefix = "school") // 把school开头的配置项找出来
public class School {
private String name;
private String website;
private String address;
public School() {
}
public School(String name, String website, String address) {
this.name = name;
this.website = website;
this.address = address;
}
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", website='" + website + '\'' +
", address='" + address + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWebsite() {
return website;
}
public void setWebsite(String website) {
this.website = website;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
进行测试：
package ***.zl.controller;
import ***.zl.vo.School;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
@Controller
public class DataController {
@Resource // 赋值
private School school;
@RequestMapping("/school")
@ResponseBody
public School querySchool(){
return school;
}
}
执行结果：
实际上还有一个报错信息，让我们添加一个依赖，当然不添加也不影响的项目的正常运行
添加以下依赖
<!--处理ConfigurationProperties注解有关的元数据-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>7. SpringBoot中使用JSP（了解）
SpringBoot不推荐使用jsp ，而是使用模板技术代替jsp，作为视图来使用！
使用jsp需要配置：
①加入一个处理jsp的依赖， 负责编译jsp文件
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>②如果需要使用servlet， jsp，jstl的功能，还需要加对应的依赖
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
</dependency>③在resources下创建一个存放jsp的目录，一般叫做webapp，这个目录默认是不能创建jsp文件，需要我们手动更改webapp目录的属性
编写index.jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>index.jsp</title>
</head>
<body>
<h1>使用jsp显示Controller中的数据${data}</h1>
</body>
</html>
④需要在pom.xml指定jsp文件编译后的存放目录；META-INF/resources（固定的）
<build>
<!--指定jsp编译后的存放目录-->
<resources>
<resource>
<!--jsp原来的目录-->
<directory>src/main/webapp</directory>
<!--指定编译后的存放目录-->
<targetPath>META-INF/resources</targetPath>
<!--指定处理的目录和文件-->
<includes>
<!--表示webapp下任意目录的任意文件-->
<include>**/*.*</include>
</includes>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>⑤创建Controller， 访问jsp
package ***.zl.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
@Controller
public class JspController {
// 方法一：使用HttpServletRequest对象
/*public String doJsp(HttpServletRequest request){
request.setAttribute("data","SpringBoot使用JSP进行显示");
// 返回视图的逻辑名称
return "index";
}*/
// 方法二：使用Model对象
@RequestMapping("/myjsp")
public String doJsp(Model model){
model.addAttribute("data","SpringBoot使用JSP进行显示");
// 返回视图的逻辑名称
return "index";
}
}
⑥在application.propertis文件中配置视图解析器
#配置端口号
server.port=9090
#配置context-path
server.servlet.context-path=/myboot
#配置视图解析器
# / 就是src/main/webapp
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp8. SpringBoot中使用ApplicationContext（上下文对象）
怎么使用容器对象？要想从容器中获取对象，通过SpringApplication.run(Application.class, args); 返回值获取容器，返回值类型是什么呢？通过源码分析：
先定位到SpringApplication的run方法
run方法的返回值是ConfigurableApplicationContext接口
ConfigurableApplicationContext接口继承ApplicationContext接口
所以run方法的返回值其实就是一个ApplicationContext容器（Spring容器中创建ClassPathXmlApplicationContext对象时，返回的结果就是ApplicationContext[是ClassPathXmlApplicationContext的父类]，然后调用getBean方法就能获取对象）！
案例：在main方法中使用SpringApplication.run()方法获取返回的Spring容器上下文对象，再调用getBean()方法进行调用！
创建一个UserService 接口：
package ***.zl.service;
public interface UserService {
void sayHello(String name);
}
编写UserService接口的实现类：
package ***.zl.service.impl;
import ***.zl.service.UserService;
import org.springframework.stereotype.Service;
@Service("userService") // 交给Spring容器管理
public class UserServiceImpl implements UserService {
@Override
public void sayHello(String name) {
System.out.println("对"+name+"说sayHello");
}
}
在入口方法中取出被Spring容器管理的UserServiceImpl 类：
package ***.zl;
import ***.zl.service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
// 返回一个ConfigurableApplicationContext接口容器或者父接口的
// ConfigurableApplicationContext cac = SpringApplication.run(Application.class, args);
ApplicationContext cac = SpringApplication.run(Application.class, args);
// 调用getBean方法，获取交给Spring容器管理的对象
UserService userService = cac.getBean("userService", UserService.class);
// 方法的调用
userService.sayHello("张三");
}
}
执行结果：
9. ***mandLineRunner接口 & ApplicationRunner接口
（1）开发中可能会有这样的情景：需要在容器启动后执行一些内容；比如：读取配置文件，数据库连接之类的；SpringBoot 给我们提供了两个接口来帮助我们实现这种需求，这两个接口分别为***mandLineRunner 和 ApplicationRunner，它们的执行时机为容器启动完成的时候（容器对象创建好后，自动执行run方法）。
（2）这两个接口中有一个run()方法，我们只需要实现这个方法即可。
（3）这两个接口的不同之处在于：ApplicationRunner中run()方法的参数为ApplicationArguments，而***mandLineRunner接口中run方法的参数为String 数组。
ApplicationRunner接口
package org.springframework.boot;
@FunctionalInterface
public interface ApplicationRunner {
void run(ApplicationArguments args) throws Exception;
}
***mandLineRunner接口
package org.springframework.boot;
@FunctionalInterface
public interface ***mandLineRunner {
void run(String... args) throws Exception;
}
案例：
编写SomeService接口
package ***.zl.service;
public interface SomeService {
String doSome(String name);
}
编写SomeService接口的实现类SomeServiceImpl
package ***.zl.service.impl;
import ***.zl.service.SomeService;
import org.springframework.stereotype.Service;
@Service("someService") // 交给Spring容器管理
public class SomeServiceImpl implements SomeService {
@Override
public String doSome(String name) {
return name+"----》去打篮球了！";
}
}
让启动口类Application实现***mandLineRunner接口，并重写run()方法
package ***.zl;
import ***.zl.service.SomeService;
import org.springframework.boot.***mandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@SpringBootApplication
public class Application implements ***mandLineRunner {
@Resource // 下面容器创建好以后就会给属性赋值
private SomeService someService;
public static void main(String[] args) {
System.out.println("准备创建容器对象"); // 1
// 创建容器对象
SpringApplication.run(Application.class, args);
System.out.println("容器对象创建好之后"); // 3
}
@Override
public void run(String... args) throws Exception {
// 在这个run方法里做自定义的操作
System.out.println("容器对象创建好，马上执行的！"); // 2
// 调用容器中对象的方法
// 在这里执行，已经保证1的容器对象创建好了
String str = someService.doSome("张大傻");
System.out.println(str);
}
}
执行顺序结果：
图书推荐：集齐“Java四大名著”召唤神龙
Java 28岁了，当打之年，并且还会打很多年。为即将或正在使用Java的你推荐Java“此生错过必遗憾”系列书单。看看你还缺哪本？请补齐。优惠购书链接就在文中，拿好不谢！
1. Java核心技术第12版开发基础+高级特性
“Java四大名著”之一Core Java最新版，一键打包全套2册！建议入门小白和准备升级到Java17的开发者购买。本书根据Java17新特性全面升级！赠送作者亲授视频课+海量代码集。
限时秒杀链接：点击购买
2. Java核心技术第11版基础知识+高级特性
“Java四大名著”之一Core Java次新版，一键打包全套2册！建议实际生产环境仍在使用Java8、Java11开发且暂时没有升级版本打算的开发者购买。本书基于Java9-11编写，赠送作者亲授视频课+海量代码集。
限时秒杀链接：点击购买
3. Java编程思想[Thinking in Java]
“Java四大名著”之一，需要有一定编程基础的人才可阅读，即使很多内容还无法理解，但每次读完一定会有所收获。本书单最前面推荐的《Java核心技术》侧重技术，而《Java编程思想》侧重于“思想”，本书为你剖析Java中各个内容的设计理念。这是一本伴随我们技术成长的好书，买一本放在旁边，摸着就有底气。
限时秒杀链接：点击购买
4. Effective Java 中文版（原书第3版）
“Java四大名著”之一，适合已经掌握Java核心技术的程序员，想更加深入地了解Java编程语言的开发者阅读。针对如何编写高效、设计优良的程序提出了最实用、最权威的指导方针，通过90条简短、独立的经验法则，探索新的设计模式和语言习惯用法，帮你更加有效地使用Java编程语言及其基本类库，指引你少走弯路。这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。是Java开发人员案头上的一本不可或缺的参考书。
限时秒杀链接：点击购买
5. Java语言程序设计基础篇+进阶篇
本套书相较于《Java核心技术》更加的基础，如果你阅读《Java核心技术》有些吃力，建议从本书读起。畅销20余年的“长城书”一键打包全套！被世界各地的大学选作教材，更新至Java9、10和11。本书通过示例讲解问题求解技巧，提供大量的程序清单，每章配有丰富的复习题和编程练习题，帮助读者掌握编程技术并解决实际开发中遇到的问题。
限时秒杀链接：点击购买
6. Java并发编程实战
让注重实战的你更快领悟Java并发编程的要领，快速构建大规模并发应用程序。“Java四大名著”之一《Effective Java》的作者Joshua Bloch参与编写。本书是Java并发编程领域的里程碑著作！从并发编程的基本理论入手，逐步介绍了在设计Java并发程序时各种重要的设计原则、设计模式与思维模式。另一本蚂蚁金服方腾飞老师写的《Java并发编程的艺术》也适合一并阅读。
限时秒杀链接：点击购买
7. 软件架构实践
让你少走弯路的进阶架构师避坑指南！图书届奥斯卡Jolt大奖双冠王作品！全球10余个国出版。卡内基梅隆等名校教材，IEEE杂志10佳图书，软件架构图书事实标准。
限时秒杀链接：点击购买
以上图书当当网全部限时秒杀，满100-50，买的越多，优惠越多！了解更多好书点击：Core Java 全面升级！
