Spring Boot provides a number of “Starters” that let you add     
jars to your classpath. Our sample application has already     
used spring-boot-starter-parent in the parent section of the POM.     
The spring-boot-starter-parent is a special starter that provides     
useful Maven defaults. It also provides a dependency-management     
section so that you can omit version tags for “blessed” dependencies.

Other “Starters” provide dependencies that you are likely to need     
when developing a specific type of application. Since we are     
developing a web application, we add a spring-boot-starter-web     
dependency. Before that, we can look at what we currently have     
by running the following command:

The mvn dependency:tree command prints a tree representation of     
your project dependencies. You can see that spring-boot-starter-parent     
provides no dependencies by itself. To add the necessary dependencies,     
edit your pom.xml and add the spring-boot-starter-web dependency     
immediately below the parent section:

If you run mvn dependency:tree again, you see that there are now a     
number of additional dependencies, including the Tomcat web server     
and Spring Boot itself.

We need to start by creating a Maven pom.xml file. The pom.xml is     
the recipe that is used to build your project. Open your favorite     
text editor and add the following:

The preceding listing should give you a working build. You can     
test it by running mvn package (for now, you can ignore the “jar     
will be empty - no content was marked for inclusion!” warning).

At this point, you could import the project into an IDE (most     
modern Java IDEs include built-in support for Maven). For simplicity,     
we continue to use a plain text editor for this example.

The Spring Boot CLI (Command Line Interface) is a command line tool    
that you can use to quickly prototype with Spring. It lets you     
run Groovy scripts, which means that you have a familiar Java-like     
syntax without so much boilerplate code.
You do not need to use the CLI to work with Spring Boot, but     
it is definitely the quickest way to get a Spring application     
off the ground.

You can download the Spring CLI distribution from the Spring     
software repository:
	•	spring-boot-cli-2.1.0.BUILD-SNAPSHOT-bin.zip
	•	spring-boot-cli-2.1.0.BUILD-SNAPSHOT-bin.tar.gz
Cutting edge snapshot distributions are also available.
Once downloaded, follow the INSTALL.txt instructions from the     
unpacked archive. In summary, there is a spring script (spring.bat     
for Windows) in a bin/directory in the .zip file. Alternatively,     
you can use java -jar with the .jar file (the script helps you to     
be sure that the classpath is set correctly).

SDKMAN! (The Software Development Kit Manager) can be used for     
managing multiple versions of various binary SDKs, including Groovy     
and the Spring Boot CLI. Get SDKMAN! from sdkman.io and install     
Spring Boot by using the following commands:

If you develop features for the CLI and want easy access     
to the version you built, use the following commands:

The preceding instructions install a local instance of spring called the dev instance. It points at your target build location, so every time you rebuild Spring Boot,spring is up-to-date.
You can see it by running the following command:

If you are on a Mac and use Homebrew, you can install the     
Spring Boot CLI by using the following commands:

Homebrew installs spring to /usr/local/bin.

If you do not see the formula, your installation of brew     
might be out-of-date. In that case, run brew update and try again.

If you are on a Mac and use MacPorts, you can install the     
Spring Boot CLI by using the following command:

The Spring Boot CLI includes scripts that provide command     
completion for the BASH and zsh shells. You can source     
the script (also named spring) in any shell or put it in     
your personal or system-wide bash completion initialization.     
On a Debian system, the system-wide scripts are in     
/shell-completion/bash and all scripts in that directory     
are executed when a new shell starts. For example, to run     
the script manually if you have installed by using SDKMAN!,      
use the following commands:

If you install the Spring Boot CLI by using Homebrew or MacPorts,     
the command-line completion scripts are automatically registered     
with your shell.

You can use the following web application to test your installation.     
To start, create a file called app.groovy, as follows:

Then run it from a shell, as follows:

The first run of your application is slow, as dependencies     
are downloaded. Subsequent runs are much quicker.

Open localhost:8080 in your favorite web browser.     
You should see the following output:

Hello World!

If you are upgrading from an earlier release of Spring Boot, check     
the “migration guide” on the project wiki that provides detailed     
upgrade instructions. Check also the“release notes” for a list of     
“new and noteworthy” features for each release.

To upgrade an existing CLI installation, use the appropriate     
package manager command (for example, brew upgrade) or, if     
you manually installed the CLI, follow thestandard instructions,     
remembering to update your PATH environment variable to     
remove any older references.

This section describes how to develop a simple “Hello World!” web     
application that highlights some of Spring Boot’s key features. We      
use Maven to build this project, since most IDEs support it.

The spring.io web site contains many “Getting Started” guides that     
use Spring Boot. If you need to solve a specific problem, check     
there first.You can shortcut the steps below by going to     
start.spring.io and choosing the "Web" starter from the     
dependencies searcher. Doing so generates a new project structure     
so that you can start coding right away. Check the Spring Initializr     
documentation for more details.

Before we begin, open a terminal and run the following commands    
to ensure that you have valid versions of Java and Maven installed:

Spring Boot can be used with “classic” Java development tools     
or installed as a command line tool. Either way, you need     
Java SDK v1.8 or higher. Before you begin, you should check     
your current Java installation by using the following command:    
$ java -version    
If you are new to Java development or if you want to experiment     
with Spring Boot, you might want to try the Spring Boot CLI     
(Command Line Interface) first. Otherwise, read on for “classic”     
installation instructions.

You can use Spring Boot in the same way as any standard Java library.    
To do so, include the appropriate spring-boot-*.jar files on your    
classpath. Spring Boot does not require any special tools integration,    
so you can use any IDE or text editor. Also, there is nothing special    
about a Spring Boot application, so you can run and debug a     
Spring Boot application as you would any other Java program.
    
Although you could copy Spring Boot jars, we generally recommend     
that you use a build tool that supports dependency management (such     
as Maven or Gradle).

Spring Boot is compatible with Apache Maven 3.2 or above. If you do    
not already have Maven installed, you can follow the instructions at maven.apache.org.

On many operating systems, Maven can be installed with a package     
manager. If you use OSX Homebrew, try brew install maven.     
Ubuntu users can run sudo apt-get install maven. Windows users     
with Chocolatey can run choco install maven from an elevated     
(administrator) prompt.

Spring Boot dependencies use the org.springframework.boot groupId.    
 Typically, your Maven POM file inherits from the spring-boot-starter-    
 parentproject and declares dependencies to one or more “Starters”.    
  Spring Boot also provides an optional Maven plugin to create     
  executable jars.    
The following listing shows a typical pom.xml file:

Spring Boot is compatible with Gradle 4. If you do not already    
 have Gradle installed, you can follow the instructions at gradle.org.
Spring Boot dependencies can be declared by using the org.springframework.boot group.     
Typically, your project declares dependencies to one or     
more“Starters”. Spring Boot provides a useful Gradle plugin     
that can be used to simplify dependency declarations and to     
create executable jars.

Gradle Wrapper
The Gradle Wrapper provides a nice way of “obtaining” Gradle when     
you need to build a project. It is a small script and library that    
 you commit alongside your code to bootstrap the build process.     
 See docs.gradle.org/4.2.1/userguide/gradle_wrapper.html for details.

The following example shows a typical build.gradle file:

Spring Boot 2.1.0.BUILD-SNAPSHOT requires Java 8 or 9 and     
Spring Framework 5.0.5.RELEASE or above. Explicit build     
support is provided for Maven 3.2+ and Gradle 4.

Spring Boot supports the following embedded servlet containers:

You can also deploy Spring Boot applications to any Servlet 3.1+ compatible container.

If you are getting started with Spring Boot,or “Spring” in general, 
start by reading this section. It answers the basic “what?”, “how?”    
and “why?” questions.It includes an introduction to Spring Boot,     
along with installation instructions.We then walk you through     
building your first Spring Boot application, discussing some core     
principles as we go.

Spring Boot makes it easy to create stand-alone, production-grade     
Spring-based Applications that you can run. We take an opinionated    
view of the Spring platform and third-party libraries, so that you    
can get started with minimum fuss. Most Spring Boot applications     
need very little Spring configuration.

You can use Spring Boot to create Java applications that can    
 be started by using java -jar or more traditional war deployments.    
  We also provide a command line tool that runs “spring scripts”.

Our primary goals are:
* Provide a radically faster and widely accessible     
	getting-started experience for all Spring development.
* Be opinionated out of the box but get out of the way     
	quickly as requirements start to diverge from the defaults.
* Provide a range of non-functional features that are     
	common to large classes of projects (such as embedded servers,     
	security, metrics, health checks, and externalized configuration).
* Absolutely no code generation and no requirement for XML    
	configuration.