首页手记 SpringBoot3入门：快速开始你的第一个Spri...

SpringBoot3入门：快速开始你的第一个Spring Boot项目

标签：

SpringBoot

概述

Spring Boot 3入门介绍了如何简化应用开发流程，提供自动配置、内置服务器及数据库支持等功能。文章详细讲解了环境配置、项目创建和基本REST API的示例，并深入探讨了依赖管理和数据库集成。通过这些内容，开发者可以快速上手并高效地开发Spring Boot应用。

引入Spring Boot 3

Spring Boot 3简介

Spring Boot 3是Spring开发团队推出的一款用于简化Spring应用开发的框架。它基于Spring框架，并结合了“约定优于配置”的原则，大大简化了开发流程。Spring Boot 3提供了自动配置、内置的Tomcat服务器、嵌入式数据库支持和生产就绪特性，使得开发者能够更加高效地开发和部署应用。Spring Boot 3最重要的特性之一是简化了项目的配置。通过提供“约定优于配置”的原则，开发者只需专注于业务逻辑的实现，而无需过多关注配置细节。此外，Spring Boot 3还提供了对多种后端技术的支持，如数据库访问、缓存、消息队列等，为开发人员提供了极大的便利。另外，Spring Boot 3支持最新的Java版本和一些现代的开发实践，如微服务架构和云原生，这使得Spring Boot 3成为了开发现代应用的理想选择，尤其是在快速迭代和提高开发效率方面。

安装与环境配置

安装和配置Spring Boot开发环境主要涉及以下几个方面：

Java环境配置

首先，确保你的机器上安装了Java。Spring Boot 3支持Java 17及以上版本。可以通过以下命令检查Java版本：
```
java -version
```
如果未安装Java，可以访问Oracle官网或OpenJDK官方网站获取Java开发工具包（JDK）。
开发工具

推荐使用IntelliJ IDEA或Eclipse作为开发工具。这里以IntelliJ IDEA为例：
1. 下载并安装IntelliJ IDEA。
2. 在IntelliJ IDEA中安装Spring Boot插件，可以通过插件市场搜索并安装。
其他依赖
- Maven或Gradle：用于构建和管理项目依赖。这里以Maven为例进行说明。
- Spring Boot CLI：可选工具，提供命令行支持，便于快速启动Spring Boot应用。

Maven配置

在IntelliJ IDEA中配置Maven项目：

打开IntelliJ IDEA，选择“File” -> “New” -> “Project”，选择"Maven"，点击"Next"。
输入项目名，选择项目位置，点击“Next”。
输入组ID和项目ID，点击“Finish”。
打开项目根目录下的pom.xml文件，确保Maven配置正确。

Spring Initializr

Spring Initializr是一个在线工具，用于快速生成Spring Boot项目。它可以根据选择的项目类型和依赖项自动生成项目结构和基本配置文件。

访问Spring Initializr官网。
选择项目配置：
- Project：选择Maven项目。
- Language：Java。
- Spring Boot：选择最新版本。
- Dependencies：选择需要的依赖（如Web、MySQL、Spring Data JPA等）。
生成项目：点击"Generate"按钮下载项目压缩包。

生成的项目压缩包解压后是一个基本的Spring Boot项目结构，包含了主类、配置文件等。

创建第一个Spring Boot项目

使用Spring Initializr创建项目

创建一个简单的Spring Boot项目，首先可以通过Spring Initializr在线生成项目结构。访问Spring Initializr官网，选择Maven项目，选择Java版本为Java 17，Spring Boot版本为最新，添加Web依赖。生成项目后，解压文件，使用IntelliJ IDEA打开项目。

项目结构解析

一个典型的Spring Boot项目包含以下几个主要部分：

src/main/java：存放主类和业务逻辑代码。

主类：通常命名为Application.java，作为项目的入口点。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
 public static void main(String[] args) {
     SpringApplication.run(Application.class, args);
 }
}

src/main/resources：存放配置文件和其他资源文件。
- application.properties或application.yml：Spring Boot的配置文件。
- static：存放静态文件，如CSS、JavaScript和图片。
- templates：存放HTML模板文件，如Thymeleaf模板。

pom.xml：Maven配置文件，用于管理项目依赖。

dependencies：列出项目中使用的依赖，如Spring Boot Starter Web。

<dependencies>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
</dependencies>

src/test/java：存放测试代码。
- 单元测试：通常放在com.example.demo包下，命名为ApplicationTests.java。

通过以上步骤，可以快速创建一个基础的Spring Boot项目结构。

Hello World示例

在Spring Boot中创建一个简单的REST API，可以展示如何使用Spring Boot提供的基本功能来构建一个简单的Web应用。

创建一个简单的REST API

创建控制器类

首先，在src/main/java/com.example.demo包下创建一个新的类HelloController.java。在这个类中，我们将定义一个简单的REST API接口，来响应HTTP GET请求。
```
package com.example.demo;

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, World!";
   }
}
```
这里，@RestController注解将这个类标记为REST控制器，而@GetMapping注解定义了一个HTTP GET请求映射，当访问/hello路径时，返回"Hello, World!"。
运行并测试应用

为了运行并测试应用，可以使用IntelliJ IDEA的内置工具或命令行工具。
- 使用IntelliJ IDEA：
  1. 在IntelliJ IDEA中，点击工具栏上的绿色三角形按钮或选择"Run 'Application.main()'（在主类上右键选择运行）"，启动Spring Boot应用。
  2. 访问浏览器并输入http://localhost:8080/hello，你将看到输出"Hello, World!"。
- 使用命令行：
  1. 打开终端窗口，导航到项目根目录。
  2. 运行mvn spring-boot:run命令，启动Spring Boot应用。
  3. 访问浏览器并输入http://localhost:8080/hello，你将看到输出"Hello, World!"。

通过这些步骤，你可以创建并运行一个简单的Spring Boot应用，展示REST API的基本用法。

添加依赖与配置

常用依赖介绍

Spring Boot提供了许多预定义的Starter依赖，可以简化项目的配置和依赖管理。下面是一些常用依赖的介绍：

Web依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

这个依赖提供了基本的Web功能，包括一个内嵌的Servlet容器（如Tomcat）和Spring MVC支持。

安全依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

这个依赖提供了基本的安全功能，如身份验证和授权。

测试依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

这个依赖提供了测试功能，包括JUnit、Mockito和Spring Test支持。

数据访问依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

这个依赖提供了JPA（Java Persistence API）支持，可以方便地进行数据库操作。

缓存依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

这个依赖提供了缓存功能，可以使用如Redis或内存缓存。

配置文件详解（application.properties与application.yml）

Spring Boot使用application.properties或application.yml文件来管理各种配置。下面是一些常用的配置项：

基本配置

# application.properties
spring.application.name=myapp

或者在application.yml中：

# application.yml
spring:
 application:
   name: myapp

这些配置项用于设置应用的基本信息，如应用名。

数据库配置

# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

或者在application.yml中：

# application.yml
spring:
 datasource:
   url: jdbc:mysql://localhost:3306/mydb
   username: root
   password: root

这些配置项用于连接数据库，如MySQL。

服务器配置
```
# application.properties
server.port=8080
```
或者在application.yml中：
```
# application.yml
server:
 port: 8080
```
这些配置项用于设置服务器端口。

日志配置

# application.properties
logging.level.root=info
logging.file.name=myapp.log

或者在application.yml中：

# application.yml
logging:
 level:
   root: info
 file:
   name: myapp.log

这些配置项用于设置日志级别和日志文件名。

通过上面的示例，你可以看到如何在Spring Boot中配置各种常用的功能，如数据库连接、服务器端口和日志设置。

实战：数据库集成

连接MySQL数据库

连接MySQL数据库需要在Spring Boot项目中添加spring-boot-starter-data-jpa依赖，并配置数据库连接信息。

添加依赖

在pom.xml中添加spring-boot-starter-data-jpa依赖：

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

配置数据库连接

在application.properties中配置数据库连接：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

或者在application.yml中配置：

spring:
 datasource:
   url: jdbc:mysql://localhost:3306/mydb
   username: root
   password: root
 jpa:
   hibernate:
     ddl-auto: update

使用Spring Data JPA进行数据操作

Spring Data JPA提供了一套强大的数据访问抽象层，简化了数据库操作。下面通过一个简单的示例来展示如何使用Spring Data JPA进行数据库操作。

创建实体类

首先，在src/main/java/com/example/demo包下创建一个实体类User.java：

package com.example.demo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

创建Repository接口

在src/main/java/com/example/demo包下创建一个UserRepository.java接口：

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

创建服务类

在src/main/java/com/example/demo包下创建一个UserService.java类：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(Long id, User user) {
        User existingUser = userRepository.findById(id).orElse(null);
        if (existingUser != null) {
            existingUser.setName(user.getName());
            existingUser.setEmail(user.getEmail());
            return userRepository.save(existingUser);
        }
        return null;
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

创建控制器类

在src/main/java/com/example/demo包下创建一个UserController.java类：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

通过这些步骤，你已经成功地使用Spring Data JPA进行了数据库操作，包括创建、读取、更新和删除用户信息。

调试与测试

异常处理

在Spring Boot中，异常处理是一个重要的环节。通过自定义异常处理类，可以更好地管理异常信息并提供友好的错误响应。

创建自定义异常类

首先，在src/main/java/com/example/demo包下创建一个自定义异常类ResourceNotFoundException.java：

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
    public ResourceNotFoundException(String message) {
        super(message);
    }
}

处理异常

在UserService.java中，当用户不存在时抛出自定义异常：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException("User not found with id " + id));
    }

    public User createUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(Long id, User user) {
        User existingUser = userRepository.findById(id).orElseThrow(() -> new ResourceNotFoundException("User not found with id " + id));
        existingUser.setName(user.getName());
        existingUser.setEmail(user.getEmail());
        return userRepository.save(existingUser);
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

这样，当用户不存在时，将返回HTTP 404状态码和相应的错误信息。

单元测试与集成测试

在Spring Boot中，可以使用JUnit和Spring Test来编写单元测试和集成测试。

单元测试

在src/test/java/com/example/demo包下创建一个单元测试类UserServiceTests.java：

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class UserServiceTests {
    @Autowired
    private UserService userService;

    @Test
    public void testGetAllUsers() {
        List<User> users = userService.getAllUsers();
        assertNotNull(users);
    }

    @Test
    public void testGetUserById() {
        User user = userService.getUserById(1L);
        assertNotNull(user);
    }

    @Test
    public void testCreateUser() {
        User user = new User();
        user.setName("Test User");
        user.setEmail("test@example.com");
        User savedUser = userService.createUser(user);
        assertNotNull(savedUser);
        assertEquals(user.getName(), savedUser.getName());
        assertEquals(user.getEmail(), savedUser.getEmail());
    }

    @Test
    public void testUpdateUser() {
        User user = new User();
        user.setName("Test User");
        user.setEmail("test@example.com");
        User savedUser = userService.createUser(user);
        assertNotNull(savedUser);
        savedUser.setName("Updated User");
        savedUser.setEmail("updated@example.com");
        User updatedUser = userService.updateUser(savedUser.getId(), savedUser);
        assertNotNull(updatedUser);
        assertEquals("Updated User", updatedUser.getName());
        assertEquals("updated@example.com", updatedUser.getEmail());
    }

    @Test
    public void testDeleteUser() {
        User user = new User();
        user.setName("Test User");
        user.setEmail("test@example.com");
        User savedUser = userService.createUser(user);
        assertNotNull(savedUser);
        userService.deleteUser(savedUser.getId());
        assertNull(userService.getUserById(savedUser.getId()));
    }
}

集成测试

在src/test/java/com/example/demo包下创建一个集成测试类UserControllerTests.java：

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.web.servlet.MockMvc;

import java.util.List;

import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

@WebMvcTest(UserController.class)
public class UserControllerTests {
    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    public void testGetAllUsers() throws Exception {
        List<User> users = List.of(new User(1L, "User 1", "user1@example.com"), new User(2L, "User 2", "user2@example.com"));
        when(userService.getAllUsers()).thenReturn(users);

        mockMvc.perform(get("/users"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$").isArray())
                .andExpect(jsonPath("$[0].name").value("User 1"))
                .andExpect(jsonPath("$[0].email").value("user1@example.com"))
                .andExpect(jsonPath("$[1].name").value("User 2"))
                .andExpect(jsonPath("$[1].email").value("user2@example.com"));
    }

    @Test
    public void testGetUserById() throws Exception {
        User user = new User(1L, "User 1", "user1@example.com");
        when(userService.getUserById(1L)).thenReturn(user);

        mockMvc.perform(get("/users/1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("User 1"))
                .andExpect(jsonPath("$.email").value("user1@example.com"));
    }

    @Test
    public void testCreateUser() throws Exception {
        User user = new User();
        user.setName("Test User");
        user.setEmail("test@example.com");
        when(userService.createUser(user)).thenReturn(user);

        mockMvc.perform(post("/users")
                .contentType("application/json")
                .content("{\"name\":\"Test User\", \"email\":\"test@example.com\"}"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("Test User"))
                .andExpect(jsonPath("$.email").value("test@example.com"));
    }

    @Test
    public void testUpdateUser() throws Exception {
        User user = new User();
        user.setName("Test User");
        user.setEmail("test@example.com");
        when(userService.updateUser(1L, user)).thenReturn(user);

        mockMvc.perform(put("/users/1")
                .contentType("application/json")
                .content("{\"name\":\"Test User\", \"email\":\"test@example.com\"}"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.name").value("Test User"))
                .andExpect(jsonPath("$.email").value("test@example.com"));
    }

    @Test
    public void testDeleteUser() throws Exception {
        mockMvc.perform(delete("/users/1"))
                .andExpect(status().isOk());
    }
}

通过这些测试，可以确保应用的各个部分能够正常工作，并且能够有效地处理各种异常情况。

总结来说，Spring Boot通过提供丰富的功能和简便的配置，使得开发人员可以更加专注于业务逻辑的实现，而不必过多地关注底层的技术细节。在开发过程中，通过合理使用依赖管理和配置文件，可以大大提高开发效率和项目的可维护性。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

PIPIONE

手记
篇

粉丝

150

获赞与收藏

704

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 31416 348

网络编程入门教程

20个小节 12873 242

Pandas 入门教程

25个小节 18755 351

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

SpringBoot3入门：快速开始你的第一个Spring Boot项目

Spring Boot 3简介

安装与环境配置

Maven配置

Spring Initializr

使用Spring Initializr创建项目

项目结构解析

创建一个简单的REST API

常用依赖介绍

配置文件详解（application.properties与application.yml）

连接MySQL数据库

使用Spring Data JPA进行数据操作

创建实体类

创建Repository接口

创建服务类

创建控制器类

异常处理

创建自定义异常类

处理异常

单元测试与集成测试

单元测试

集成测试

阅读免费教程