SpringBoot2.快速搭建一个SpringBoot应用

Posted 2020-10-03

上一篇博客我们介绍了SpringBoot的概念，这里我们通过快速搭建一个SpringBoot应用来体验SpringBoot的特色。

1.创建工程
首先我们打开MyEclipse，创建一个Maven工程：

然后选择创建模式，这里我们选择不需要骨架：

最后填写项目相关参数：

项目创建之后工程目录如下：

pom.xml文件中有一些错误，我们先去配置它，在POM文件中添加SpringBoot的依赖，配置如下：

[html] view plain copy

 

1. <project xmlns="http://maven.apache.org/POM/4.0.0"   
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0   
4.     http://maven.apache.org/xsd/maven-4.0.0.xsd">  
5.   <modelVersion>4.0.0</modelVersion>  
6.   <groupId>cn.com.springboot.web</groupId>  
7.   <artifactId>spring-boot-test</artifactId>  
8.   <version>0.0.1-SNAPSHOT</version>  
9.   <packaging>war</packaging>  
10.     
11.   <parent>  
12.        <groupId>org.springframework.boot</groupId>  
13.        <artifactId>spring-boot-starter-parent</artifactId>  
14.        <version>1.5.4.RELEASE</version>  
15.        <relativePath/> <!-- lookup parent from repository -->  
16.    </parent>  
17.   
18.   
19.    <properties>  
20.        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
21.        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>  
22.        <java.version>1.8</java.version>  
23.    </properties>  
24.     
25.   <dependencies>  
26.        <dependency>  
27.            <groupId>org.springframework.boot</groupId>  
28.            <artifactId>spring-boot-starter-web</artifactId>  
29.        </dependency>  
30.   
31.   
32.        <dependency>  
33.            <groupId>org.springframework.boot</groupId>  
34.            <artifactId>spring-boot-starter-test</artifactId>  
35.            <scope>test</scope>  
36.        </dependency>  
37.          
38.        <dependency>    
39.           <groupId>mysql</groupId>    
40.           <artifactId>mysql-connector-java</artifactId>    
41.        </dependency>    
42.    </dependencies>  
43.   
44.   
45.    <build>  
46.        <plugins>  
47.            <plugin>  
48.                <groupId>org.springframework.boot</groupId>  
49.                <artifactId>spring-boot-maven-plugin</artifactId>  
50.            </plugin>  
51.        </plugins>  
52.    </build>  
53. </project>  

我们将jre环境换为1.8（因为SpringBoot中很多依赖是需要jdk1.8版本支持的）：


然后我们保存pom.xml文件，当编译器加载更新完毕后，我们会在工程中看到maven依赖被成功加载进来：


此时我们打开“Maven Dependencies”依赖的详情，可以看到如下依赖被引入：

我们可以发现web常用的依赖都被引入进来了，就如前面概述中所说的，SpringBoot的核心依赖中包含了许多开发常用的jar包依赖。

我们要解释的jar依赖有两个：
（1）spring-boot-starter-parent
该依赖为Spring Boot的父级依赖，它用来提供相关的Maven默认依赖，引入该依赖之后，常用的包依赖可以省去version标签。
想查看Spring Boot提供了哪些jar包的依赖，可以去本地的maven仓库的以下路径：
xxx\repository\org\springframework\boot\spring-boot-dependencies\1.5.4.RELEASE\spring-boot-dependencies-1.5.1.RELEASE.pom
的pom文件中查看。若SpringBoot提供的依赖版本有些东西不是开发中需要的，可以选择去声明其他版本依赖覆盖本依赖。 

（2）spring-boot-starter-web
此依赖为Spring Boot的”开箱即用“依赖模块之一，“开箱即用”的依赖基本都是以spring-boot-starter-xx作为命名的。关于开箱即用，
它会自动封装所需功能的依赖，不需要做很多的配置和引入各种需要的依赖，也不会出现依赖版本不匹配的问题。 

然后我们创建用户请求响应Controller层，用来响应一个RESTful风格的请求：

代码如下：

[java] view plain copy

 

1. package cn.springboot.test.controller;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5.   
6. import org.springframework.web.bind.annotation.PathVariable;  
7. import org.springframework.web.bind.annotation.RequestMapping;  
8. import org.springframework.web.bind.annotation.RestController;  
9.   
10. @RestController  
11. //该注解等价于@[email protected]的结合，使用这个注解的类里面的方法都以json格式输出。  
12. public class HelloController {  
13.   private static Map<Integer,String> userMap = new HashMap<Integer,String>();  
14.   private void initUserMap(){  
15.       userMap.put(1, "张三");userMap.put(2, "李四");  
16.       userMap.put(3, "王五");userMap.put(4, "赵二");  
17.   }  
18.       
19.   @RequestMapping("/hello/{id}")  
20.   public String findById(@PathVariable Integer id) {  
21.       initUserMap();  
22.       return "你好，用户:" + userMap.get(id);  
23.   }  
24. }  

SpringBoot启动有三种方式：
1. main方法启动 
2. 使用maven命令 mvn spring-boot:run 在命令行启动该应用 
3. Java -jar 命令启动，需要先运行“mvn package”进行打包

我们这里选项第一种方式。创建SpringBoot的一个核心启动类：

代码如下：

[java] view plain copy

 

1. package cn.springboot.test;  
2.   
3. import org.springframework.boot.SpringApplication;  
4. import org.springframework.boot.autoconfigure.SpringBootApplication;  
5.   
6. @SpringBootApplication  
7. //Sprnig Boot项目的核心注解，主要目的是开启自动配置  
8. public class SpringbootTestSimpleApplication {  
9.     //该main方法作为项目启动的入口  
10.     public static void main(String[] args) {  
11.         SpringApplication.run(SpringbootTestSimpleApplication.class, args);  
12.     }  
13. }  

我们运行SpringbootTestSimpleApplication，待控制台加载：

 

加载完毕后，我们在浏览器访问刚刚写的hello服务，访问id为1和2的用户信息。

当路径为"http://localhost:8080/hello/1"时，浏览器结果为：

当路径为"http://localhost:8080/hello/2"时，浏览器结果为：


就这样我们实现了一个简单的SpringBoot服务，看起来十分的简介和快速，这就是SpringBoot的强大之处。