spring_reference/all in one/getting_started.md

493 lines
25 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

### 开始
如果你想从总体上对Spring Boot或Spring入门本章节就是为你准备的在这里我们将回答基本的"what?""how?"和"why?"问题。你会发现一个温雅的Spring Boot介绍及安装指南。然后我们构建第一个Spring Boot应用并讨论一些我们需要遵循的核心原则。
### Spring Boot介绍
Spring Boot使开发独立的产品级别的基于Spring的应用变得非常简单你只需"just run"。
我们为Spring平台及第三方库提供开箱即用的设置这样你就可以有条不紊地开始。多数Spring Boot应用需要很少的Spring配置。
你可以使用Spring Boot创建Java应用并使用`java -jar`启动它或采用传统的war部署方式。我们也提供了一个运行"spring脚本"的命令行工具。
我们主要的目标是:
- 为所有的Spring开发提供一个从根本上更快的和广泛使用的入门经验。
- 开箱即用,但你可以通过不采用默认设置来摆脱这种方式。
- 提供一系列大型项目常用的非功能性特征(比如,内嵌服务器,安全,指标,健康检测,外部化配置)。
- 绝对不需要代码生成及XML配置。
### 系统要求
默认情况下Spring Boot 1.3.0.BUILD-SNAPSHOT 需要Java和Spring框架4.1.3或以上。你可以在Java6下使用Spring Boot不过需要添加额外配置。具体参考[Section 73.9, “How to use Java 6” ](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#howto-use-java-6)。构建环境明确支持的有Maven3.2+和Gradle1.12+)。
**注**尽管你可以在Java6或Java7环境下使用Spring Boot通常我们建议你如果可能的话就使用Java8。
* Servlet容器
下列内嵌容器支持开箱即用out of the box
|名称|Servlet版本|Java版本|
|--------|:-------|:-------|
|Tomcat 8|3.1|Java 7+|
|Tomcat 7|3.0|Java 6+|
|Jetty 9|3.1|Java 7+|
|Jetty 8|3.0|Java 6+|
|Undertow 1.1|3.1|Java 7+|
你也可以将Spring Boot应用部署到任何兼容Servlet 3.0+的容器。
### Spring Boot安装
Spring Boot可以跟典型的Java开发工具一块使用或安装为一个命令行工具。不管怎样你将需要安装[Java SDK v1.6 ](http://www.java.com/)或更高版本。在开始之前你需要检查下当前安装的Java版本
```shell
$ java -version
```
如果你是一个Java新手或你只是想体验一下Spring Boot你可能想先尝试[Spring Boot CLI](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-the-cli),否则继续阅读经典地安装指南。
**注**尽管Spring Boot兼容Java 1.6如果可能的话你应该考虑使用Java最新版本。
* 为Java开发者准备的安装指南
你可以以和任何标准Java库相同的方式使用Spring Boot。只需要简单地在你的classpath下包含正确的`spring-boot-*.jar`文件。Spring Boot不需要集成任何特殊的工具所以你可以使用任何IDE或文本编辑器Spring Boot应用也没有什么特殊之处所以你可以像任何其他Java程序那样运行和调试。
尽管你可以拷贝Spring Boot jars不过我们通常推荐你使用一个支持依赖管理的构建工具比如Maven或Gradle
* Maven安装
Spring Boot兼容Apache Maven 3.2或更高版本。如果没有安装Maven你可以参考[maven.apache.org](http://maven.apache.org/)指南。
**注**在很多操作系统上你可以通过一个包管理器安装Maven。如果你是一个OSX Homebrew用户可以尝试`brew install maven`。Ubuntu用户可以运行`sudo apt-get install maven`。
Spring Boot依赖的`groupId`为`org.springframework.boot`。通常你的Maven POM文件需要继承`spring-boot-starter-parent`,然后声明一个或多个[“Starter POMs”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#using-boot-starter-poms)依赖。Spring Boot也提供了一个用于创建可执行jars的[Maven插件](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#build-tool-plugins-maven-plugin)。
下面是一个典型的`pom.xml`文件:
```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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- Inherit defaults from Spring Boot -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.0.BUILD-SNAPSHOT</version>
</parent>
<!-- Add typical dependencies for a web application -->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<!-- Package as an executable jar -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<!-- Add Spring repositories -->
<!-- (you don't need this if you are using a .RELEASE version) -->
<repositories>
<repository>
<id>spring-snapshots</id>
<url>http://repo.spring.io/snapshot</url>
<snapshots><enabled>true</enabled></snapshots>
</repository>
<repository>
<id>spring-milestones</id>
<url>http://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-snapshots</id>
<url>http://repo.spring.io/snapshot</url>
</pluginRepository>
<pluginRepository>
<id>spring-milestones</id>
<url>http://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>
</project>
```
**注**`spring-boot-starter-parent`是使用Spring Boot的一个不错的方式但它不总是合适的。有时你需要继承一个不同的parent POM或者你可能只是不喜欢我们的默认配置。查看[Section 13.1.2, “Using Spring Boot without the parent POM”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#using-boot-maven-without-a-parent)获取使用`import`的替代解决方案。
* Gradle安装
Spring Boot兼容Gradle 1.12或更高版本。如果没有安装Gradle你可以参考[www.gradle.org](http://www.gradle.org/)上的指南。
Spring Boot依赖可以使用`org.springframework.boot` `group`来声明。通常,你的项目将声明一个或多个[“Starter POMs”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#using-boot-starter-poms)依赖。Spring Boot提供一个用于简化依赖声明和创建可执行jars的有用的[Gradle插件](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#build-tool-plugins-gradle-plugin)。
**注**当你需要构建一个项目时Gradle Wrapper提供一个获取Gradle的漂亮方式。它是一个伴随你的代码一块提交的小脚本和库用于启动构建进程。具体参考[Gradle Wrapper](www.gradle.org/docs/current/userguide/gradle_wrapper.html)。
下面是一个典型的`build.gradle`文件:
```gradle
buildscript {
repositories {
jcenter()
maven { url "http://repo.spring.io/snapshot" }
maven { url "http://repo.spring.io/milestone" }
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:1.3.0.BUILD-SNAPSHOT")
}
}
apply plugin: 'java'
apply plugin: 'spring-boot'
jar {
baseName = 'myproject'
version = '0.0.1-SNAPSHOT'
}
repositories {
jcenter()
maven { url "http://repo.spring.io/snapshot" }
maven { url "http://repo.spring.io/milestone" }
}
dependencies {
compile("org.springframework.boot:spring-boot-starter-web")
testCompile("org.springframework.boot:spring-boot-starter-test")
}
```
* Spring Boot CLI安装
Spring Boot是一个命令行工具用于使用Spring进行快速原型搭建。它允许你运行[Groovy](http://groovy.codehaus.org/)脚本这意味着你可以使用类Java的语法并且没有那么多的模板代码。
你没有必要为了使用Spring Boot而去用CLI但它绝对是助力Spring应用的最快方式。
- 手动安装
你可以从Spring软件仓库下载Spring CLI分发包
1. [spring-boot-cli-1.3.0.BUILD-SNAPSHOT-bin.zip](http://repo.spring.io/snapshot/org/springframework/boot/spring-boot-cli/1.3.0.BUILD-SNAPSHOT/spring-boot-cli-1.3.0.BUILD-SNAPSHOT-bin.zip)
2. [spring-boot-cli-1.3.0.BUILD-SNAPSHOT-bin.tar.gz](http://repo.spring.io/snapshot/org/springframework/boot/spring-boot-cli/1.3.0.BUILD-SNAPSHOT/spring-boot-cli-1.3.0.BUILD-SNAPSHOT-bin.tar.gz)
不稳定的[snapshot分发包](http://repo.spring.io/snapshot/org/springframework/boot/spring-boot-cli/)也能获取到。
下载完成后,遵循解压后的存档里的[INSTALL.txt](http://raw.github.com/spring-projects/spring-boot/master/spring-boot-cli/src/main/content/INSTALL.txt)操作指南进行安装。一般而言,在`.zip`文件的`bin/`目录下存在一个`spring`脚本Windows下是`spring.bat`),或者使用`java -jar`来运行一个`.jar`文件该脚本会帮你确定classpath被正确设置
- 使用GVM安装
GVMGroovy环境管理器可以用来管理多种不同版本的Groovy和Java二进制包包括Groovy自身和Spring Boot CLI。可以从[gvmtool.net](http://gvmtool.net/)获取`gvm`并使用以下命令安装Spring Boot
```shell
$ gvm install springboot
$ spring --version
Spring Boot v1.3.0.BUILD-SNAPSHOT
```
如果你正在为CLI开发新的特性并想轻松获取你刚构建的版本可以使用以下命令
```shell
$ gvm install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-1.3.0.BUILD-SNAPSHOT-bin/spring-1.3.0.BUILD-SNAPSHOT/
$ gvm use springboot dev
$ spring --version
Spring CLI v1.3.0.BUILD-SNAPSHOT
```
这将会在你的gvm仓库中安装一个名叫`dev`的本地`spring`实例。它指向你的目标构建位置所以每次你重新构建Spring Boot`spring`将会是最新的。
你可以通过以下命令来验证:
```shell
$ gvm ls springboot
================================================================================
Available Springboot Versions
================================================================================
> + dev
* 1.3.0.BUILD-SNAPSHOT
================================================================================
+ - local version
* - installed
> - currently in use
================================================================================
```
- 使用OSX Homebrew进行安装
如果你的环境是Mac并使用[Homebrew](http://brew.sh/)想要安装Spring Boot CLI只需如下操作
```shell
$ brew tap pivotal/tap
$ brew install springboot
```
Homebrew将把`spring`安装到`/usr/local/bin`下。
**注**如果该方案不可用可能是因为你的brew版本太老了。你只需执行`brew update`并重试即可。
- 使用MacPorts进行安装
如果你的环境是Mac并使用[MacPorts](http://www.macports.org/)想要安装Spring Boot CLI只需如下操作
```shell
$ sudo port install spring-boot-cli
```
- 命令行实现
Spring Boot CLI启动脚本为[BASH](http://en.wikipedia.org/wiki/Bash_%28Unix_shell%29)和[zsh](http://en.wikipedia.org/wiki/Zsh) shells提供完整的命令行实现。你可以在任何shell中`source`脚本(名称也是`spring`或将它放到你个人或系统范围的bash实现初始化中。在一个Debian系统里系统范围的脚本位于`/shell-completion/bash`下当一个新的shell启动时该目录下的所有脚本都被执行。想要手动运行该脚本例如你已经使用`GVM`进行安装了:
```shell
$ . ~/.gvm/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
grab help jar run test version
```
**注**如果你使用Homebrew或MacPorts安装Spring Boot CLI命令行实现脚本会自动注册到你的shell。
- Spring CLI示例快速入门
下面是一个相当简单的web应用你可以用它测试你的安装是否成功。创建一个名叫`app.groovy`的文件:
```groovy
@RestController
class ThisWillActuallyRun {
@RequestMapping("/")
String home() {
"Hello World!"
}
}
```
然后简单地从一个shell中运行它
```shell
$ spring run app.groovy
```
**注**:当你首次运行该应用时将会花费一点时间,因为需要下载依赖。后续运行将会快很多。
在你最喜欢的浏览器中打开[localhost:8080](localhost:8080),然后你应该看到以下输出:
```java
Hello World!
```
### 从Spring Boot早期版本升级
如果你正在升级一个Spring Boot早期版本查看下放在[project wiki](http://github.com/spring-projects/spring-boot/wiki)上的"release notes"。你会发现每次发布的更新指南和一个"new and noteworthy"特性列表。
想要升级一个已安装的CLI你需要使用合适的包管理命令例如`brew upgrade`或如果你是手动安装CLI按照[standard instructions](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation)操作并记得更新你的`PATH`环境变量以移除任何老的引用。
### 开发你的第一个Spring Boot应用
让我们使用Java开发一个简单的"Hello World!" web应用来强调下Spring Boot的一些关键特性。我们将使用Maven构建该项目因为大多数IDEs都支持它。
**注**[spring.io](http://spring.io/)网站包含很多使用Spring Boot的"入门"指南。如果你正在找特定问题的解决方案,可以先去那瞅瞅。
在开始前你需要打开一个终端检查是否安装可用的Java版本和Maven
```shell
$ java -version
java version "1.7.0_51"
Java(TM) SE Runtime Environment (build 1.7.0_51-b13)
Java HotSpot(TM) 64-Bit Server VM (build 24.51-b03, mixed mode)
```
```shell
$ mvn -v
Apache Maven 3.2.3 (33f8c3e1027c3ddde99d3cdebad2656a31e8fdf4; 2014-08-11T13:58:10-07:00)
Maven home: /Users/user/tools/apache-maven-3.1.1
Java version: 1.7.0_51, vendor: Oracle Corporation
```
**注**:该示例需要创建自己的文件夹。后续的操作假设你已创建一个合适的文件夹,并且它是你的“当前目录”。
* 创建POM
我们需要以创建一个Maven `pom.xml`文件作为开始。该`pom.xml`是用来构建项目的处方。打开你最喜欢的文本编辑器,然后添加以下内容:
```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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.3.0.BUILD-SNAPSHOT</version>
</parent>
<!-- Additional lines to be added here... -->
<!-- (you don't need this if you are using a .RELEASE version) -->
<repositories>
<repository>
<id>spring-snapshots</id>
<url>http://repo.spring.io/snapshot</url>
<snapshots><enabled>true</enabled></snapshots>
</repository>
<repository>
<id>spring-milestones</id>
<url>http://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-snapshots</id>
<url>http://repo.spring.io/snapshot</url>
</pluginRepository>
<pluginRepository>
<id>spring-milestones</id>
<url>http://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>
</project>
```
这会给你一个可运转的构建,你可以通过运行`mvn package`测试它(现在你可以忽略"jar将是空的-没有包含任何内容!"的警告)。
**注**目前你可以将该项目导入一个IDE大多数现代的Java IDE都包含对Maven的内建支持。简单起见我们将继续使用普通的文本编辑器完成该示例。
* 添加classpath依赖
Spring Boot提供很多"Starter POMs"这能够让你轻松的将jars添加到你的classpath下。我们的示例程序已经在POM的`partent`节点使用了`spring-boot-starter-parent`。`spring-boot-starter-parent`是一个特殊的starter它提供了有用的Maven默认设置。同时它也提供了一个`dependency-management`节点这样对于”blessed“依赖你可以省略`version`标记。
其他的”Starter POMs“简单的提供依赖这些依赖可能是你开发特定类型的应用时需要的。由于正在开发一个web应用我们将添加一个`spring-boot-starter-web`依赖-但在此之前,让我们看下目前所拥有的:
```shell
$ mvn dependency:tree
[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT
```
`mvn dependency:tree`命令以树形表示来打印你的项目依赖。你可以看到`spring-boot-starter-parent`本身并没有提供依赖。编辑我们的`pom.xml`,并在`parent`节点下添加`spring-boot-starter-web`依赖:
```xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
```
如果再次运行`mvn dependency:tree`你将看到现在有了一些其他依赖包括Tomcat web服务器和Spring Boot自身。
* 编写代码
为了完成应用程序我们需要创建一个单独的Java文件。Maven默认会编译`src/main/java`下的源码,所以你需要创建那样的文件结构,然后添加一个名为`src/main/java/Example.java`的文件:
```java
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
@RestController
@EnableAutoConfiguration
public class Example {
@RequestMapping("/")
String home() {
return "Hello World!";
}
public static void main(String[] args) throws Exception {
SpringApplication.run(Example.class, args);
}
}
```
尽管这里没有太多代码,但很多事情正在发生。让我们分步探讨重要的部分。
* @RestController和@RequestMapping注解
我们的`Example`类上使用的第一个注解是`@RestController`。这被称为一个构造型stereotype注解。它为阅读代码的人们提供建议。对于Spring该类扮演了一个特殊角色。在本示例中我们的类是一个web `@Controller`所以当处理进来的web请求时Spring会询问它。
`@RequestMapping`注解提供路由信息。它告诉Spring任何来自"/"路径的HTTP请求都应该被映射到`home`方法。`@RestController`注解告诉Spring以字符串的形式渲染结果并直接返回给调用者。
**注**`@RestController`和`@RequestMapping`注解是Spring MVC注解它们不是Spring Boot的特定部分。具体查看Spring参考文档的[MVC章节](http://docs.spring.io/spring/docs/4.1.5.RELEASE/spring-framework-reference/htmlsingle#mvc)。
* @EnableAutoConfiguration注解
第二个类级别的注解是`@EnableAutoConfiguration`。这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于`spring-boot-starter-web`添加了Tomcat和Spring MVC所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。
**Starter POMs和Auto-Configuration**设计auto-configuration的目的是更好的使用"Starter POMs"但这两个概念没有直接的联系。你可以自由地挑选starter POMs以外的jar依赖并且Spring Boot将仍旧尽最大努力去自动配置你的应用。
* main方法
我们的应用程序最后部分是`main`方法。这只是一个标准的方法它遵循Java对于一个应用程序入口点的约定。我们的main方法通过调用`run`将业务委托给了Spring Boot的`SpringApplication`类。`SpringApplication`将引导我们的应用启动Spring相应地启动被自动配置的Tomcat web服务器。我们需要将`Example.class`作为参数传递给`run`方法来告诉`SpringApplication`谁是主要的Spring组件。为了暴露任何的命令行参数`args`数组也会被传递过去。
### 运行示例
到此我们的应用应该可以工作了。由于使用了`spring-boot-starter-parent` POM这样我们就有了一个非常有用的`run`目标,我们可以用它启动程序。在项目根目录下输入`mvn spring-boot:run`来启动应用:
```shell
$ mvn spring-boot:run
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.3.0.BUILD-SNAPSHOT)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.222 seconds (JVM running for 6.514)
```
如果使用一个浏览器打开[localhost:8080](http://localhost:8080),你应该可以看到以下输出:
```shell
Hello World!
```
点击`ctrl-c`温雅地关闭应用程序。
### 创建一个可执行jar
让我们通过创建一个完全自包含的可执行jar文件来结束我们的示例该jar文件可以在生产环境运行。可执行jars有时候被成为胖jars "fat jars"是包含你的编译后的类和你的代码运行所需的依赖jar的存档。
**可执行jars和Java**Java没有提供任何标准的加载内嵌jar文件即jar文件中还包含jar文件的方法。如果你想发布一个自包含的应用这就是一个问题。为了解决该问题很多开发者采用"共享的"jars。一个共享的jar简单地将来自所有jars的类打包进一个单独的“超级jar”。采用共享jar方式的问题是很难区分在你的应用程序中可以使用哪些库。在多个jars中如果存在相同的文件名但内容不一样也会是一个问题。Spring Boot采取一个[不同的途径](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#executable-jar)并允许你真正的内嵌jars。
为了创建可执行的jar需要将`spring-boot-maven-plugin`添加到我们的`pom.xml`中。在`dependencies`节点下插入以下内容:
```xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
```
**注**`spring-boot-starter-parent` POM包含用于绑定`repackage`目标的`<executions>`配置。如果你不使用parent POM你将需要自己声明该配置。具体参考[插件文档](http://docs.spring.io/spring-boot/docs/1.3.0.BUILD-SNAPSHOT/maven-plugin/usage.html)。
保存你的`pom.xml`,然后从命令行运行`mvn package`
```shell
$ mvn package
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:1.3.0.BUILD-SNAPSHOT:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
```
如果查看`target`目录,你应该看到`myproject-0.0.1-SNAPSHOT.jar`。该文件应该有10Mb左右的大小。如果想偷看内部结构你可以运行`jar tvf`
```shell
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
```
在`target`目录下,你应该也能看到一个很小的名为`myproject-0.0.1-SNAPSHOT.jar.original`的文件。这是在Spring Boot重新打包前Maven创建的原始jar文件。
为了运行该应用程序,你可以使用`java -jar`命令:
```shell
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.3.0.BUILD-SNAPSHOT)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.536 seconds (JVM running for 2.864)
```
和以前一样,点击`ctrl-c`来温柔地退出程序。