前言

如果你是一个浸淫 SpringBoot 已久的老手，那么可能下面的内容可能不那么适合你，写得很简单。但如果是对于一个刚学习 SpringBoot 的新手而言，我想多少还是有些用的。本文就来手把手教你如何创建一个 SpringBoot 项目，并对其中的一些关键信息进行简单分析，让你更加快速的掌握如何创建一个 SpringBoot 项目。

Spring Boot 简介

使用 Servlet/JSP 开发 JavaWeb 时，一个接口对应一个Servlet，配置很繁琐。未尽量减少这种麻烦，Spring Boot 应用而生。它是由 Pivotal 团队提供的全新框架，目的适用于简化 Spring 应用的初始搭建即开发过程。该框架使用特定方式进行配置，从而使开发人员无需定义样板化的配置。

如何创建 Spring Boot 项目

Sping Boot 项目的本质其实还是一个 Maven 项目，主要有如下几种创建 Spring Boot 项目的方式；

在线创建

  1. 打开 https://start.spring.io/ 来生成 Spring Boot 项目；

创建 SpringBoot 项目的 3 种方式 - 图1

  1. 然后选择和填写相关配置；
  • Project：表示使用什么构建工具，Maven or Gradle；
  • Language：表示使用什么编程语言， Java 、Kotlin or Groovy；
  • Spring Boot：Spring Boot 的版本；
  • Project Metadata：项目元数据，即 Maven项目基本元素，根据自己的实际情况填写；
  • Dependencies：要加入的 Spring Boot 组件；

创建 SpringBoot 项目的 3 种方式 - 图2

  1. 然后点击生成或 Ctrl + Enter 即可；

创建 SpringBoot 项目的 3 种方式 - 图3

  1. 将压缩包下载后，解压缩后用自己喜欢的 IDE 开发即可；

IntelliJ IDEA 创建

  1. 新建项目时选择 Spring Initializr ；

创建 SpringBoot 项目的 3 种方式 - 图4

  1. 点击下一步，填写相关配置；
  • Group：组织 ID，一般分为多个段，一般第一段为域，而第二段则是 公司名称；
  • Artifact：唯一标识符，一般是项目名；

创建 SpringBoot 项目的 3 种方式 - 图5

  1. 选择包，添加相关依赖；

创建 SpringBoot 项目的 3 种方式 - 图6

  1. 配置项目名，点击完成即可；

创建 SpringBoot 项目的 3 种方式 - 图7

Maven 创建

  1. 新建 Maven 项目；

创建 SpringBoot 项目的 3 种方式 - 图8

  1. 填写项目名和相关配置；

创建 SpringBoot 项目的 3 种方式 - 图9

  1. 点击完成即可；

创建 SpringBoot 项目的 3 种方式 - 图10

  1. 配置 pom.xml 添加依赖；
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>org.cunyu1943</groupId>
  8.     <artifactId>springDemo</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <parent>
  12.         <groupId>org.springframework.boot</groupId>
  13.         <artifactId>spring-boot-starter-parent</artifactId>
  14.         <version>2.2.6.RELEASE</version>
  15.     </parent>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-starter-web</artifactId>
  20.             <version>2.2.6.RELEASE</version>
  21.         </dependency>
  22.     </dependencies>
  24. </project>
  1. 在 main/java 目录下创建一个包，然后新建一个类，比如我的如下；
  1. package controller;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  8. /**
  9.  * Created with IntelliJ IDEA.
  10.  * Version : 1.0
  11.  * Author  : cunyu
  12.  * Email   : cunyu1024@foxmail.com
  13.  * Website : https://cunyu1943.github.io
  14.  * 公众号   : 村雨遥
  15.  * Date    : 2020/4/23 下午2:50
  16.  * Project : springDemo
  17.  * Package : controller
  18.  * Class   : App
  19.  * Desc    :
  20.  */
  22. @EnableAutoConfiguration
  23. @RestController
  25. public class App {
  26.     public static void main(String[] args) throws Exception {
  27.         SpringApplication.run(App.class, args);
  28.     }
  30.     @GetMapping("/index")
  31.     public String index() {
  32.         return "Hello World!";
  33.     }
  34. }
  1. 运行上一步中的 main 方法即可；

创建 SpringBoot 项目的 3 种方式 - 图11

常见项目结构

代码层

根目录：com.springboot：

  • build ：工程启动类；
  • entity ：实体类；
  • dao ：数据访问层；
  • service ：数据服务层，业务类代码；
  • controller ：前端访问控制器；
  • config ：配置信息类；
  • util ：工具类；
  • constant ：常用接口类；
  • vo ：数据传输类；
  • Application.java：项目的启动类；

资源文件结构

根目录 src/main/resources：

  • config ：.properties、.json 等配置文件；
  • i18n ：国际化相关；
  • META-INF/spring ：spring.xml ；
  • static ：页面以及 js、css、image 等分别放在各自文件夹下；

@SpringBootApplication 注解分析

相关代码

  1. package org.springframework.boot.autoconfigure;
  2. @Target(ElementType.TYPE)
  3. @Retention(RetentionPolicy.RUNTIME)
  4. @Documented
  5. @Inherited
  6. @SpringBootConfiguration
  7. @EnableAutoConfiguration
  8. @ComponentScan(excludeFilters = {
  9.         @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
  10.         @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
  11. public @interface SpringBootApplication {
  12.    ......
  13. }

说明

@SpringBootApplication 标注该类是一个启动类，可以看做是 @Configuration、@EnableAutoConfiguration、@ComponentScan 的集合；

  • @Configuration ：允许在上下文中注册额外的 Bean 或导入其他配置；
  • @EnableAutoConfiguration：启动 Spring Boot 的自动配置机制；
  • @ComponentScan：扫描被 @ComponentScan（@Service、@Controller、@Repository） 注解的 Bean，默认扫描该类所在包下所有类，将这些 Bean 定义加载到 IOC 容器中；

pom.xml 分析

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.3.2.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.cunyu</groupId>
  12.     <artifactId>springboot-03</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>springboot-03</name>
  15.     <description>spring boot - 03</description>
  17.     <properties>
  18.         <java.version>1.8</java.version>
  19.     </properties>
  21.     <dependencies>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-test</artifactId>
  31.             <scope>test</scope>
  32.             <exclusions>
  33.                 <exclusion>
  34.                     <groupId>org.junit.vintage</groupId>
  35.                     <artifactId>junit-vintage-engine</artifactId>
  36.                 </exclusion>
  37.             </exclusions>
  38.         </dependency>
  39.     </dependencies>
  41.     <build>
  42.         <plugins>
  43.             <plugin>
  44.                 <groupId>org.springframework.boot</groupId>
  45.                 <artifactId>spring-boot-maven-plugin</artifactId>
  46.             </plugin>
  47.         </plugins>
  48.     </build>
  50. </project>

创建好项目后，如果没有选其他组件，会生成如上的 Spring Boot 项目依赖，主要有四个部分：

  • 项目元数据

创建时输入的 Project Metadata 部分，即 Maven 项目的基本元素，包括 groupId、artifactId、version、name、description 等；

  • parent

继承 spring-boot-starter-parent 的依赖管理，控制版本与打包等等内容；

  • dependencies

项目具体依赖，默认包含 spring-boot-starter-web，用于实现HTTP接口（该依赖中包含了Spring MVC）；spring-boot-starter-test用于编写单元测试的依赖包。后续开发中，主要就是在这里添加各种依赖。

  • build

构建配置部分，默认使用 spring-boot-maven-plugin，配合 spring-boot-starter-parent 可以把 Spring Boot 应用打包成 jar 来直接运行。

总结

以上就是今天的全部内容了，文章主要介绍了两种创建 SpringBoot 的方式，一种是通过 Spring 官网在线创建的方式，另一种则是通过 IDEA 创建的方式，两个方式其实效果都是一样的，只不过形式不同而已。

最后，创作不易，如果觉得我的文章对你有所帮助，那就帮忙点赞关注吧，感谢支持！