Spring Boot 简明教程

Spring Boot - Bootstrapping

本章将向您解释如何在 Spring Boot 应用程序上执行启动。

This chapter will explain you how to perform bootstrapping on a Spring Boot application.

Spring Initializer

一种启动 Spring Boot 应用程序的方法是使用 Spring Initializer。为此，您将必须访问 Spring Initializer 网页 www.start.spring.io 并选择您的构建、Spring Boot 版本和平台。此外，您还需要提供一个组、制品和运行应用程序所需的依赖项。

One of the ways to Bootstrapping a Spring Boot application is by using Spring Initializer. To do this, you will have to visit the Spring Initializer web page www.start.spring.io and choose your Build, Spring Boot Version and platform. Also, you need to provide a Group, Artifact and required dependencies to run the application.

观察以下屏幕截图，该屏幕截图显示了我们添加 spring-boot-starter-web 依赖项来编写 REST 端点的示例。

Observe the following screenshot that shows an example where we added the spring-boot-starter-web dependency to write REST Endpoints.

在您提供组、制品、依赖项、构建项目、平台和版本后，单击 Generate Project 按钮。zip 文件将下载，并且文件将被提取。

Once you provided the Group, Artifact, Dependencies, Build Project, Platform and Version, click Generate Project button. The zip file will download and the files will be extracted.

本节向您解释使用 Maven 和 Gradle 的示例。

This section explains you the examples by using both Maven and Gradle.

Maven

下载项目后，解压该文件。现在，你的 pom.xml 文件看起来如下所示 −

After you download the project, unzip the file. Now, your pom.xml file looks as shown below −

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>demo</name>
   <description>Demo project for Spring Boot</description>

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

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</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>
      </dependency>
   </dependencies>

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

</project>

Gradle

下载项目后，解压该文件。现在，你的 build.gradle 文件看起来如下所示 −

Once you download the project, unzip the file. Now your build.gradle file looks as shown below −

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Class Path Dependencies

Spring Boot 提供许多 Starters ，用于向我们的类路径中添加 jar。例如，对于编写 Rest 端点，我们需要在我们的类路径中添加 spring-boot-starter-web 依赖项。观察下面显示的代码以获得更好的理解 −

Spring Boot provides a number of Starters to add the jars in our class path. For example, for writing a Rest Endpoint, we need to add the spring-boot-starter-web dependency in our class path. Observe the codes shown below for a better understanding −

Maven dependency

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

Gradle dependency

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Main Method

spring boot 应用程序类应该编写这个主方法。这个类应该使用 @SpringBootApplication 进行注释。这是 spring boot 应用程序开始的入口点。你可以在使用默认包的 src/java/main 目录中找到主类文件。

The main method should be writing the Spring Boot Application class. This class should be annotated with @SpringBootApplication. This is the entry point of the spring boot application to start. You can find the main class file under src/java/main directories with the default package.

在这个例子中，主类文件位于使用默认包 com.tutorialspoint.demo 的 src/java/main 目录中。观察这里展示的代码以获得更好的理解 −

In this example, the main class file is located at the src/java/main directories with the default package com.tutorialspoint.demo. Observe the code shown here for a better understanding −

package com.tutorialspoint.demo;

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

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Write a Rest Endpoint

要在 spring boot 应用程序主类文件中编写一个简单的 Hello Word Rest 端点，请遵循以下步骤 −

To write a simple Hello World Rest Endpoint in the Spring Boot Application main class file itself, follow the steps shown below −

Firstly, add the @RestController annotation at the top of the class.
Now, write a Request URI method with @RequestMapping annotation.
Then, the Request URI method should return the Hello World string.

现在，你的 spring boot 应用程序主类文件将看起来像下面给出的代码中所示 −

Now, your main Spring Boot Application class file will look like as shown in the code given below −

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController

public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

Create an Executable JAR

让我们使用如下所示在命令提示符中使用 Maven 和 Gradle 命令创建一个可执行 JAR 文件来运行 spring boot 应用程序 −

Let us create an executable JAR file to run the Spring Boot application by using Maven and Gradle commands in the command prompt as shown below −

使用 Maven 命令 mvn clean install 如下所示 −

Use the Maven command mvn clean install as shown below −

执行命令后，你可以在命令提示符中看到 BUILD SUCCESS 消息，如下所示 −

After executing the command, you can see the BUILD SUCCESS message at the command prompt as shown below −

使用 Gradle 命令 gradle clean build 如下所示 −

Use the Gradle command gradle clean build as shown below −

执行命令后，你可以在命令提示符中看到 BUILD SUCCESSFUL 消息，如下所示 −

After executing the command, you can see the BUILD SUCCESSFUL message in the command prompt as shown below −

build successful message in command prompt

Run Hello World with Java

创建可执行 JAR 文件后，你可以在以下目录中找到它。

Once you have created an executable JAR file, you can find it under the following directories.

对于 Maven，你可以在如下所示的 target 目录中找到 JAR 文件 −

For Maven, you can find the JAR file under the target directory as shown below −

对于 Gradle，你可以在如下所示的 build/libs 目录中找到 JAR 文件 −

For Gradle, you can find the JAR file under the build/libs directory as shown below −

现在，使用命令 java –jar <JARFILE> 运行 JAR 文件。请注意，在上面的示例中，JAR 文件被命名为 demo-0.0.1-SNAPSHOT.jar

Now, run the JAR file by using the command java –jar <JARFILE>. Observe that in the above example, the JAR file is named demo-0.0.1-SNAPSHOT.jar

一旦运行 jar 文件，你可以在控制台窗口中看到输出，如下所示 −

Once you run the jar file, you can see the output in the console window as shown below −

现在查看控制台，Tomcat 已在端口 8080 (http) 上启动。现在转到 Web 浏览器并输入 URL http://localhost:8080/ ，你将能看到如下所示的输出 −

Now, look at the console, Tomcat started on port 8080 (http). Now, go to the web browser and hit the URL http://localhost:8080/ and you can see the output as shown below −