Quickly build apps with spring boot

With the release of the new Spring 4 release, Spring Boot's new sub-project has received a wide range of attention, as both the Spring 4 official press release and the interview with the chief architect, Adrian Colyer, have praised the productivity gains of this subproject.

Spring boot takes full advantage of the Javaconfig configuration model and the concept of "convention over Configuration", which greatly simplifies the development of Web applications and rest services based on spring MVC.

Spring 4 advocates the architecture of microservices, and in response to this philosophy, there have been some valuable discussions on Weibo recently, such as here and here. The MicroServices architecture advocates the ability to split functionality into discrete services and deploy it independently, and Spring boot makes it easy to package applications into separate, runnable jar packages, so it fits in the development model. Currently, Spring Boot is still a milestone version of 0.5.0, so the relevant documentation is not yet complete, and this article will introduce a simple sample of the development process based on this project.

For feature development with spring boot, you need to use Gradle or Maven as the build tool. In this example, we'll use Eclipse and Maven plug-ins for development. To use Spring Boot, first create a MAVEN project and modify the MAVEN main configuration file, Pom.xml, as follows:

Pom.xml Code

2. <properties>

4. <java.version>1.7</java.version>

6. <start-class>com.test.springboot.Startup</start-class>

8. </properties>

10. <!--Inherit defaults from Spring Boot--

12. <parent>

14. <groupId>org.springframework.boot</groupId>

16. <artifactId>spring-boot-starter-parent</artifactId>

18. <version>1.0. 1. Release</version>

20. </parent>

24. <!--Add Typical dependencies for a Web application--

26. <dependencies>

28. <dependency>

30. <groupId>org.springframework.boot</groupId>

32. <artifactId>spring-boot-starter-web</artifactId>

34. </dependency>

36. </dependencies>

40. <build>

42. <pluginManagement>

44. <plugins>

46. <plugin>

48. <artifactId>maven-compiler-plugin</artifactId>

50. <configuration>

52. <source>1.7</source>

54. <target>1.7</target>

56. </configuration>

58. </plugin>

60. </plugins>

62. </pluginManagement>

64. </build>

68. <repositories>

70. <repository>

72. <id>spring-snapshots</id>

74. <url>http://repo.spring.io/snapshot</url>

76. <snapshots>

78. <enabled>true</enabled>

80. </snapshots>

82. </repository>

84. <repository>

86. <id>spring-milestones</id>

88. <url>http://repo.spring.io/milestone</url>

90. </repository>

92. </repositories>

94. <pluginRepositories>

96. <pluginRepository>

98. <id>spring-snapshots</id>

100. <url>http://repo.spring.io/snapshot</url>

102. </pluginRepository>

104. <pluginRepository>

106. <id>spring-milestones</id>

108. <url>http://repo.spring.io/milestone</url>

110. </pluginRepository>

112. </pluginRepositories>

In the above configuration, you need to set the project's parent to spring-boot-starter-parent and add a dependency on spring-boot-starter-web so that we don't have to set up individual dependencies and their version information. And in the build to declare the use of Spring-boot-maven-plugin this plug-in, it will be the MAVEN packaging formed Jar made two changes, and ultimately produce a content structure that meets our requirements.

In our app, we're going to publish a rest service that shows a basic user information, first defining a simple model class:

User code

2. public class User {

4. Private Long ID;

6. private String name;

10. Public Long getId () {

12. return ID;

14. }

18. public void SetId (Long id) {

20. This.id = ID;

22. }

26. Public String GetName () {

28. return name;

30. }

34. public void SetName (String name) {

36. THIS.name = name;

38. }

40. }

Next, we need to declare a spring MVC controller that responds to requests for entities:

Usercontroller Code

2. @EnableAutoConfiguration

4. @RestController

6. @RequestMapping ("/user")

8. public class Usercontroller {

10. @RequestMapping ("/{id}")

12. Public User View (@PathVariable ("id") Long ID) {

14. User user = new user ();

16. User.setid (ID);

18. User.setname ("Zhang");

20. return user;

22. }

26. public static void Main (string[] args) {

28. Springapplication.run (Usercontroller.class);

30. //}

32. }

This class does not differ from the one we use to define a controller with spring MVC. Next, we need to declare a main class to launch this application:

Startup Code

2. @Configuration

4. @ComponentScan

6. @EnableAutoConfiguration

8. public class Startup {

10. public static void Main (string[] args) {

12. Springapplication app = new Springapplication (startup.class);

14. App.setwebenvironment (TRUE);

16. App.setshowbanner (FALSE);

20. set<object> set = new hashset<object> ();

22. Set.add ("Classpath:applicationContext.xml");

24. App.setsources (set);

26. App.run (args);

28. }

30. }

The Springapplication helper class is used in the main method of this class, and the application class is configured to start the Spring application context. The Componentscan and enableautoconfiguration annotations are used in this class, where the Componentscan annotation tells spring to scan the specified package to initialize the spring Bean. This ensures that the beans we declare can be discovered. Enableautoconfiguration will start the auto-configuration mode, which will cascade the Tomcat dependency in our configuration, so an embedded tomcat will be started automatically when the app starts, because spring MVC is used in the sample. As a result, the required Dispatcherservlet are also automatically registered, which does not require a configuration like Web. Xml.
To run this application in Eclipse, you can run the main function directly in Java application, which launches the application, and we can see the following running effect in the browser, which is the rest service we want:

After the development debugging is complete, you can make the app into a jar package, and in eclipse you can directly use the MAVEN plugin's Package command, eventually forming a runnable jar. We can run the jar package with the Java–jar command. The MyEclipse Maven package reference (http://mrlee23.iteye.com/blog/2047946 ) shows the same effect as during the commissioning period. Now look at the directory structure of this jar package after decompression:

This jar differs from the traditional jar package in that it has a directory called LIB, which contains the other jar packages that the simple application relies on, including the built-in embedded Tomcat, which is used to publish services and access Web resources. In addition to the class created by the source code we have compiled, there are many classes provided by spring in the Org directory, and it is the class that relies on these class to be able to load in the jar in the Lib directory. Such a loading mechanism is similar to declaring Bundle-classpath in an OSGi bundle, but in OSGi it is the container that is responsible for loading the classes under the specified path. This outlines the reasons why a jar package can publish a service.

If we want to use HTML, JSP and other Web resources, we can directly return the corresponding view in the controller.

If we want to convert this jar package into a war that can be deployed in a servlet container, we can't rely on the main function of application. Instead, to start the spring application context in a manner similar to the Web. xml file configuration, we need to declare a class like this:

Hellowebxml Code

1. public class Hellowebxml extends Springbootservletinitializer {

2. @Override

3. Protected Springapplicationbuilder Configure (Springapplicationbuilder application) {

4. Return application.sources (Application.class);

5. }

7. }

The role of this class is similar to configuring the Listener in Web. Xml to initialize the spring application context, except that there is no need to write additional XML files here.

If you want to change the final packaging form to a war, you also need to modify the Pom.xml file, in addition to modifying the value of packaging to war, you need to configure the dependency appropriately (this part is not mentioned in the Spring boot sample and documentation. To remind everyone to note):

Pom.xml Code

2. <dependency>

4. <groupId>org.springframework.boot</groupId>

6. <artifactId>spring-boot-starter-web</artifactId>

8. <exclusions>

10. <exclusion>

12. <groupId>org.springframework.boot</groupId>

14. <artifactId>spring-boot-starter-tomcat</artifactId>

16. </exclusion>

18. </exclusions>

20. </dependency>

There is a need to remove the dependency on embedded Tomcat, so that in the war package, the Tomcat-related jar package will not be included in the Lib directory, or a startup error may occur. In addition, after removing the dependency on Tomcat, in order to ensure that the compilation is correct, you also need to add a dependency on Servlet-api, so add the following configuration:

Pom.xml Code

1. <dependency>

2. <groupId>org.apache.tomcat</groupId>

3. <artifactId>tomcat-servlet-api</artifactId>

4. <version>7.0. </version>

5. <scope>provided</scope>

6. </dependency>

Set the scope property here to provided so that the jar package will not be included in the resulting war, because servers such as Tomcat or jetty will provide the relevant API classes at runtime. At this point, the Execute MVN Package command will get a war file that we can directly put under Tomcat (requires 7.0.42 or more).

The above describes the process of developing an application based on spring boot, and its documentation is not yet complete, but there are a number of examples on GitHub, including integrated access to the database with spring data (relational and non-relational), security, WebSocket, and so on, which readers are interested in downloading and running.

Based on the above introduction, I hope the reader can understand the new project of Spring boot. It simplifies the configuration of jar package management and associated infrastructure environments, helps us to quickly develop Web applications or build rest services, and hopefully it will be as mature as possible, more in practice, and more efficient in development.

Resources

http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/

Https://github.com/spring-projects

Quickly build apps with spring boot