Spring boot--2 minutes Build Spring Web MVC rest style HelloWorld

A previous article, "5 minutes Building Spring Web MVC rest Style HelloWorld", describes the common way to develop a spring Web MVC Web service. Next look at how to build one quickly using spring boot.

Spring boot makes it easier for us to create a spring-based standalone and product-level application and service that can be "run on the Fly". The support contract is larger than the configuration to build and run the spring application as quickly as possible.

Before we created a spring-based project, we needed to consider which spring dependencies and third-party dependencies to add. With spring boot, we can start the spring application with minimal dependencies. Most spring boot applications require very little configuration to run, such as the ability to create standalone, standalone large Java applications, and then run a startup with Java-jar or a traditional war deployment. It also provides command-line tools to run the spring script directly (such as groovy script). That is, spring boot makes spring applications simpler from configuration to run, but does not provide enhancements to spring itself (that is, additional functionality).

Objective:

Make all spring development faster and allow more people to make the spring start experience faster and provide "starter" pom to simplify our MAVEN configuration (that is, use spring boot only with maven/ Gradle such a dependency management tool to be able to perform its capabilities), unlike before, building a SPRINGMVC project requires a lot of configuration, etc.

Out-of-the-box, quickly start requirements development without being affected by other aspects (if spring is automatically configured)

Provides a number of non-functional common large project class features (such as embedded server, security, metrics, health Check, extranet configuration), such as the ability to embed Tomcat/jetty directly (no need to deploy war packages separately)

No code generation, no XML configuration required

My build Environment

JDK 7

Maven 3

Servlet3 container

Create a project

Start by using MAVEN to create a normal Maven app that doesn't have to be web-ready.

Add spring boot-related POM configuration

Add the following configuration in Pom.xml

Java code

2. <!--Inherit defaults from Spring Boot--
4. <parent>
6. <groupId>org.springframework.boot</groupId>
8. <artifactId>spring-boot-starter-parent</artifactId>
10. <version>0.5. 0.build-snapshot</version>
12. </parent>
16. <!--Add Typical dependencies for a Web application --
18. <dependencies>
20. <dependency>
22. <groupId>org.springframework.boot</groupId>
24. <artifactId>spring-boot-starter-web</artifactId>
26. </dependency>
28. </dependencies>
32. <!--package as a executable JAR--
34. <build>
36. <plugins>
38. <plugin>
40. <groupId>org.springframework.boot</groupId>
42. <artifactId>spring-boot-maven-plugin</artifactId>
44. </plugin>
46. </plugins>
48. </build>
52. <!--allow access to Spring milestones and snapshots-
54. <!--(you don't need this if you're using anything after 0.5. 0.RELEASE) --
56. <repositories>
58. <repository>
60. <id>spring-snapshots</id>
62. <url>http://repo.spring.io/snapshot</url>
64. <snapshots><enabled>true</enabled></snapshots>
66. </repository>
68. <repository>
70. <id>spring-milestones</id>
72. <url>http://repo.spring.io/milestone</url>
74. <snapshots><enabled>true</enabled></snapshots>
76. </repository>
78. </repositories>
80. <pluginRepositories>
82. <pluginRepository>
84. <id>spring-snapshots</id>
86. <url>http://repo.spring.io/snapshot</url>
88. </pluginRepository>
90. <pluginRepository>
92. <id>spring-milestones</id>
94. <url>http://repo.spring.io/milestone</url>
96. </pluginRepository>
98. </pluginRepositories>

After inheriting spring-boot-starter-parent, we can inherit some of the default dependencies, so that we do not need to add a bunch of corresponding dependencies to minimize the dependency configuration; Spring-boot-starter-web provides support for the Web. Spring-boot-maven-plugin provides a plug-in that directly runs the project, and we can run it directly mvn Spring-boot:run.

Entity Java code

2. Package com.sishuok.entity;
6. /**
8. * <p>user:zhang Kaitao
10. * <p>date:13-12-22
12. * <p>version:1.0
14. */
16. Public class User {
18. private Long ID;
20. private String name;
24. Public Long getId () {
26. return ID;
28. }
32. public void SetId (Long id) {
34. this.id = ID;
36. }
40. Public String GetName () {
42. return name;
44. }
48. public void SetName (String name) {
50. this.name = name;
52. }
56. @Override
58. public Boolean equals (Object o) {
60. if (this= O) return true;
62. if (o = = Null | | getclass ()! = O.getclass ()) return false;
66. User user = (user) O;
70. if (id! = null?!id.equals (user.id): user.id! = null) return false;
74. return true;
76. }
80. @Override
82. public int hashcode () {
84. return ID ! = null? Id.hashcode (): 0;
86. }
88. }

Controller Java Code

2. Package Com.sishuok.controller;
6. Import Com.sishuok.entity.User;
8. Import org.springframework.boot.SpringApplication;
10. Import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
12. Import org.springframework.web.bind.annotation.PathVariable;
14. Import org.springframework.web.bind.annotation.RequestMapping;
16. Import Org.springframework.web.bind.annotation.RestController;
20. /**
22. * <p>user:zhang Kaitao
24. * <p>date:13-12-22
26. * <p>version:1.0
28. */
30. @EnableAutoConfiguration
32. @RestController
34. @RequestMapping ("/user")
36. Public class Usercontroller {
40. @RequestMapping ("/{id}")
42. Public User View (@PathVariable ("id") Long ID) {
44. User user = new user ();
46. User.setid (ID);
48. User.setname ("Zhang");
50. return user;
52. }
56. //public static void Main (string[] args) {
58. //Springapplication.run (Usercontroller.class);
60. //}  
64. }

Run

The first way

Turn on automatic configuration by adding @enableautoconfiguration to Usercontroller and then through Springapplication.run (Usercontroller.class); Run this controller ; It is convenient to run only one controller in this way;

The second way

Enable annotation scanning and automatically register the corresponding annotation bean via @[email protected]

Java code

2. Package Com.sishuok;
6. Import Com.sishuok.controller.UserController;
8. Import org.springframework.boot.SpringApplication;
10. Import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
12. Import Org.springframework.context.annotation.ComponentScan;
14. Import org.springframework.context.annotation.Configuration;
18. /**
20. * <p>user:zhang Kaitao
22. * <p>date:13-12-22
24. * <p>version:1.0
26. */
28. @Configuration
30. @ComponentScan
32. @EnableAutoConfiguration
34. Public class Application {
36. public static void Main (string[] args) {
38. Springapplication.run (Application.   Class);
40. }
42. }

In this way, a basic restful Web application is built.

You can see the JSON results by entering HTTP://LOCALHOST:8080/USER/1 in the address bar.

If you look at their dependencies, you'll find that the dependencies are automatically added (whether you're using/not), but it's really fast to develop an app, and for beginners who want to learn/experience spring, building a project model quickly can be considered in this way. Of course, if you don't want to rely on so many jar packages, you can remove the parent and add dependencies yourself.

Welcome to join Spring Group 134755960 for communication.

Reference

Https://github.com/spring-projects/spring-boot

Spring boot--2 minutes Build Spring Web MVC rest style HelloWorld