Spring Boot从零入门3_建立Hello World及项目剖析

时间  2019-11-10
标签 spring boot 入门 建立 hello world 项目 剖析 栏目 Spring 繁體版
原文   原文链接

本文属于原创，转载注明出处，欢迎关注微信小程序小白AI博客 微信公众号小白AI或者网站 https://xiaobaiai.nethtml

[TOC]java

1 前言

上一篇咱们讲述了Spring boot的几个核心模块，知道了Spring boot是如何减小组件依赖和简化繁杂的配置的，以及讲述了Spring boot减小组件依赖和简化繁杂配置的内部原理，最后完成了Spring boot的开发环境搭建。这一篇咱们将讲述如何建立Spring boot Hello World级别的项目，建立一个简单的WEB应用，而后咱们对这个项目层层剖析，让咱们更深的了解Spring boot是如何工做的。git

2 名词术语

名词术语 释义
CLI 命令行界面，command-line interface
Marven Apache Maven是一个软件项目管理和综合工具，构建自动化系统(如Make,CMake)。基于项目对象模型（POM）的概念，Maven能够从一个中心资料片管理项目构建，报告和文件。Maven简化和标准化项目建设过程，处理编译，分配，文档，团队协做和其余任务的无缝链接。 Maven增长可重用性并负责创建相关的任务；Marven拥有依赖管理功能，它经过简单的配置就能够自动从网络上下载项目所需的依赖
POM 项目对象模型(Project Object Model)，它是Maven项目中的文件，使用XML表示，名称叫作pom.xml；该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目受权、项目的url、项目的依赖关系等；Maven世界中，project能够什么都没有，甚至没有代码，可是必须包含pom.xml文件
Gradle Gradle是一个彻底开源的构建自动化系统，使用特定编程语言Groovy来书写配置文件，不一样于Marven使用XML。如Android开发IDE Android Studio默认就是使用Gradle来构建项目；Gradle与Maven相比更为灵活，简单。
JDK8 JDK8或者JDK1.8是因为自从JDK1.5/JDK5命名方式改变后遗留的新旧命令方式问题。因此JDK8或者JDK1.8也是同一个东西。
STS Spring Tool Suite，Spring Tools 4是适用于你喜欢的编码环境的下一代Spring工具。不管是你喜欢Eclipse，Visual Studio Code仍是Theia IDE，STS是从头开始大量重构的，为开发基于Spring的企业应用程序提供了世界一流的支持。
Thymeleaf Thymeleaf是现代化服务器端的Java模板引擎，不一样与JSP和FreeMarker，Thymeleaf的语法更加接近HTML，而且也有不错的扩展性。
注解 注解只有成员变量，没有方法。注解的成员变量在注解的定义中以“无形参的函数”形式来声明，如int id();引用时如@TestAnnotation(id=3) 。注解中属性能够有默认值，默认值须要用 default 关键值指定，如public int id() default -1;注解的提取须要借助于 Java 的反射技术，反射比较慢，因此注解使用时也须要谨慎计较时间成本。注解主要给编译器及工具类型的软件用的。
元注解 元注解是能够注解到注解上的注解，或者说元注解是一种基本注解，可是它可以应用到其它的注解上面。若是把注解理解为标签，元注解也是一张标签，可是它是一张特殊的标签，它的做用和目的就是给其余普通的标签进行解释说明的。元标签有 @Retention、@Documented、@Target、@Inherited、@Repeatable 5 种

3 建立Hello World项目

建立一个Spring boot应用，有下面几种方式能够选择：github

  • 使用IDE工具，如咱们使用的STS4
  • 使用Spring boot CLI工具
  • 使用Spring Initializr网站来建立

下面对这三种方式一一讲述如何建立一个Spring boot WEB项目。web

💡 STS(Spring Tool Suite)能够开发其余不少类型的项目，这里仅以Spring boot项目做为建立示例。

3.1 基于STS4建立项目

3.1.1 项目建立

基于STS4建立Spring Web项目，这里选择Marven Project项目类型或者是Spring Starter Project项目类型。Spring Stater Project跟下一小节所讲的Spring Initializr Website建立项目基本一致，只不过一个是集成在STS中，一个是独立的Web网站，下一小节细讲，这里就不展开了。这里选择Marven Project类型，开始建立。spring

建立Marven项目中，咱们选择Create a Simple Project，能够选择默认工做目录或者其余存放项目的目录，Next后须要咱们填写一些项目信息，包括：apache

  • groupId：在全部项目中惟一标识你的项目。组ID应该遵循Java的程序包名称规则。这意味以反向域名开头（固然这不是强迫的，只是历史遗留下来的），如：编程

    • org.apache.maven
    • org.apache.commons
    • org.apache.maven.plugins
    • org.apache.maven.reporting
  • artifactId：是没有版本的jar的名称。若是建立了它，那么能够选择任何名称，包括小写字母和不是很奇怪的符号。若是是第三方jar，则必须使用该jar的名称。
  • version：若是发布了版本，则能够选择带有数字和点（1.0、1.一、1.0.1，...）的任何典型版本。不要使用日期，由于它们一般与SNAPSHOT（快照）构建相关联。

若是它是第三方artifact，则不管使用什么版本，都必须使用其版本号。小程序

点击完成后，就建立了一个最简单的Marven项目，仅仅只有一个pom.xml文件，里面也只有咱们建立的项目信息，接下来咱们须要实现WEB服务器，访问一个简单的页面，页面显示出Hello World!。微信小程序

3.1.2 添加工程代码

添加Spring WEB依赖项到pom.xml中：

<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>com.xiaobaiai.examples</groupId>
    <artifactId>test_01_helloworld</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <!-- 下面为添加的依赖内容，spring-boot-starter-web -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

第二步，在src/main/java目录下新建一个Java文件:

填写Package和Name，点击Finish，建立完成，而后编写该Java文件：

package com.xiaobaiai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@SpringBootApplication
@Controller
public class Test01HelloworldApplication {
    @RequestMapping("/")
    @ResponseBody
    public String index() {
        return "Hello World!";
    }

    public static void main(String[] args) {
        SpringApplication.run(Test01HelloworldApplication.class, args);
    }
}
💡 在STS中，包一键导入快捷键 Ctrl + Shift + o

3.1.3 运行Hell World Web应用

上述修改两个文件就完成一个基本的Hello World!级别应用，而后就能够运行了： 选中项目-->菜单栏Run-->Run (Spring boot App)或者直接到工具栏找到快捷按钮（绿色右箭头），点击。接下来就能够看到在STS中的console(控制台)中看到Web 服务启动的过程了，没有出现错误，Tomcat initialized with port(s): 8080 (http)，打开浏览器，输入http://localhost:8080回车可看到输出Hello World!，Demo成功：

3.2 使用Spring Initializr Website建立项目并导入

3.2.1 STS中的Spring Initializr

经过Spring Initializr咱们能够经过点击页面，选择咱们所须要的依赖项，最终生成项目配置文件和应用文件。通常IDE中也集成了Spring Initializr，如STS中新建一个Spring Starter Project就能够操做Spring Initializr，在下一小节中咱们将经过网站中的Spring Initializr来实现建立一个Web项目:

3.2.2 网站的中Spring Initializr

在浏览器中打开https://start.spring.io，输入项目相关信息，并选择Spring Boot及构建工具等，在Dependencies的Web栏中选中Spring Web，最后点击绿色按钮Generate - Ctrl按钮生成工程文件压缩包，放于你的工做目录中并解压，而后用STS导入该项目:

导入成功后，能够看到自动生成了上一小节中咱们建立的pom.xml和XXApplication.java文件以及测试文件XXApplicationTests.java，其中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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xiaobaiai</groupId>
    <artifactId>test_02_helloworld</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test_02_helloworld</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

一样地咱们把下面代码复制到Test02HelloworldApplication.java中(注意咱们的类名改了，不是Test01了):

package com.xiaobaiai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@SpringBootApplication
@Controller
public class Test02HelloworldApplication {
    @RequestMapping("/")
    @ResponseBody
    public String index() {
        return "Hello World!";
    }
    public static void main(String[] args) {
        SpringApplication.run(Test02HelloworldApplication.class, args);
    }
}

最后点击Run，到浏览器中输入http://localhost:8080回车可看到输出Hello World!。

3.3 基于Spring Boot CLI建立项目

上一篇中咱们已经介绍过Sping Boot CLI（命令行界面）这个工具了，它可用于快速使用Spring进行原型设计。使咱们能够运行Groovy脚本，接下来咱们实际操做一下。

3.3.1 安装Spring Boot CLI工具

从Spring软件存储库下载Spring CLI发行版，选择你工做的平台版本，这里选择了spring-boot-cli-2.2.0.RELEASE-bin.zip Windows版本：

下载好后，解压，而后配置好环境变量，则就安装成功，验证是否安装并配置好：

# 查看spring cli版本
$ spring --version
Spring CLI v2.2.0.RELEASE
# 查看spring全部帮助
$ spring --help
# 查看spring run命令帮助
$ spring help run
# 查看spring init命令帮助
$ spring help init
# 查看全部支持的dependencies，支持的工程类型(Project types，默认工程类型为marven-project)
$ spring init --list

$ spring init --list
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
:: Service capabilities ::  https://start.spring.io

Supported dependencies
+--------------------------------------+--------------------------------------------------------------+-------------------------------+
| Id                                   | Description                                                  | Required version              |
+--------------------------------------+--------------------------------------------------------------+-------------------------------+
......
| activemq                             | Spring JMS support with Apache ActiveMQ 'Classic'.           |                               |
| web                                  | Build web, including RESTful, applications using Spring MVC. |                               |
|                                      | Uses Apache Tomcat as the default embedded container.        |                               |
......
+--------------------------------------+--------------------------------------------------------------+-------------------------------+

Project types (* denotes the default)
+-----------------+------------------------------------------+-----------------------------+
| Id              | Description                              | Tags                        |
+-----------------+------------------------------------------+-----------------------------+
| gradle-build    | Generate a Gradle build file.            | build:gradle,format:build   |
| gradle-project  | Generate a Gradle based project archive. | build:gradle,format:project |
| maven-build     | Generate a Maven pom.xml.                | build:maven,format:build    |
| maven-project * | Generate a Maven based project archive.  | build:maven,format:project  |
+-----------------+------------------------------------------+-----------------------------+

Parameters
+-------------+------------------------------------------+------------------------------+
| Id          | Description                              | Default value                |
+-------------+------------------------------------------+------------------------------+
| artifactId  | project coordinates (infer archive name) | demo                         |
| bootVersion | spring boot version                      | 2.2.0.RELEASE                |
| description | project description                      | Demo project for Spring Boot |
| groupId     | project coordinates                      | com.example                  |
| javaVersion | language level                           | 1.8                          |
| language    | programming language                     | java                         |
| name        | project name (infer application name)    | demo                         |
| packageName | root package                             | com.example.demo             |
| packaging   | project packaging                        | jar                          |
| type        | project type                             | maven-project                |
| version     | project version                          | 0.0.1-SNAPSHOT               |
+-------------+------------------------------------------+------------------------------+

3.3.2 使用Spring Boot CLI工具建立Hell World应用

接下来，咱们直接使用Spring Boot CLI工具建立上述咱们的Hello World WEB应用。

# 建立项目name: test_03_helloworld
# groupId: com.xiaobaiai
# artifactId: test_03_helloworld
# language: java/groovy/kotlin
# boot-version: 2.2.0
# 构建工具类型: marven-project/marven-build/gradle-project/gradle-build
# 依赖项(dependencies)：web
# java-version: java(jdk)版本
# --package-name: 包名
# --packaging:打包方式jar/war
# --extract: 不加这个参数则建立出来的项目就是已经压缩过的，跟用Spring Initializr Website建立出来的同样
# 最后一个test_03_helloworld即指定目标生成目录
$ mkdir test_03_helloworld
$ cd test_03_helloworld
$ spring init -n test_03_helloworld -g com.xiaobaiai -a test_03_helloworld -l java -b 2.2.0.RELEASE -t maven-project -d web --extract -j 11 --package-name com.xiaobaiai --extract test_03_helloworld
💡 spring run命令只是针对Groovy语言的。

建立完成后，其实跟上述两种方式建立出来的工程是同样的，而后一样地，咱们去修改src/main/java/com/xiaobaiai/Test03HelloworldApplication.java这个文件，添加同样的内容，这里就不贴代码了（可使用文本编辑器如Vim/VS Code/Notepad++/Atom/Subline2等等）。

.
├── HELP.md
├── list
│   ├── HELP.md
│   ├── mvnw
│   ├── mvnw.cmd
│   ├── pom.xml
│   └── src
│       ├── main
│       └── test
├── mvnw
├── mvnw.cmd
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   └── resources
    └── test
        └── java
💡 用Spring Boot CLI工具建立出来生成的工程文件默认是在当前文件夹中，若是加了--extract参数，则全部文件都解压出来，所以须要预先创建一个工程目录再执行建立命令。固然也能够指定生成文件夹，则会建立项目的时候建立该文件夹并将项目文件都生成到该文件夹中。

💡 另外还可使用SDKMAN管理各类二进制SDK的多个版本，包括Groovy和Spring Boot CLI，具体的能够去官方文档了解。

接下来就是如何编译了。spring cli针对不一样类型语言的WEB应用编译方式是不同的，若是咱们建立了Groovy语言类型的项目，那么只须要用到spring run组合命令就能够了，可是这里选择了java语言类型，则须要结合mvn(marven的命令行工具)和java(jdk的命令行工具)了。首先确保这两个命令已经配置好了环境变量。

而后到项目根目录执行：

# spring-boot:run为Spring Boot Maven Plugin插件所支持，还有如spring-boot:repackage/spring-boot:start/spring-boot:stop/spring-boot:build-info。
$ mvn spring-boot:run

最后到浏览器中输入http://localhost:8080回车可看到输出Hello World!。

3.4 各建立项目方式比较

  • 使用CLI工具建立大项目仍是优势麻烦的，只是运行Groovy还能够选择一下
  • 使用SPring Initializr工具方便快速

4 Spring Boot应用是如何工做的？

上面是一个简单的WEB应用，一一讲述了几种建立方式，并在浏览器中输出了Hello World!，那么整个应用是怎么运做的呢？这一节咱们详细地来剖析下。

4.1 pom.xml

4.1.1 spring-boot-starter-parent

pom.xml是整个项目的核心配置文件，Marven的POM文件之间具备集成性，下面这段代码就表示POM文件继承自groupId为org.springframework.boot，artifactId为spring-boot-starter-parent，version为2.2.0.RELEASE的POM文件。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.0.RELEASE</version>
    <relativePath /> <!-- lookup parent from repository -->
</parent>

spring-boot-starter-parent项目是一个特殊的启动程序项目，为咱们的应用程序提供默认配置，并提供完整的依赖关系树以快速构建咱们的Spring Boot项目。它还为Maven插件提供了默认配置，例如maven-failsafe-plugin，maven-jar-plugin，maven-surefire-plugin，maven-war-plugin。咱们能够找到spring-boot-starter-parent-2.2.0.RELEASE.pom具体查看，如Windows系统中，该文件在C:\Users\{your username}\.m2\repository\org\springframework\boot\spring-boot-starter-parent\2.2.0.RELEASE\路径下。 Linux平台在用户目录~/.m2/repository/org/springframework\boot\spring-boot-starter-parent\2.2.0.RELEASE\路径下。打开该文件后，咱们能够看到spring-boot-starter-parent-2.2.0.RELEASE.pom又依赖了spring-boot-dependencies项目，这个文件里面定义了大部分底层依赖软件的版本号以及咱们上一节介绍的Spring boot核心模块，如spring-boot-actuator等。咱们能够从这个连接获取spring-boot-starter-parent的最新版本https://search.maven.org/classic/#search%7Cga%7C1%7Ca%3A%22spring-boot-starter-parent%22。

4.1.2 spring-boot-starter-web

再到咱们的应用这一层，咱们依赖了spring-boot-starter-web和spring-boot-starter-test（能够作单元测试）两个依赖。咱们能够经过STS能够看到两个依赖里又包含了哪些依赖，如spring-boot-starter-web里面依赖了tomcat(实际用的是spring boot内嵌的tomcat)、spring-web和spring-webmvc等。有了这些依赖其实就构成了咱们实现一个Web Server的基础。

另外，添加了父级依赖模块(spring-boot-starter-parent)后，在应用中添加其余依赖，咱们是不须要指定版本了，因此的依赖版本已经在父级依赖中获得了管理(固然，咱们也能够独立指定版本)。如：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

4.1.3 dependencyManagement标签自定义父级依赖以及其余属性自定义

咱们能够定义本身的一套父级版本依赖吗？固然是能够的，咱们只须要定义<dependencyManagement>标记里内容就能够了，相似spring-boot-dependencies的POM文件里所示同样:

<dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot</artifactId>
        <version>2.2.0.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
        <version>2.2.0.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test-autoconfigure</artifactId>
        <version>2.2.0.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-actuator</artifactId>
        <version>2.2.0.RELEASE</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-actuator-autoconfigure</artifactId>
        <version>2.2.0.RELEASE</version>
        
        ......
        
    </dependencies>
</dependencyManagement>

为了自定义父级依赖中其余属性（配置），咱们能够在相应位置从新去声明配置相关值，spring-boot-starter-parent经过其父级spring-boot-dependencies依赖使用属性来配置全部依赖项版本，Java版本和Maven插件版本等。所以，咱们只需更改相应的属性便可自定义控制这些配置。好比咱们想更改tomcat的版本，只须要在spring-boot-dependencies的POM文件中对应位置修改以下代码：

<properties>
    ......
    <tomcat.version>9.0.27</tomcat.version>
    ......
</properties>

4.1.4 自定义父级依赖

对于添加指定的父级依赖，而不是spring-boot-starter-parent，咱们能够彻底自定义配置咱们全部的依赖，那么咱们就须要配置相似spring-boot-starter-parent全部相关的内容，包括版本以及相关属性配置等。

4.1.5 Spring Boot Marven插件

pom.xml中还有这么一段代码：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

上面的配置就是Spring Boot Maven插件，Spring Boot Maven插件提供了许多方便的功能：

  • 把项目打包成一个可执行的超级JAR（uber-JAR）,包括把应用程序的全部依赖打入JAR文件内，并为JAR添加一个描述文件，其中的内容能让你用java -jar来运行应用程序。
  • 搜索public static void main()方法来标记为可运行类。

4.2 Spring Boot 注解(annotations)与应用入口

4.2.1 注解（annotations）

在咱们实现的简单Hello World Web项目中，咱们使用了几个注解，如代码中所示的SpringBootApplication和Controller：

@SpringBootApplication
@Controller
public class Test02HelloworldApplication {
    @RequestMapping("/")
    @ResponseBody
    public String index() {
        return "Hello World!";
    }
    public static void main(String[] args) {
        SpringApplication.run(Test02HelloworldApplication.class, args);
    }

}

咱们能够直接看到SpringBootApplication类中是什么内容，具体作了啥？它的定义以下：

@Target(ElementType.TYPE) // 元注解，指定了注解运用的地方，注解就被限定了运用的场景，此处限定为能够给一个类型进行注解，好比类、接口、枚举
@Retention(RetentionPolicy.RUNTIME)  // 元注解， 注解能够保留到程序运行的时候，它会被加载进入到 JVM 中，因此在程序运行时能够获取到它们
@Documented // 元注解，将注解中的元素包含到 Javadoc 中去
@Inherited // 元注解，超类被 @Inherited 注解过的注解进行注解的话，那么若是它的子类没有被任何注解应用的话，那么这个子类就继承了超类的注解。
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
@ConfigurationPropertiesScan
public @interface SpringBootApplication {
    ......
}

里面又有三个重要的注解：

1) @SpringBootConfiguration

该注解向类添加@Configuration注解，该注解将类标记为应用程序上下文的Bean定义的源。

2) @EnableAutoConfiguration

这告诉Spring Boot经过基于类路径设置，其余bean和各类属性设置添加bean，从而基于pom.xml中添加的依赖关系自动配置重要的bean定义。

3) @ComponentScan

该注解告诉Spring boot扫描基础包，查找其余的bean/组件，并对其进行配置。

4) @Controller : 该注解指定了当前类Test02HelloworldApplication充当MVC中控制器做用，调度程序扫描带此类注解的类以查找映射的方法，并检测@RequestMapping注解。

5)@RequestMapping : 你可使用@RequestMapping注解将URL（例如/appointments）映射到整个类或特定的处理方法上。一般，类级别的注解将特定的请求路径（或路径模式）映射到表单控制器上，其余方法级别的注解使特定的HTTP请求方法（GET、POST等）的主映射范围变窄，或一个HTTP请求参数条件。下面是一个Controller + RequestMapping的示例：

@Controller
@RequestMapping("/appointments")
public class AppointmentsController {

    private final AppointmentBook appointmentBook;

    @Autowired
    public AppointmentsController(AppointmentBook appointmentBook) {
        this.appointmentBook = appointmentBook;
    }

    @RequestMapping(method = RequestMethod.GET)
    public Map<String, Appointment> get() {
        return appointmentBook.getAppointmentsForToday();
    }

    @RequestMapping(value="/{day}", method = RequestMethod.GET)
    public Map<String, Appointment> getForDay(@PathVariable @DateTimeFormat(iso=ISO.DATE) Date day, Model model) {
        return appointmentBook.getAppointmentsForDay(day);
    }

    @RequestMapping(value="/new", method = RequestMethod.GET)
    public AppointmentForm getNewForm() {
        return new AppointmentForm();
    }

    @RequestMapping(method = RequestMethod.POST)
    public String add(@Valid AppointmentForm appointment, BindingResult result) {
        if (result.hasErrors()) {
            return "appointments/new";
        }
        appointmentBook.addAppointment(appointment);
        return "redirect:/appointments";
    }
}

在类级别上，若是没有@RequestMapping，想URL路径都是绝对的，而不是相对的，如咱们Hello World WEB项目里代码所示。而上面的示例都是相对appointments路径。

4.2.2 应用入口及应用配置

在上一节中咱们也提到了SpringApplication类的做用，只是没有实际项目来体会，这一节有了Hello World程序做为示例，咱们再次来总结它的做用，进一步加深理解：

  • @SpringBootApplication是Sprnig Boot项目的核心注解，主要目的是开启自动配置，包括建立上下文内容，刷新应用上下文，并加载全部单例Bean
  • 在大多数状况下，能够直接从主方法中调用静态run(Class, String [])方法来引导应用程序
  • 能够在应用运行以前建立和定制SpringApplication实例，如：
SpringApplication springApplication = new SpringApplication(SpringbootActionApplication.class);
// 关闭应用启动时的Banner，以下：
//  .   ____          _            __ _ _
// /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
//( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
// \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
//  '  |____| .__|_| |_|_| |_\__, | / / / /
// =========|_|==============|___/=/_/_/_/
// :: Spring Boot ::        (v2.2.0.RELEASE)
springApplication.setBannerMode(Banner.Mode.OFF);
springApplication.run(args);

在修改应用程序默认配置上，咱们还能够经过src/main/resources/application.properties这个文件来配置。里面内容默认为空。常见配置有：

# 指定应用名（该名字在Spring Cloud应用中会被注册为服务名）
spring.application.name=hello
# 关闭Banner
spring.main.banner-mode=off
# 修改WEB端口8080为8081
server.port = 8081
# 修改日志级别和中控台日志保存文件路径
# 全部文件日志打印级别为WARN
logging.level.root=WARN
# 指定包或具体类打印日志级别， 如logging.level.com.xiaobaiai=DEBUG
logging.level.{some.package.path}=DEBUG
# 默认日志都会打印到控制台，你能够设定打印到文件，即直接指定路径和文件名
logging.file=\path_to\logfile.log
# 也能够只指定路径，默认为spring.log
logging.file.path=C:\\Work\\sts4\\test_02_helloworld\\logs
# 自定义属性值，而后在应用程序中经过@Value注解来赋值，
# @Value(value=”${com.xiaobaiai.name}”)
# private String name;
com.xiaobaiai.name="小白AI"

固然咱们还能够在配置参数与配置参数之间进行引用，还可使用指定配置参数文件，或者经过定义专用类来导入配置，这里就不展开了。

5 总结

这一节内容有点长，可是总的来讲就是讲述了三种方式去建立一个Hello World WEB 项目，而后对这个WEB项目从pom.xml文件开始进行了分析，讲述了父级依赖，以及应用依赖和具体的版本依赖是如何实现的，最后对Spring Boot的应用入口和重要的几个注解也进行了讲解。完成这些，咱们如今基本上对Spring Boot应用有了基本的了解了，接下来咱们继续。

6 参考资料

本文属于原创，转载注明出处，欢迎关注CSDNfreeape或微信小程序小白AI博客 微信公众号小白AI或者网站 https://xiaobaiai.net

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程