创建Spring Boot项目有哪几种方式

06-01 1201阅读

文章目录

  • 创建Spring Boot项目有哪几种方式
    • 方式一:通过Spring Initializr网站创建
        • 步骤 1:访问Spring Initializr网站
        • 步骤 2:配置项目信息
        • 步骤 3:添加依赖
        • 步骤 4:生成项目
        • 步骤 5:导入项目
        • 方式二:使用IntelliJ IDEA创建
            • 步骤 1:打开IntelliJ IDEA
            • 步骤 2:创建新项目
            • 步骤 3:配置项目信息
            • 步骤 4:添加依赖
            • 步骤 5:完成项目创建
            • 验证项目创建成功
            • 方式三:从Maven项目引入依赖创建
              • 步骤1. 创建Maven项目
                • 使用IntelliJ IDEA创建
                • 使用Maven命令行创建
                • 步骤2. 引入Spring Boot依赖
                • 步骤13. 创建Spring Boot主应用类
                • 步骤14. 创建一个简单的控制器
                • 步骤15. 运行Spring Boot应用
                • 步骤6. 验证应用
                • 方式四:Spring Tool Suite(STS)
                  • 1. 启动STS
                  • 2. 创建新项目
                  • 3. 配置项目基本信息
                  • 4. 添加项目依赖
                  • 5. 项目创建完成
                  • 6. 验证项目
                    • 创建主应用类
                    • 运行项目
                    • 创建简单控制器进行测试

                      创建Spring Boot项目有哪几种方式

                      下面为你详细介绍如何使用Spring Boot官方模板创建Spring Boot项目,这里提供两种常见的创建方式:通过Spring Initializr网站创建和使用IntelliJ IDEA集成开发环境创建。

                      方式一:通过Spring Initializr网站创建

                      步骤 1:访问Spring Initializr网站

                      打开浏览器,访问 Spring Initializr,该网站是Spring官方提供的用于快速生成Spring Boot项目骨架的工具。

                      步骤 2:配置项目信息
                      • Project:选择项目构建工具,常见的有Maven Project(Maven项目)和Gradle Project(Gradle项目),这里以Maven Project为例。
                      • Language:选择项目使用的编程语言,如Java、Kotlin、Groovy等,默认是Java。
                      • Spring Boot:选择Spring Boot的版本,建议选择稳定的最新版本。
                      • Group:项目的组ID,通常是公司或组织的域名倒写,例如 com.example。
                      • Artifact:项目的唯一标识符,也是项目生成后的根目录名称,例如 demo。
                      • Name:项目名称,默认与Artifact相同。
                      • Description:项目描述信息。
                      • Package name:项目的基础包名,默认根据Group和Artifact生成。
                      • Packaging:项目的打包方式,有Jar和War两种,一般选择Jar。
                      • Java:选择Java版本,根据自己的环境选择合适的版本,如Java 8、Java 11等。
                        步骤 3:添加依赖

                        在“Dependencies”部分,点击“Add Dependencies”按钮,搜索并添加项目所需的依赖,例如:

                        • Spring Web:用于构建Web应用。
                        • Spring Data JPA:用于数据库访问。
                        • H2 Database:嵌入式数据库,方便开发测试。
                          步骤 4:生成项目

                          点击页面下方的“Generate”按钮,网站会自动生成一个压缩包,下载该压缩包到本地。

                          步骤 5:导入项目

                          解压下载的压缩包,打开你的集成开发环境(如IntelliJ IDEA、Eclipse等),选择“Import Project”或“Open”,导入解压后的项目目录。

                          方式二:使用IntelliJ IDEA创建

                          步骤 1:打开IntelliJ IDEA

                          启动IntelliJ IDEA开发环境。

                          步骤 2:创建新项目

                          选择“File” -> “New” -> “Project”,在弹出的窗口中选择“Spring Initializr”。

                          步骤 3:配置项目信息
                          • Project SDK:选择你本地安装的Java SDK版本。
                          • Project Metadata:填写项目的组ID、Artifact、名称等信息,与通过网站创建时的配置类似。
                          • Spring Initializr:保持默认的 https://start.spring.io 即可。
                            步骤 4:添加依赖

                            点击“Next”,在“Dependencies”页面添加项目所需的依赖,例如Spring Web、Spring Data JPA等。

                            步骤 5:完成项目创建

                            点击“Finish”,IntelliJ IDEA会自动从Spring Initializr下载项目骨架并导入到开发环境中。

                            验证项目创建成功

                            项目创建完成后,找到项目中的主应用类(通常是带有 @SpringBootApplication 注解的类),运行其 main 方法。如果控制台输出类似以下信息,说明项目启动成功:

                            Started DemoApplication in 3.214 seconds (JVM running for 3.879)
                            

                            至此,你已经成功使用Spring Boot官方模板创建了一个Spring Boot项目。

                            方式三:从Maven项目引入依赖创建

                            以下为你详细介绍如何通过在Maven项目中引入依赖来创建Spring Boot项目,步骤如下:

                            步骤1. 创建Maven项目

                            你可以使用IDE(如IntelliJ IDEA、Eclipse)或者Maven命令行工具来创建一个基本的Maven项目。

                            使用IntelliJ IDEA创建
                            • 打开IntelliJ IDEA,选择 File -> New -> Project。
                            • 在左侧面板选择 Maven,确保已选择合适的JDK版本,勾选 Create from archetype 并选择 org.apache.maven.archetypes:maven-archetype-quickstart。
                            • 点击 Next,填写 GroupId、ArtifactId 等信息,然后点击 Finish。
                              使用Maven命令行创建

                              打开命令行工具,执行以下命令:

                              mvn archetype:generate -DgroupId=com.example -DartifactId=springboot-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
                              

                              上述命令会创建一个名为 springboot-demo 的Maven项目,其 GroupId 为 com.example。

                              创建Spring Boot项目有哪几种方式
                              (图片来源网络,侵删)

                              步骤2. 引入Spring Boot依赖

                              打开项目中的 pom.xml 文件,添加Spring Boot相关依赖。以下是一个基本的 pom.xml 示例:

                              
                                  4.0.0
                                  com.example
                                  springboot-demo
                                  1.0-SNAPSHOT
                                  
                                  
                                      org.springframework.boot
                                      spring-boot-starter-parent
                                      2.7.12 
                                       
                                  
                                  
                                      
                                      
                                          org.springframework.boot
                                          spring-boot-starter-web
                                      
                                      
                                      
                                          org.springframework.boot
                                          spring-boot-starter-test
                                          test
                                      
                                  
                                  
                                      
                                          
                                          
                                              org.springframework.boot
                                              spring-boot-maven-plugin
                                          
                                      
                                  
                              
                              

                              上述 pom.xml 文件中,spring-boot-starter-parent 是Spring Boot的父项目,它提供了默认的依赖管理和插件配置;spring-boot-starter-web 是用于构建Web应用的依赖;spring-boot-starter-test 是用于测试的依赖;spring-boot-maven-plugin 用于打包和运行Spring Boot应用。

                              创建Spring Boot项目有哪几种方式
                              (图片来源网络,侵删)

                              步骤13. 创建Spring Boot主应用类

                              在 src/main/java 目录下,按照 GroupId 创建对应的包结构,例如 com/example,然后在该包下创建一个主应用类,示例代码如下:

                              package com.example;
                              import org.springframework.boot.SpringApplication;
                              import org.springframework.boot.autoconfigure.SpringBootApplication;
                              @SpringBootApplication
                              public class SpringbootDemoApplication {
                                  public static void main(String[] args) {
                                      SpringApplication.run(SpringbootDemoApplication.class, args);
                                  }
                              }
                              

                              @SpringBootApplication 是一个组合注解,包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 等注解,用于启用Spring Boot的自动配置和组件扫描功能。

                              创建Spring Boot项目有哪几种方式
                              (图片来源网络,侵删)

                              步骤14. 创建一个简单的控制器

                              在 com.example 包下创建一个控制器类,示例代码如下:

                              package com.example;
                              import org.springframework.web.bind.annotation.GetMapping;
                              import org.springframework.web.bind.annotation.RestController;
                              @RestController
                              public class HelloController {
                                  @GetMapping("/hello")
                                  public String hello() {
                                      return "Hello, Spring Boot!";
                                  }
                              }
                              

                              @RestController 注解表示这是一个RESTful风格的控制器,@GetMapping 注解用于处理HTTP GET请求。

                              步骤15. 运行Spring Boot应用

                              • 使用IDE运行:在主应用类 SpringbootDemoApplication 中,右键点击 main 方法,选择 Run 'SpringbootDemoApplication.main()'。
                              • 使用Maven命令运行:打开命令行工具,进入项目根目录,执行以下命令:
                                mvn spring-boot:run
                                

                                步骤6. 验证应用

                                打开浏览器或者使用工具(如Postman)访问 http://localhost:8080/hello,如果看到页面显示 Hello, Spring Boot!,则说明Spring Boot项目创建并运行成功。

                                通过以上步骤,你就可以通过在Maven项目中引入依赖来创建一个简单的Spring Boot项目。

                                方式四:Spring Tool Suite(STS)

                                Spring Tool Suite(STS)是一个专门为Spring开发设计的集成开发环境,以下为你详细介绍使用STS创建Spring Boot项目的步骤:

                                1. 启动STS

                                打开Spring Tool Suite,进入主界面。

                                2. 创建新项目

                                • 选择菜单栏中的 File -> New -> Spring Starter Project。如果该选项未显示,可能需要确保STS已正确安装并更新到支持Spring Boot项目创建的版本。

                                  3. 配置项目基本信息

                                  • Project:选择项目的构建工具,一般有Maven Project(Maven项目)和Gradle Project(Gradle项目)两种选择,这里以Maven Project为例。
                                  • Spring Boot:选择合适的Spring Boot版本,建议选择稳定的最新版本。
                                  • Group:填写项目的组ID,通常是公司或组织的域名倒写,例如 com.example。
                                  • Artifact:填写项目的唯一标识符,也是项目生成后的根目录名称,例如 springboot-demo。
                                  • Name:项目名称,默认与Artifact相同,可根据需要修改。
                                  • Description:对项目的简要描述信息。
                                  • Package name:项目的基础包名,默认根据Group和Artifact生成。
                                  • Packaging:项目的打包方式,有Jar和War两种,一般选择Jar。
                                  • Java:选择Java版本,要与你本地安装的Java环境相匹配,如Java 8、Java 11等。

                                    4. 添加项目依赖

                                    点击 Next 后,进入依赖选择页面。这里可以根据项目需求添加各种依赖,常见的依赖如下:

                                    • Web:勾选 Spring Web,用于构建Web应用程序。
                                    • Template Engines:如果需要使用模板引擎渲染页面,可以选择 Thymeleaf。
                                    • SQL:若要进行数据库操作,可选择 Spring Data JPA 用于数据库访问,以及 H2 Database 作为嵌入式数据库方便开发测试。
                                    • Testing:Spring Boot DevTools 可以提供开发时的自动重启等功能;Spring Boot Test 用于编写测试用例。

                                      你可以通过搜索框快速查找所需的依赖,选择完成后点击 Finish。

                                      5. 项目创建完成

                                      STS会自动从Spring Initializr下载项目骨架,并导入到工作区中。等待项目的依赖下载完成,这个过程可能需要一些时间,具体取决于网络状况。

                                      6. 验证项目

                                      创建主应用类

                                      项目创建完成后,会自动生成一个带有 @SpringBootApplication 注解的主应用类,通常位于 src/main/java 下以你配置的 Package name 为路径的目录中,例如 com/example/springbootdemo 包下的 SpringbootDemoApplication.java。

                                      package com.example.springbootdemo;
                                      import org.springframework.boot.SpringApplication;
                                      import org.springframework.boot.autoconfigure.SpringBootApplication;
                                      @SpringBootApplication
                                      public class SpringbootDemoApplication {
                                          public static void main(String[] args) {
                                              SpringApplication.run(SpringbootDemoApplication.class, args);
                                          }
                                      }
                                      
                                      运行项目
                                      • 右键点击主应用类,选择 Run As -> Spring Boot App。
                                      • 若控制台输出类似以下信息,则说明项目启动成功:
                                        Started SpringbootDemoApplication in 3.214 seconds (JVM running for 3.879)
                                        
                                        创建简单控制器进行测试

                                        在 com.example.springbootdemo 包下创建一个控制器类 HelloController.java:

                                        package com.example.springbootdemo;
                                        import org.springframework.web.bind.annotation.GetMapping;
                                        import org.springframework.web.bind.annotation.RestController;
                                        @RestController
                                        public class HelloController {
                                            @GetMapping("/hello")
                                            public String hello() {
                                                return "Hello, Spring Boot!";
                                            }
                                        }
                                        

                                        打开浏览器,访问 http://localhost:8080/hello,如果页面显示 Hello, Spring Boot!,则表明项目创建和配置正常。

                                        通过以上步骤,你就可以使用STS成功创建一个Spring Boot项目。

免责声明:我们致力于保护作者版权,注重分享,被刊用文章因无法核实真实出处,未能及时与作者取得联系,或有版权异议的,请联系管理员,我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明:本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度,360,搜狗等多加搜索引擎自动关键词搜索配图,如有侵权的图片,请第一时间联系我们。

目录[+]

取消
微信二维码
微信二维码
支付宝二维码