【001】Spring Boot 入门之 Hello World

第一章：Spring Boot 入门

一、Spring Boot 出现的背景

J2EE 笨重的开发、繁多的配置、低下的开发效率、复杂的部署流程、第三方技术集成难度大 ，从而诞生了 Spring Boot 。举个栗子，如果不用 Spring Boot ，平时我们开发一个 Web 应用程序需要以下步骤：

### 传统 Web 应用开发步骤

1、新建一个 web 工程
2、引入依赖
3、配置 web.xml 文件
4、配置框架本身的配置文件
5、加入运行容器
6、调试运行

在这些步骤中，可能感触最深的或者最麻烦的就是引入各种依赖和配置各种 xml 文件 ，一不小心，依赖包可能冲突，或者缺少，配置文件也可能写错。有的时候，我们可能只是开发的一个很小的 web 应用，但是搭建环境可能比写业务代码花的时间长 ，想起来头都大。这时，Spring Boot 就诞生了！

二、Spring Boot 简介

相关链接：

Spring 官网： Spring 官网
Spring Boot 官网： Spring Boot 官网
使用文档： Spring boot 使用文档

Spring Boot 是由 Pivotal 团队 提供的全新框架，其设计目的是用来简化 Spring 应用的初始搭建以及开发过程 。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

---

Spring Boot 简化了基于 Spring 的应用开发，约定大于配置，去繁从简 ，通过少量的代码就能创建一个独立的、产品级别的 Spring 应用。不仅如此，Spring Boot 为 Spring 平台及第三方库提供【开箱即用】的设置 ，这样你就可以有条不紊地开始。Spring Boot 的核心思想就是约定大于配置，多数 Spring Boot 应用只需要很少的 Spring 配置 。采用 Spring Boot 可以大大的简化你的开发模式，所有你想集成的常用框架，它都有对应的组件支持。

三、Spring Boot 优缺点

### Spring Boot 优点
1、快速创建独立运行的 Spring 项目以及与主流框架集成
2、使用嵌入式的 Servlet 容器，应用无需打成 WAR 包
3、starters 自动依赖与版本控制
4、大量的自动配置，简化开发，也可修改默认值
5、无需配置 XML，无代码生成，开箱即用
6、准生产环境的运行时应用监控
7、与云计算的天然集成


### Spring Boot 缺点
Spring Boot 唯一的缺点就是入门容易，精通难，只有对 Spring 非常的了解，才能够深度定制 Spring Boot

### Spring Boot 总体概括，它就是

1、简化 Spring 应用开发的一个框架
2、整个 Spring 技术栈的一个大整合
3、J2EE 开发的一站式解决方案

四、微服务简介

【微服务】是一种架构风格，它能够将单一程序开发成一组小型服务的组合，每一个功能元素最终都是一个可独立替换和独立升级的软件单元。这些小型服务可以使用不同的编程语言以及数据存储技术 ，每一个微服务运行在自己的进程中，使用轻量级机制通信，并通过完全自动化部署机制来独立部署。

### 什么是微服务

1、始于 2014 年，martin fowler 的初始微服务文档: https://martinfowler.com/articles/microservices.html
2、微服务其实就是一种架构风格（服务微化）
3、一个应用应该是一组小型服务
4、可以通过 HTTP 的方式进行互通
5、原先的应用称为单体应用 ==> ALL IN ONE

单体应用 与 微服务 之间的对比图：

微服务之间的相互调用 关系图：

第二章：Spring Boot 中的 Hello World

一、Hello World 环境准备

1、学习前提

### 学习 Spring Boot 前提
1、最好学习过 Spring 框架
2、能够使用 Maven 进行项目构建和依赖管理
3、熟悉使用 IDE  ===>  如 IDEA 、 Eclipse 或者 STS 等等


### 环境准备
1、JDK1.8  ===>  Spring Boot 官网推荐 jdk1.7 及以上，个人推荐使用 JDK1.8 或 JDK11
2、Maven3.x  ===>  maven 3.3 以上版本
3、IntelliJ IDEA  ===>  2017年及以上，可使用 2020 版本，支持中文哦
4、Spring Boot 1.5.9.RELEASE  ===>  Spring Boot 官网推荐 1.5.9 及以上，个人推荐 Spring Boot 2.3.x 以上

2、Maven 配置

找到 Maven 安装目录下 settings.xml 配置文件的 profiles 标签，然后在 profiles 里面添加下面代码：

<!-- 如果你的 JDK 是 1.8 的，那就直接复制；如果你的 JDK 是其他版本的，改一下就行了 -->

<profile>
  <id>jdk-1.8</id>
  <activation>
    <activeByDefault>true</activeByDefault>
    <jdk>1.8</jdk>
  </activation>
  <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
  </properties>
</profile>

3、IDEA 配置

我们使用 IDEA 开发工具 进行项目的开发，因此需按照 File\settings\build,Execution,Deployment\Build Tools\Maven 路径 给 IDEA 配置好 Maven 。配置项及截图如下：

# 配置好 Maven 的下列三项：

- Maven home directory
- User settings file
- Local repository

二、创建第一个 Spring Boot 应用

现在就使用 Spring Boot 来开发一个小功能：浏览器发送一个 hello 请求 ，服务器接受请求并处理，然后返回相应的结果。 那就开始吧！

1、创建 Maven 项目

新建一个 project 或者 module，选择 Maven ，然后填写相关信息，一直下一步即可 ，直到 Finish 就完成了 Maven 项目的创建。我创建的项目工程名是 001-springboot-helloworld，完成后如下图：

2、导入相关的依赖

打开 Maven 工程下的 pom.xml 文件，把以下代码复制到 pom.xml 文件中：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

3、创建主程序

在 Maven 项目的 src\main\java 目录下创建 主程序【HelloWorldApplication】。 注意事项及代码如下：

### 注意事项

1、我的包名为 edu.jgsu ，路径是：src\main\java\edu\jgsu
2、HelloWorldApplication 必须放在 jgsu 包里面
3、以后所有包和类必须放在 jgsu 包下面的子包里面，即 jgsu 下面的子包 和 HelloWorldApplication 同级
4、文字描述不够直观，请看下图

package edu.jgsu;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// @SpringBootApplication 用来标注一个主程序类，说明这是一个 Spring Boot 应用
@SpringBootApplication
public class HelloWorldApplication {
    public static void main(String[] args) {
        // 将 Spring 应用启动起来
        SpringApplication.run(HelloWorldApplication.class, args);
    }
}

4、编写 Controller

在 edu\jgsu 下面新建一个 Controller 包 ，然后在 Controller 下编写 HelloController 类 。代码如下：

package edu.jgsu.Controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    // @ResponseBody 注解用于返回字符串，在这个方法中，用于返回【Hello,Spring Boot!】字符串
    // 如果不写这个注解，那么spring boot 就会去 resources 目录下找以【Hello,Spring Boot!】命名的静态页面
    @ResponseBody
    @RequestMapping("/hello")    // 访问路径
    public String Hello() {
        return "Hello,Spring Boot!";
    }

}

5、启动运行

切换到 HelloWorldApplication 主程序类，然后运行其主(main)方法 ，最后在浏览器输入如下地址即可。如果能看到以下效果，则代表你的第一个 Spring Boot 应用启动成功了。 如下图：

然后在地址栏后面加上 /hello ，/hello 来自于 HelloController 类 @RequestMapping 注解 里面的字符串。若成功返回指定字符串，那代表 hello 请求成功了。 如下图：

6、打包部署

添加打包插件 ，把以下代码添加到 pom.xml 文件 </project> 上一行中：

<!-- 这个插件，可以将应用打包成一个可执行的 jar 包 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

选择 Maven ，然后点击 Lifecycle\package 命令即可进行打包。如下图：

打包完成之后，停止 Maven 项目运行，去 Maven 工程目录下找到【target】文件夹，刚刚打包的 jar 包就放在里面 。然后复制到桌面，使用 java -jar xxx.jar 命令来使用 jar 包。这个 jar 包 内嵌 tomcat 应用服务器 ，启动成功后仍然可以通过浏览器访问。如下图：

三、自定义 banner【拓展】

我们启动 spring 项目时，默认的 banner 是这样的，如下：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 

如果我想把 banner 换成其他的文字可以吗？当然可以，以下是步骤：

# 替换步骤如下：


1、关键字搜索：spring boot banner      个人推荐网站  ==>  https://www.bootschool.net/ascii

2、输入自己喜欢的文字，然后生成，最后拷贝结果。或者点击 ASCll 艺术字，然后寻找到自己喜欢的 banner 并拷贝结果

3、回到 IDEA ，在 src/main/resources/ 下新建 banner.txt 文本，把拷贝结果复制到里面即可

4、重新启动项目，即可看到结果。示例如下

# 我的 banner


//                          _ooOoo_                               //
//                         o8888888o                              //
//                         88" . "88                              //
//                         (| ^_^ |)                              //
//                         O\  =  /O                              //
//                      ____/`---'\____                           //
//                    .'  \\|     |//  `.                         //
//                   /  \\|||  :  |||//  \                        //
//                  /  _||||| -:- |||||-  \                       //
//                  |   | \\\  -  /// |   |                       //
//                  | \_|  ''\---/''  |   |                       //
//                  \  .-\__  `-`  ___/-. /                       //
//                ___`. .'  /--.--\  `. . ___                     //
//              ."" '<  `.___\_<|>_/___.'  >'"".                  //
//            | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //
//            \  \ `-.   \_ __\ /__ _/   .-` /  /                 //
//      ========`-.____`-.___\_____/___.-`____.-'========         //
//                           `=---='                              //
//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //
//            佛祖保佑       永不宕机     永无BUG                    //

TIPS： 到这里为止，一个 通过 Maven 构建的 Spring Boot 应用 就完成了~~

第三章：Spring Boot 应用剖析和自动配置原理

一、Spring Boot 应用剖析

为什么 Spring Boot 能够如此简单的实现一个 Web 应用？为什么 Spring Boot 不需要配置繁琐的 tomcat 服务器？这就要归功于 Spring Boot 的各种启动器 。先阅读以下依赖并分析：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
</parent>

<!-- web 相关依赖：包括 tomcat、dispatcherServlet 和 xml 配置文件等等 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

spring-boot-starter 称之为【场景启动器】，它能够帮我们导入了各种模块正常运行所依赖的组件 。Spring Boot 将所有的功能场景都抽取出来，做成一个个的 【starters(启动器)】，只需要在项目里面引入这些 starter ，那么相关场景的所有依赖都会导入进来 。要用什么功能就导入什么场景的启动器即可。例如要用到【邮件功能】，那就导入【spring-boot-starter-mail】启动器。 要用哪一个版本可参考官网的某一个详细版本。如 Spring Boot-2.12 版本 。那么接下来，我们再来看看下面的依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

spring-boot-starter-parent 是 spring-boot-starter-web 的父项目 。而 spring-boot-dependencies 是 spring-boot-starter-parent 的父项目，它才是是真正管理 Spring Boot 应用里面的所有的依赖版本的管理者，也可以称之为 【Spring Boot 的版本仲裁中心】 。以后我们导入依赖，默认是不需要写版本的。【除非没有在 dependencies 里面管理的依赖，才需要声明版本号】

二、Spring Boot 的自动配置原理

我们先来看看 Spring Boot 的主程序类【HelloWorldApplication】，也就是 Spring Boot 应用的入口。 代码如下：

package edu.jgsu;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// @SpringBootApplication 用来标注一个主程序类，说明这是一个 Spring Boot 应用
@SpringBootApplication
public class HelloWorldApplication {
    public static void main(String[] args) {
        // 将 Spring 应用启动起来
        SpringApplication.run(HelloWorldApplication.class, args);
    }
}

在上述代码中，【@SpringBootApplication】注解是用来说明这个类是 Spring Boot 的主配置类 ，Spring Boot 就应该运行这个类中的 main 方法来启动 Spring Boot 应用 。让我们跟进 【@SpringBootApplication】注解 看一下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
...

【@SpringBootConfiguration】是 Spring Boot 的配置类注解，用于标注在某个类上，表示这是一个 Spring Boot 的配置类 。跟进这个注解，我们又发现了 【@Configuration】注解 ，这个注解用于配置类，是 Spring 底层注解。

注意： Spring Boot 中的配置类和 Spring 中的配置文件是等价的

继续跟进 【@Configuration】注解 ，我们又发现了 【@Component】注解 。具体如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    @AliasFor(annotation = Component.class)
    String value() default "";
    ……
}

【@Component】注解 表示配置类也是容器中的一个组件，都会交给 Spring 进行统一管理。那么到此为止，【@SpringBootConfiguration】注解 就说完了。那么接下来说一下 【@EnableAutoConfiguration】注解 的作用。

---

在学习 Spring Boot 之前，我们需要 手动配置 的很多东西。那么现在，Spring Boot 会帮我们进行自动配置。【@EnableAutoConfiguration】这个注解的作用就是告诉 Spring Boot 开启自动配置功能，这样自动配置才能生效。 跟进这个注解：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
...

在上面代码中，有两个注解很重要，分别是 【@AutoConfigurationPackage】 注解和【@Import】注解 。那就先来说一下 【@AutoConfigurationPackage】这个注解 。该注解的作用就是 自动配置包，将主配置类（@SpringBootApplication 标注的类）的所在包及下面所有子包里面的所有组件扫描到 Spring 容器 。

---

举个例子：如果把上面 Controller 包下面的 HelloController 类剪切到 edu 包下， 此时这个类不在扫描的范围之内，那么 HelloController 类将无法被访问。所以当我们访问 /hello 时，浏览器会返回 404 页面。 那么接下来，我们跟进 【@AutoConfigurationPackage】 这个注解看一下：

Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}

这是我们发现了一个 Spring 的底层注解 【@Import】 ，该注解的作用时给容器中导入一个组件，导入的组件为AutoConfigurationPackages.Registrar.class 。进一步的源码也就不分析了，到这里就差不多了。更多细节请自行查阅相关书籍。

---

那么到这里为止，我们已经清楚了【自动配置注解的功能】，其功能就是给容器中导入非常多的自动配置类【xxxAutoConfiguration】，就是给容器中导入某个场景需要的所有组件，并配置好这些组件 。有了自动配置类，也就免去了我们手动编写配置注入功能组件等相关工作。

---

Spring Boot 在启动一个应用的过程中，它会从【类路径下】的 META-INF/spring.factories 文件中获取【@EnableAutoConfiguration】注解所指定的值 ，将这些值作为自动配置类导入到容器中，自动配置类就生效，从而帮我们进行自动配置工作。以前我们需要自己配置的东西，现在这些自动配置类都帮我们配置好。

TIPS： J2EE 的整体整合解决方案和自动配置都在 spring-boot-autoconfigure-2.0.1.RELEASE.jar 中

三、快速创建 Spring Boot 应用

上述的 Hello World 使用的时 Maven 进行构建，那么现在学习一种新的构建 Spring Boot 的方式，那就是使用 Spring Initializr 来快速创建 Spring
Boot 应用。具体操作往下看！

---

首先 ，我们新建一个模块或者工程，选择左边的 Spring Initializr ，然后点击下一步，如下图：

然后填好相关信息，点击下一步 ，此刻进入到 依赖选择页面 ，选择好你要依赖，例如你要做 Web 开发，那么你就选择左侧的 Web ，中间选择你要的依赖，我选的是 Spring Web 。如果你还要用到数据库，那就选择数据库相关的即可。下图仅供参考：

选择好以后，点击完成即可。这里要注意：选择我们需要的模块之后，向导会联网创建 Spring Boot 项目【一定要联网】。创建完成之后项目结构如下图。然后自己编写 Controller 类，再去浏览器访问 ，这里就不在赘述了。

项目创建成功后，默认生成的内容有哪些呢？如下：

# 默认生成的内容如下：

1、主程序 Application 已经生成好了，我们只需要编写业务逻辑即可

2、resources 文件夹中目录结构
    2.1、static: 保存所有的静态资源 ==> 如 js、css、images 等等
    2.2、templates: 保存所有的模板页面
    2.3、application.properties: Spring Boot 应用的配置文件，可以修改一些默认设置

3、Spring Boot 的 jar 包使用嵌入式的 Tomcat，默认不支持 JSP 页面，所以要使用模板引擎（freemarker、thymeleaf）