使用Spring Boot快速构建应用

时间  2019-11-05 标签 使用 spring boot 快速 构建 应用

随着Spring 4新版本的发布，Spring Boot这个新的子项目获得了普遍的关注，由于不论是Spring 4官方发布的新闻稿仍是针对首席架构师Adrian Colyer的专访，都对这个子项目所带来的生产率提高赞誉有加。html


Spring Boot充分利用了JavaConfig的配置模式以及“约定优于配置”的理念，可以极大的简化基于Spring MVC的Web应用和REST服务开发。java


Spring 4倡导微服务的架构，针对这一理念，近来在微博上也有一些有价值的讨论，如这里和这里。微服务架构倡导将功能拆分到离散的服务中，独立地进行部 署，Spring Boot可以很方便地将应用打包成独立可运行的JAR包，所以在开发模式上很契合这一理念。目前，Spring Boot依然是0.5.0的里程碑版本，所以相关的文档尚不完善，本文将会以一个简单的样例来介绍基于这个项目的开发过程。git


要Spring Boot进行功能开发，须要使用Gradle或者Maven做为构建工具。在本例中，咱们会使用Eclipse和Maven插件进行开发。要使用 Spring Boot，首先建立一个Maven工程，并修改Maven主要的配置文件pom.xml，以下所示：github

 

Pom.xml代码  收藏代码web

  1. <properties>  spring

  2.     <java.version>1.7</java.version>  数据库

  3.     <start-class>com.test.springboot.Startup</start-class>  apache

  4. </properties>  api

  5. <!-- Inherit defaults from Spring Boot -->  浏览器

  6. <parent>  

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

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

  9.     <version>1.0.1.RELEASE</version>  

  10. </parent>  

  11.   

  12. <!-- Add typical dependencies for a web application -->  

  13. <dependencies>  

  14.     <dependency>  

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

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

  17.     </dependency>  

  18. </dependencies>  

  19.   

  20. <build>  

  21.     <pluginManagement>  

  22.         <plugins>  

  23.             <plugin>  

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

  25.                 <configuration>  

  26.                     <source>1.7</source>  

  27.                     <target>1.7</target>  

  28.                 </configuration>  

  29.             </plugin>  

  30.         </plugins>  

  31.     </pluginManagement>  

  32. </build>  

  33.   

  34. <repositories>  

  35.     <repository>  

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

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

  38.         <snapshots>  

  39.             <enabled>true</enabled>  

  40.         </snapshots>  

  41.     </repository>  

  42.     <repository>  

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

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

  45.     </repository>  

  46. </repositories>  

  47. <pluginRepositories>  

  48.     <pluginRepository>  

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

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

  51.     </pluginRepository>  

  52.     <pluginRepository>  

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

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

  55.     </pluginRepository>  

  56. </pluginRepositories>  

 

在上面的配置中，须要将工程的parent设置为spring-boot-starter-parent，并添加对spring-boot- starter-web的依赖，这样咱们就无需设置各个依赖项及其版本信息了。而且在构建中要声明使用spring-boot-maven-plugin 这个插件，它会对Maven打包造成的JAR进行二次修改，最终产生符合咱们要求的内容结构。


在咱们的应用中将要发布一个REST服务，显示一个基本的用户信息，首先定义一个简单的模型类：

 

User代码  收藏代码

  1. public class User {  

  2.     private Long id;    

  3.     private String name;    

  4.     

  5.     public Long getId() {    

  6.         return id;    

  7.     }    

  8.     

  9.     public void setId(Long id) {    

  10.         this.id = id;    

  11.     }    

  12.     

  13.     public String getName() {    

  14.         return name;    

  15.     }    

  16.     

  17.     public void setName(String name) {    

  18.         this.name = name;    

  19.     }      

  20. }  

 

接下来，咱们须要声明一个Spring MVC的Controller，响应对实体的请求：

 

Usercontroller代码  收藏代码

  1. //@EnableAutoConfiguration  

  2. @RestController    

  3. @RequestMapping("/user")   

  4. public class UserController {  

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

  6.     public User view(@PathVariable("id") Long id) {    

  7.         User user = new User();    

  8.         user.setId(id);    

  9.         user.setName("zhang");    

  10.         return user;    

  11.     }    

  12.     

  13.     //public static void main(String[] args) {    

  14.     //    SpringApplication.run(UserController.class);    

  15.     //}    

  16. }  

 

这个类与咱们在使用Spring MVC定义Controller时并没有任何差异。接下来，咱们须要声明一个主类启动这个应用程序：

 

Startup 代码  收藏代码

  1. @Configuration    

  2. @ComponentScan    

  3. @EnableAutoConfiguration    

  4. public class Startup {  

  5.     public static void main(String[] args) {  

  6.         SpringApplication app = new SpringApplication(Startup.class);  

  7.         app.setWebEnvironment(true);  

  8.         app.setShowBanner(false);  

  9.           

  10.         Set<Object> set = new HashSet<Object>();  

  11.         //set.add("classpath:applicationContext.xml");  

  12.         app.setSources(set);  

  13.         app.run(args);  

  14.     }    

  15. }  

  

这个 类的main方法中使用了SpringApplication帮助类，并以Application这个类做为配置来启动Spring的应用上下文。在这个 类中使用了ComponentScan以及EnableAutoConfiguration注解，其中ComponentScan注解会告知Spring 扫描指定的包来初始化Spring Bean，这可以确保咱们声明的Bean可以被发现。EnableAutoConfiguration将会启动自动配置模式，在咱们的配置中会将对 Tomcat的依赖级联进来，所以在应用启动时将会自动启动一个嵌入式的Tomcat，由于在样例中使用了Spring MVC，因此也会自动注册所需的DispatcherServlet，这都不须要相似web.xml这样的配置。
在Eclipse中要运行这个应用的话，能够直接以Java Application的形式来运行这个main函数，此时会启动应用，咱们在浏览器中能够看到以下的运行效果，这就是咱们想要的REST服务：

 

在开发调试完成以后，能够将应用打成JAR包的形式，在Eclipse中能够直接使用Maven插件的package命令，最终会造成一个可运行的 JAR包。咱们使用java –jar命令就能够运行这个JAR包了。Myeclipse的Maven的package请参考（http://mrlee23.iteye.com/blog/2047946 ）所呈现出的效果与在调试期是同样的。如今看一下这个JAR包解压后的目录结构：

 

 

 

 

这个JAR包与传统JAR包的不一样之处在于里面有一个名为lib的目录，在这个目录中包含了这个简单应用所依赖的其余JAR包，其中也包含内置的嵌 入式Tomcat，正是使用它，才能发布服务和访问Web资源。除了咱们编写的源码所编译造成的CLASS之外，在org目录下还有许多Spring所提 供的CLASS，正是依赖这些CLASS，才可以加载位于lib目录下JAR中的类。这样的加载机制与在OSGi bundle中声明Bundle-Classpath很相似，不过在OSGi中会由容器来负责加载指定路径下的类。这大体阐述了这样一个JAR包可以发布 服务的缘由。

若是咱们想要使用HTML、JSP等Web资源的话，在Controller中直接返回对应的视图就能够了。

若是咱们想要将这个JAR包转换成能够在Servlet容器中部署的WAR的话，就不能依赖于Application的main函数了，而是要以相似于web.xml文件配置的方式来启动Spring应用上下文，此时咱们须要声明这样一个类：

 

Hellowebxml 代码  收藏代码

  1. public class HelloWebXml extends SpringBootServletInitializer {  

  2.     @Override  

  3.     protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {  

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

  5.     }  

  6.   

  7. }  

 

这个类的做用与在web.xml中配置负责初始化Spring应用上下文的监听器做用相似，只不过在这里不须要编写额外的XML文件了。

若是要将最终的打包形式改成WAR的话，还须要对pom.xml文件进行修改，除了须要将packaging的值修改成war之外，还须要对依赖进行适当的配置（这一部分在Spring Boot的样例和文档中均未说起，提醒你们注意）：

Pom.xml代码  收藏代码

  1. <dependency>  

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

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

  4.            <exclusions>  

  5.             <exclusion>  

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

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

  8.             </exclusion>  

  9.            </exclusions>   

  10. </dependency>  

 

在这里须要移除对嵌入式Tomcat的依赖，这样打出的WAR包中，在lib目录下才不会包含Tomcat相关的JAR包，不然将会出现启动错误。另外，在移除对Tomcat的依赖后，为了保证编译正确，还须要添加对servlet-api的依赖，所以添加以下的配置：

Pom.xml代码  收藏代码

  1. <dependency>  

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

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

  4.             <version>7.0.42</version>  

  5.             <scope>provided</scope>  

  6. </dependency>  

 

在这里将scope属性设置为provided，这样在最终造成的WAR中不会包含这个JAR包，由于Tomcat或Jetty等服务器在运行时将 会提供相关的API类。此时，执行mvn package命令就会获得一个WAR文件，咱们能够直接将其放到Tomcat下运行（须要7.0.42版本以上）。

以上介绍了基于Spring Boot开发应用的过程，目前它的文档尚不完善，可是在GitHub上有很多的样例，包括与Spring Data集成访问数据库（关系型以及非关系型）、安全、WebSocket等，读者感兴趣能够下载运行。

基于以上的介绍，但愿读者可以对Spring Boot这个新项目有所了解。它简化了JAR包管理和相关基础设施环境的配置，可以帮助咱们快速开发Web应用或构建REST服务，但愿它可以尽快完善成熟，更多地用于实践，提高开发效率。

 

参考资料

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

https://github.com/spring-projects

联系我们 沪ICP备13005482号-10