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);
Although there isn’t much code here, quite a lot is going on. Let’s step though the
important parts.
10.3.1 The @RestController and @RequestMapping annotations

The first annotation on our Example class is @RestController. This is known as a
stereotype annotation. It provides hints for people reading the code, and for Spring,
that the class plays a specific role. In this case, our class is a web @Controller so
Spring will consider it when handling incoming web requests.
The @RequestMapping annotation provides “routing” information. It is telling Spring
that any HTTP request with the path "/" should be mapped to the home method. The
@RestController annotation tells Spring to render the resulting string directly
back to the caller.
The @RestController and @RequestMapping annotations are Spring MVC
annotations (they are not specific to Spring Boot). See the
MVC section in the Spring
Reference Documentation for more details.
10.3.2 The @EnableAutoConfiguration annotation

The second class-level annotation is @EnableAutoConfiguration. This annotation tells
Spring Boot to “guess” how you will want to configure Spring, based on the jar
dependencies that you have added. Since spring-boot-starter-web added Tomcat and
Spring MVC, the auto-configuration will assume that you are developing a web application
and setup Spring accordingly.
Starter POMs and Auto-Configuration
Auto-configuration is designed to work well with “Starter POMs”, but the two concepts
are not directly tied. You are free to pick-and-choose jar dependencies outside of the
starter POMs and Spring Boot will still do its best to auto-configure your application.
10.3.3 The “main” method

The final part of our application is the main method. This is just a standard method
that follows the Java convention for an application entry point. Our main method delegates
to Spring Boot’s SpringApplication class by calling run. SpringApplication will
bootstrap our application, starting Spring which will in turn start the auto-configured
Tomcat web server. We need to pass Example.class as an argument to the run method to
tell SpringApplication which is the primary Spring component. The args array is also
passed through to expose any command-line arguments.
10.4 Running the example

At this point our application should work. Since we have used the
spring-boot-starter-parent POM we have a useful run goal that we can use to start
the application. Type mvn spring-boot:run from the root project directory to start the
application:
$ mvn spring-boot:run
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v1.1.5.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.222 seconds (JVM running for 6.514)
If you open a web browser to http://localhost:8080 you should see the following output:
Hello World!
To gracefully exit the application hit ctrl-c.
10.5 Creating an executable jar

Let’s finish our example by creating a completely self-contained executable jar file that
we could run in production. Executable jars (sometimes called “fat jars”) are archives
containing your compiled classes along with all of the jar dependencies that your code
needs to run.
Executable jars and Java
Java does not provide any standard way to load nested jar files (i.e. jar files that are
themselves contained within a jar). This can be problematic if you are looking to
distribute a self-contained application.
To solve this problem, many developers use “shaded” jars. A shaded jar simply packages
all classes, from all jars, into a single “uber jar”. The problem with shaded jars is that
it becomes hard to see which libraries you are actually using in your application. It can
also be problematic if the the same filename is used (but with different content) in
multiple jars.
Spring Boot takes a different
approach and allows you to actually nest jars directly.
To create an executable jar we need to add the spring-boot-maven-plugin to our
pom.xml. Insert the following lines just below the dependencies section:
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
The spring-boot-starter-parent POM includes <executions> configuration to
bind the repackage goal. If you are not using the parent POM you will need to declare
this configuration yourself. See the plugin
documentation for details.
Save your pom.xml and run mvn package from the command line:
$ 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.1.5.RELEASE:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
If you look in the target directory you should see myproject-0.0.1-SNAPSHOT.jar. The
file should be around 10 Mb in size. If you want to peek inside, you can use jar tvf:
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
You should also see a much smaller file named myproject-0.0.1-SNAPSHOT.jar.original
in the target directory. This is the original jar file that Maven created before it was
repackaged by Spring Boot.
To run that application, use the java -jar command:
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v1.1.5.RELEASE)
....... . . .
....... . . . (log output here)