首页手记 SpringBoot 3教程：轻松入门与实践

SpringBoot 3教程：轻松入门与实践

标签：

SpringBoot

概述

Spring Boot 3教程介绍了Spring Boot 3的主要特性和优势，包括支持Java 17、改进的Spring CLI和Spring Doc等功能。文章详细讲解了如何安装和配置开发环境，并通过示例展示了创建和运行第一个Spring Boot 3项目的步骤。此外，还涵盖了数据库集成、RESTful API开发、日志管理与配置以及安全性与认证等关键内容。

SpringBoot 3简介

SpringBoot 3的主要特性

Spring Boot 3 是Spring Boot系列的最新版本，它继承了之前版本的优点，并引入了一些新特性，以满足现代应用开发的需求。以下是一些主要特性：

支持Java 17：Spring Boot 3正式支持Java 17，这使得开发者可以利用最新的Java语言特性，如模式匹配、密封类等。
改进的Spring CLI：Spring CLI工具集成了构建、运行和测试Spring Boot应用的功能，使得开发更加便捷。
增强的Spring Doc：Spring Boot 3对Spring Doc进行了增强，提供了一种生成API文档的更有效的方法。
Spring Security 6：集成最新的Spring Security版本，增强了安全性功能。
改进的错误处理和日志记录：提供了更强大和灵活的错误处理机制，并改进了日志记录功能，使其更加自动化。
WebFlux支持：支持WebFlux，使得构建响应式应用变得更加容易。
新的构建工具选项：除了传统的Maven和Gradle，Spring Boot 3还支持新的构建工具选项，如Bazel。
Spring Boot Actuator 3：集成了新的Actuator版本，增强了应用的监控和管理能力。

为什么选择SpringBoot 3

选择Spring Boot 3有几个重要的理由：

简化配置：Spring Boot 3通过约定优于配置的理念，减少了大量配置工作，使得开发人员可以专注于业务逻辑的实现。
简化部署：Spring Boot 3自带嵌入式Web服务器（如Tomcat、Jetty等），使得应用可以更快地部署和运行。
快速启动：Spring Boot 3的应用可以快速启动，无需复杂的环境配置。
依赖管理：Spring Boot 3自动管理依赖关系，确保项目的依赖版本一致。
社区支持：Spring Boot 3拥有强大的社区支持和活跃的开发团队，可以更快地解决遇到的问题。

SpringBoot 3的安装与环境搭建

要开始使用Spring Boot 3，首先需要确保你的开发环境已经安装了以下软件：

Java 17：Spring Boot 3支持Java 17及以上版本。确保你的JDK版本符合要求。
IDE：推荐使用IntelliJ IDEA或Eclipse等现代IDE，它们都支持Spring Boot。
构建工具：选择Maven或Gradle作为构建工具。

以下是安装和配置过程的详细步骤：

安装Java 17：
- 访问Oracle官网或Adoptium等网站，下载并安装Java 17。
- 验证Java版本：
```
java -version
```
安装IDE：
- 下载并安装IntelliJ IDEA或Eclipse。
- 如果使用IntelliJ IDEA，确保安装了Spring Boot插件。
安装构建工具：
- 对于Maven：
```
mvn -version
```
- 对于Gradle：
```
gradle -v
```

接下来，确保你的环境变量配置正确。例如，对于Java环境变量，可以在Windows和Linux中分别设置：

Windows：

PATH=C:\Program Files\Java\jdk-17\bin;%PATH%

Linux：

PATH=/usr/lib/jvm/java-17-openjdk-amd64/bin:$PATH

创建第一个SpringBoot 3项目

使用Spring Initializr快速创建项目

Spring Initializr是一个在线工具，用于快速生成Spring Boot项目。它能够自动生成项目结构和必要的配置文件。

访问Spring Initializr官网：
- 在线地址：https://start.spring.io/
选择项目配置：
- Project：Maven Project
- Language：Java
- Spring Boot：选择版本（例如3.0.0）
- Packaging：Jar
- Java：选择版本（例如17）
- Dependencies：根据需要选择依赖项，例如Spring Web、Spring Data JPA等。
生成代码：
- 点击“Generate”按钮，下载生成的项目压缩包。
解压下载的压缩包，导入到IDE中。

以下是通过命令行使用Maven创建项目的示例：

mvn archetype:generate -DgroupId=com.example -DartifactId=springboot3demo -Dversion=1.0.0 -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

项目结构解析

生成的Spring Boot项目包含了一些标准文件和目录：

src/main/java：存放Java源代码文件，包括主类文件。
src/main/resources：存放资源文件，如配置文件application.properties或application.yml。
src/main/resources/META-INF：包含Spring Boot启动所需的清单文件。
src/test/java：存放测试用例。
pom.xml：Maven项目的配置文件，定义了项目的依赖关系、构建配置等。

主类通常位于src/main/java目录下，例如com.example.springboot3demo包下的Application.java文件。该文件通常包含一个main方法，用于启动Spring Boot应用。

简单的Hello World示例

为了验证项目是否成功创建，可以实现一个简单的“Hello World”示例。

在src/main/java/com/example/springboot3demo目录下创建一个主类Application.java：
```
package com.example.springboot3demo;
```

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class Application {

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

}

@RestController
class HelloWorldController {

@GetMapping("/")
public String hello() {
    return "Hello, Spring Boot 3!";
}

}


2. 运行主类：
```sh
mvn spring-boot:run

访问http://localhost:8080/，确认可以看到“Hello, Spring Boot 3!”。

SpringBoot 3的核心概念

配置文件详解

Spring Boot的配置文件主要分为两种：application.properties和application.yml。这里主要介绍application.properties，因为它更直观易读。

配置文件位于src/main/resources目录下，通过这些文件可以配置应用的各种属性，例如端口、数据源等。

下面是一些常用的配置示例：

端口：
```
server.port=8080
```

数据源配置：

spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

日志配置：

logging.level.root=INFO
logging.file.name=application.log

启用组件扫描：

spring.main.scan-base-packages=com.example.springboot3demo

自动配置机制

Spring Boot的核心特性之一是其自动配置机制。自动配置通过@SpringBootApplication注解实现，该注解包含@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个注解。

@SpringBootConfiguration：表明这是一个Spring Boot配置类。
@EnableAutoConfiguration：启用自动配置。
@ComponentScan：扫描指定包下的组件。

自动配置的原理是通过解析配置文件中的属性，动态注册Spring Bean，从而实现无需编写大量配置代码的应用初始化。

依赖注入与组件扫描

Spring Boot使用依赖注入来管理对象及其依赖关系。通过@Autowired注解可以将依赖的Bean注入到需要的地方。

下面是一个简单的例子，展示了如何使用依赖注入：

创建一个服务类GreetingService.java：
```
package com.example.springboot3demo;
```

import org.springframework.stereotype.Service;

@Service
public class GreetingService {

public String greet(String name) {
    return "Hello, " + name + "!";
}

}


2. 在控制器中注入服务：
```java
package com.example.springboot3demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

    private final GreetingService greetingService;

    @Autowired
    public HelloWorldController(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    @GetMapping("/")
    public String hello(@RequestParam String name) {
        return greetingService.greet(name);
    }
}

SpringBoot 3常用功能介绍

数据库集成（JPA, MyBatis等）

Spring Boot支持多种数据库和ORM框架，例如JPA和MyBatis。这里以JPA为例，展示如何集成数据库。

添加依赖：
在pom.xml中添加JPA和MySQL驱动依赖：

<dependencies>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>
</dependencies>

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

spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

定义实体类：


package com.example.springboot3demo.model;

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;

// Getters and Setters
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;
}

}


4. **创建Repository接口**：
```java
package com.example.springboot3demo.repository;

import com.example.springboot3demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

在服务中使用Repository：
```
package com.example.springboot3demo;
```

import com.example.springboot3demo.model.User;
import com.example.springboot3demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class UserService {

@Autowired
private UserRepository userRepository;

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

public Optional<User> findById(Long id) {
    return userRepository.findById(id);
}

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

}


6. **在控制器中调用服务**：
```java
package com.example.springboot3demo;

import com.example.springboot3demo.model.User;
import com.example.springboot3demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public List<User> listUsers() {
        return userService.findAll();
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
}

RESTful API开发

Spring Boot支持快速开发RESTful API。下面是一个简单的示例：

定义实体类：


package com.example.springboot3demo.model;

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

@Entity
public class Post {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String title;
private String content;

// Getters and Setters
public Long getId() {
    return id;
}

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

public String getTitle() {
    return title;
}

public void setTitle(String title) {
    this.title = title;
}

public String getContent() {
    return content;
}

public void setContent(String content) {
    this.content = content;
}

}


2. **创建Repository接口**：
```java
package com.example.springboot3demo.repository;

import com.example.springboot3demo.model.Post;
import org.springframework.data.jpa.repository.JpaRepository;

public interface PostRepository extends JpaRepository<Post, Long> {
}

定义服务类：


package com.example.springboot3demo.service;

import com.example.springboot3demo.model.Post;
import com.example.springboot3demo.repository.PostRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
public class PostService {

@Autowired
private PostRepository postRepository;

public List<Post> findAll() {
    return postRepository.findAll();
}

public Optional<Post> findById(Long id) {
    return postRepository.findById(id);
}

public Post save(Post post) {
    return postRepository.save(post);
}

}


4. **创建控制器**：
```java
package com.example.springboot3demo;

import com.example.springboot3demo.model.Post;
import com.example.springboot3demo.service.PostService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/posts")
public class PostController {

    @Autowired
    private PostService postService;

    @GetMapping
    public List<Post> listPosts() {
        return postService.findAll();
    }

    @GetMapping("/{id}")
    public Post getPost(@PathVariable Long id) {
        return postService.findById(id).orElse(null);
    }

    @PostMapping
    public Post createPost(@RequestBody Post post) {
        return postService.save(post);
    }

    @PutMapping("/{id}")
    public Post updatePost(@PathVariable Long id, @RequestBody Post post) {
        post.setId(id);
        return postService.save(post);
    }

    @DeleteMapping("/{id}")
    public void deletePost(@PathVariable Long id) {
        postService.findById(id).ifPresent(post -> postService.delete(post));
    }
}

日志管理与配置

Spring Boot提供了强大的日志管理功能。默认使用的是Logback，但也可以通过配置文件切换到其他日志框架。

配置日志级别：
在application.properties中配置日志级别：

logging.level.root=INFO
logging.level.com.example=DEBUG
logging.file.name=application.log

自定义日志格式：
可以通过logging.pattern.file属性自定义日志格式：
```
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss} %-5level %logger{36} - %msg%n
```

安全性与认证（Spring Security）

Spring Boot与Spring Security集成可以轻松实现认证和授权功能。这里提供一个简单的示例，展示如何实现基本的HTTP认证。

添加依赖：
在pom.xml中添加Spring Security依赖：

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

配置安全性：
创建一个配置类，继承自WebSecurityConfigurerAdapter：
```
package com.example.springboot3demo;
```

import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
            .antMatchers("/").permitAll()
            .anyRequest().authenticated()
        .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
        .and()
            .logout()
            .permitAll();
}

@Override
@Bean
public UserDetailsService userDetailsService() {
    UserDetails user = User.withDefaultPasswordEncoder()
        .username("user")
        .password("password")
        .roles("USER")
        .build();

    return new InMemoryUserDetailsManager(user);
}

}


3. **创建登录页面**：
   在`src/main/resources/templates`目录下创建一个`login.html`文件：
```html
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login Page</title>
</head>
<body>
    <div th:if="${param.error}">
        Invalid username or password.
    </div>
    <form th:action="@{/login}" method="post">
        <input type="text" name="username" placeholder="Username"/>
        <input type="password" name="password" placeholder="Password"/>
        <input type="submit" value="Login"/>
    </form>
</body>
</html>

映射登录控制器：
在控制器中添加登录页面的映射：
```
package com.example.springboot3demo;
```

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class LoginController {

@GetMapping("/login")
public String login() {
    return "login";
}

}


### 实战案例：构建一个简单的博客应用

#### 需求分析
假设我们要构建一个简单的博客应用，主要功能包括：

1. 用户注册与登录。
2. 发布和查看博客文章。
3. 用户可以评论文章。

#### 功能设计
1. **用户注册与登录**：
   - 实现用户注册和登录功能，验证用户名和密码。
   - 用户信息存储在数据库中。

2. **发布和查看博客文章**：
   - 用户可以发布新文章，包括标题、内容、发表日期等。
   - 查询和显示所有文章，按发表日期排序。

3. **用户评论文章**：
   - 用户可以在文章下发表评论。
   - 展示文章评论列表，按评论时间排序。

#### 代码实现与测试
我们将逐步实现这些功能，首先从用户注册和登录开始。

1. **创建用户实体类**：
```java
package com.example.springboot3demo.model;

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 username;
    private String password;

    // Getters and Setters
    public Long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

创建用户Repository接口：


package com.example.springboot3demo.repository;

import com.example.springboot3demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

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


3. **创建用户注册和登录服务**：
```java
package com.example.springboot3demo.service;

import com.example.springboot3demo.model.User;
import com.example.springboot3demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    public User registerUser(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        return userRepository.save(user);
    }

    public User login(String username, String password) {
        User user = userRepository.findByUsername(username);
        if (user != null && passwordEncoder.matches(password, user.getPassword())) {
            return user;
        }
        return null;
    }
}

创建控制器处理用户注册和登录：
```
package com.example.springboot3demo;
```

import com.example.springboot3demo.model.User;
import com.example.springboot3demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/users")
public class UserController {

@Autowired
private UserService userService;

@Autowired
private PasswordEncoder passwordEncoder;

@PostMapping("/register")
public User registerUser(@RequestBody User user) {
    return userService.registerUser(user);
}

@PostMapping("/login")
public User login(@RequestParam String username, @RequestParam String password) {
    return userService.login(username, password);
}

}


5. **创建数据库表**：
在`src/main/resources/schema.sql`文件中定义创建用户表的SQL脚本：
```sql
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(255) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL
);

测试用户注册和登录：
使用Postman或IntelliJ IDEA的HTTP Client插件进行测试：

注册新用户：

POST /api/users/register
Body: {"username": "testuser", "password": "password"}

登录用户：

POST /api/users/login
Params: username=testuser&password=password

接下来，我们将实现文章发布和查看功能。

创建文章实体类：


package com.example.springboot3demo.model;

import javax.persistence.*;
import java.util.Date;

@Entity
public class Post {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String title;
private String content;
private Date date;

@ManyToOne
private User author;

// Getters and Setters
public Long getId() {
    return id;
}

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

public String getTitle() {
    return title;
}

public void setTitle(String title) {
    this.title = title;
}

public String getContent() {
    return content;
}

public void setContent(String content) {
    this.content = content;
}

public Date getDate() {
    return date;
}

public void setDate(Date date) {
    this.date = date;
}

public User getAuthor() {
    return author;
}

public void setAuthor(User author) {
    this.author = author;
}

}


2. **创建文章Repository接口**：
```java
package com.example.springboot3demo.repository;

import com.example.springboot3demo.model.Post;
import org.springframework.data.jpa.repository.JpaRepository;

public interface PostRepository extends JpaRepository<Post, Long> {
}

创建文章服务：


package com.example.springboot3demo.service;

import java.util.Date;

@Service
public class PostService {

@Autowired
private PostRepository postRepository;

public Post savePost(Post post) {
    post.setDate(new Date());
    return postRepository.save(post);
}

public List<Post> findAllPosts() {
    return postRepository.findAll();
}

}


4. **创建控制器处理文章发布和查看**：
```java
package com.example.springboot3demo;

import com.example.springboot3demo.model.Post;
import com.example.springboot3demo.model.User;
import com.example.springboot3demo.service.PostService;
import com.example.springboot3demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/posts")
public class PostController {

    @Autowired
    private PostService postService;

    @Autowired
    private UserService userService;

    @PostMapping
    public Post createPost(@RequestBody Post post, @RequestParam String username) {
        User author = userService.findByUsername(username);
        post.setAuthor(author);
        return postService.savePost(post);
    }

    @GetMapping
    public List<Post> listPosts() {
        return postService.findAllPosts();
    }
}

测试文章发布和查看：

发布新文章：

POST /api/posts
Headers: Content-Type: application/json
Body: {"title": "First Post", "content": "This is my first post"}
Params: username=testuser

查看所有文章：
```
GET /api/posts
```

接下来，实现评论功能。

创建评论实体类：


package com.example.springboot3demo.model;

import javax.persistence.*;
import java.util.Date;

@Entity
public class Comment {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String content;
private Date date;

@ManyToOne
private User author;

@ManyToOne
private Post post;

// Getters and Setters
public Long getId() {
    return id;
}

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

public String getContent() {
    return content;
}

public void setContent(String content) {
    this.content = content;
}

public Date getDate() {
    return date;
}

public void setDate(Date date) {
    this.date = date;
}

public User getAuthor() {
    return author;
}

public void setAuthor(User author) {
    this.author = author;
}

public Post getPost() {
    return post;
}

public void setPost(Post post) {
    this.post = post;
}

}


2. **创建评论Repository接口**：
```java
package com.example.springboot3demo.repository;

import com.example.springboot3demo.model.Comment;
import org.springframework.data.jpa.repository.JpaRepository;

public interface CommentRepository extends JpaRepository<Comment, Long> {
}

创建评论服务：


package com.example.springboot3demo.service;

import com.example.springboot3demo.model.Comment;
import com.example.springboot3demo.repository.CommentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
public class CommentService {

@Autowired
private CommentRepository commentRepository;

public Comment saveComment(Comment comment) {
    comment.setDate(new Date());
    return commentRepository.save(comment);
}

}


4. **创建控制器处理评论发布与查看**：
```java
package com.example.springboot3demo;

import com.example.springboot3demo.model.Comment;
import com.example.springboot3demo.model.Post;
import com.example.springboot3demo.model.User;
import com.example.springboot3demo.service.CommentService;
import com.example.springboot3demo.service.PostService;
import com.example.springboot3demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/comments")
public class CommentController {

    @Autowired
    private CommentService commentService;

    @Autowired
    private PostService postService;

    @Autowired
    private UserService userService;

    @PostMapping
    public Comment createComment(@RequestBody Comment comment, @RequestParam String username, @RequestParam Long postId) {
        User author = userService.findByUsername(username);
        Post post = postService.findById(postId);
        comment.setAuthor(author);
        comment.setPost(post);
        return commentService.saveComment(comment);
    }

    @GetMapping("/{postId}")
    public List<Comment> listCommentsByPost(@PathVariable Long postId) {
        Post post = postService.findById(postId);
        return post.getComments();
    }
}

总结与进阶资源

SpringBoot 3学习资源推荐

Spring Boot 3提供了丰富的学习资源，包括官方文档、教程、视频课程等。以下是一些推荐的学习资源：

官方文档：
- Spring Boot官方文档详尽地介绍了Spring Boot的核心概念和用法。
- 链接：https://docs.spring.io/spring-boot/docs/3.0.0/reference/html/
在线教程：
- 官方网站上的教程提供了从入门到进阶的详细指南。
- 链接：https://spring.io/guides/gs/spring-boot/
视频课程：
- 例如慕课网、极客时间等平台上的Spring Boot课程，适合不同层次的学习者。
- 链接：https://www.imooc.com/course/list?c=java

常见问题与调试技巧

在使用Spring Boot过程中，常见的问题包括配置错误、依赖问题、安全性问题等。以下是一些调试技巧：

查看日志：
- 日志文件可以帮助定位问题，特别是在启动和运行过程中。
- 查看logging.file.name配置的日志文件。
使用IDE调试工具：
- 使用IntelliJ IDEA或Eclipse内置的调试工具，可以逐步执行代码，查看变量值，发现逻辑错误。
依赖冲突：
- 使用Maven或Gradle的依赖树命令查看依赖关系。
- Maven：mvn dependency:tree
- Gradle：./gradlew dependencies

进一步学习的方向与建议

深入Spring Boot源码：
- 深入理解Spring Boot的自动配置机制，学习如何编写自定义的自动配置类。
- 参考链接：https://docs.spring.io/spring-boot/docs/3.0.0/reference/html/
微服务架构：
- 学习如何使用Spring Boot构建微服务架构，包括服务发现、负载均衡、服务网关等。
- 参考链接：https://spring.io/guides/gs/microservices/
Spring Cloud：
- 学习Spring Cloud的集成，包括服务注册与发现、配置中心、熔断机制等。
- 参考链接：https://spring.io/projects/spring-cloud
性能优化：
- 学习如何优化Spring Boot应用的性能，包括数据库优化、缓存机制、异步处理等。
- 参考链接：https://spring.io/blog/2015/04/21/optimizing-spring-boot-applications

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

翻阅古今

手记
篇

粉丝

9

获赞与收藏

36

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30787 345

网络编程入门教程

20个小节 12720 239

Pandas 入门教程

25个小节 18599 341

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空