1. SpringBoot HelloWorld

在使用 SpringBoot 框架时，个人推荐参考官方网站，虽然是英文文档也比较难懂些，但是也是最权威的。好吧，下面开始从基础上来创建一个 SpringBoot 项目吧！

假设现在需要一个简单的功能，即浏览器向 SpringBoot 项目发送一个 hello 请求，服务器接受请求并处理后，在页面上显示Hello World字符串。

1.1 创建 Maven 项目

1.2 导入 SpringBoot 依赖

首先我们需要在 pom.xml 文件中导入SpringBoot 相关的依赖：

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

这里我们只需简单地知道，spring-boot-starter-parent 表示与 SpringBoot 相关的依赖，而 spring-boot-starter-web 则表示与 web 相关的依赖，比如 web-mvc 依赖。

1.3 编写主程序类

我们在包 com.shoto 下创建一个主程序类 HelloWorldMainApplication，该类是 SpringBoot 程序的入口，其中的 main 中的 run 方法用于启动 SpringBoot 应用：

/*
 * @SpringBootApplication 该注解用于指明该类是 SpringBoot 的主程序类
 */
@SpringBootApplication
public class HelloWorldMainApplication {
    public static void main(String[] args) {
        // run 方法用于启动 SpringBoot 应用
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}

1.4 编写 Controller 类

在com.shoto.controller 包下编写一个控制器类，具体如下：

@Controller
public class HelloController {

    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        return "Hello World!";
    }
}

1.5 运行主程序测试

1.6 简化部署

如果我们需要快速的创建一个可运行 jar 包，首先我们需要在 pom.xml 中导入相关的依赖：

<!--生成可执行jar包-->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

然后使用 maven 执行 mvn package 命令，此时会在 target 目录下生成相应的可运行 jar。我们可以使用命令java -jar jar名称 来运行该 jar 包。

2. Hello World 探究

在前面我们已经创建和运行了一个简单的 SpringBoot 应用，下面我们来解释一下该 HelloWorld 程序的一些细节。

2.1 pom 文件

2.1.1 父项目

前面我们在 pom 文件中配置了如下内容：

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

它是 SpringBoot 应用的核心配置，我们点击 spring-boot-starter-parent 可以发现其父项目是 spring-boot-dependencies，具体内容如下：

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

点击spring-boot-dependencies 后我们可以发现其管理了 SpringBoot 应用里面的所有依赖版本，因此以后我们导入依赖默认是不需要写版本的，当然如果没有在 dependencies 里面管理的依赖自然需要声明版本号。

2.1.2 启动器

同样的，前面我们在 pom 文件中也配置了如下内容：

<!--配置web相关依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

spring-boot-starter-web 表示 web 相关的启动器，它帮我们导入了 web 模块正常运行所依赖的所有组件，这样就可以减少我们的配置以及配置出错的情况。该 web 启动器包含的依赖有：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
<!--内置 Tomcat 配置-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<!--Hibernate 校验器-->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-validator</artifactId>
</dependency>
<!--与 Jackson 绑定-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
<!-- SpringMVC 配置-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
</dependency>

SpringBoot 将所有的功能场景都抽取出来，做成一个个的 starters（启动器），我们只需要在项目里面引入这些 starter，那么相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器。

SpringBoot 支持的启动器的相关详细信息可参考官方文档.

2.2 主程序类

/*
 * @SpringBootApplication 该注解用于指明该类是 SpringBoot 的主程序类
 */
@SpringBootApplication
public class HelloWorldMainApplication {
    public static void main(String[] args) {
        // run 方法用于启动 SpringBoot 应用
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}

这里我们需要注意的是 @SpringBootApplication 注解，其声明了 HelloWorldMainApplication 是一个主程序类，SpringBoot 会运行这个类的 main 方法来启动 SpringBoot 应用。

2.2.1 @SpringBootApplication

点击 @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 {
    ...
｝

在这里，我们只需关注 @SpringBootConfiguration 和 @EnableAutoConfiguration 这两个注解。

@SpringBootConfiguration ：标注在某个类上，用于表示这是一个Spring Boot的配置类；
点击 @SpringBootConfiguration 后我们可以发现其也是由以下多个注解组成的：
1
2
3
4
5
6
7
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
...
｝
其中，注解 @Configuration 表明当前类是 Spring 的一个配置类，相当于我们 Spring 的一个配置文件，不过这里是以一个 Java 类的形式，该类也是一个组件（Component）。

@EnableAutoConfiguration ：开启 SpringBoot 的自动配置功能，这样自动配置才能生效。

我们点击 @EnableAutoConfiguration 注解，我们可以发现其部分内容如下：

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

在这里，我们需关注 @AutoConfigurationPackage 和 @Import(EnableAutoConfigurationImportSelector.class) 这两个注解：

点击 @AutoConfigurationPackage 注解，我们发现其是由 @Import({Registrar.class}) 等注解构成的，其作用是将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring 容器中。本项目中我们的主程序类的包是 com.shoto，所以如果我们在该包外创建一个 controller 类，其是不会加入 Spring 容器中的，这一点需要额外注意；

@Import(EnableAutoConfigurationImportSelector.class) 注解会将 EnableAutoConfigurationImportSelector 类加入到 IoC 容器中，同时也会将自动配置类（xxxAutoConfiguration）及其相应的组件一并导入。

SpringBoot 的自动配置类位于 spring-boot-autoconfigure-2.2.1.RELEASE.jar 中，我们可以在 META-INF/spring.factories 中查看，其部分内容如下所示：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
...
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
...

其中 RedisAutoConfiguration 中则实现了 Redis 相关的自动配置，比如 RedisTemplate 的配置，不同的于 Spring 中使用 <bean> 标签，这里直接使用如下代码来实现。@Bean 可以将方法的返回值加入到 IoC 容器中。

@Bean
@ConditionalOnMissingBean(
    name = {"redisTemplate"}
)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
    // 创建一个 RedisTemplate
    RedisTemplate<Object, Object> template = new RedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

以上即是注解 @SpringBootApplication和其相关注解的一些作用，其标注的类即为一个主程序类，同时也是一个配置类。其作用是 SpringBoot 应用的启动入口，同时引发 SpringBoot 的自动配置生效等功能。

3. 快速创建 SpringBoot 项目

3.1 网站在线创建

我们可以访问该网站（点击），在线配置并下载 SpringBoot 项目，然后使用 IDEA 等软件打开即可。

3.2 Spring Initializer 创建

IDEA 支持使用 Spring 的项目创建向导来快速创建一个 SpringBoot 项目，如下图所示。点击 next 后，具体的配置按需求来就好了。 Initializer创建SpringBoot项目

默认生成的项目我们需要注意的是 resources 文件夹。

resources 文件夹中的目录结构：
- static：保存所有的静态资源； js css images；
- templates：保存所有的模板页面；（SpringBoot 默认 jar 包使用嵌入式的 Tomcat，默认不支持 JSP 页面）；可以使用模板引擎（freemarker、thymeleaf）；
- application.properties：SpringBoot 应用的全局配置文件，比如配置与数据库的连接信息和 Tomcat 的端口号等等。