首页手记 Springboot框架入门教程

Springboot框架入门教程

标签：

SpringBoot

概述

Spring Boot框架是一个基于Spring框架的简化开发工具，它通过约定优于配置的方式，帮助开发者快速搭建应用，减少配置工作。本文将详细介绍Spring Boot框架的主要特点、环境搭建、核心概念以及项目实践等内容，帮助读者快速掌握Spring Boot的开发技巧。

Spring Boot简介

什么是Spring Boot

Spring Boot 是一个基于Spring框架开发的框架，旨在简化基于Spring的应用程序开发。它通过约定优于配置的方式来提供一系列默认设置，使得开发过程更加简洁和高效。Spring Boot 可以减少开发人员在配置Spring应用上的时间，让开发者能够更加专注于业务逻辑的实现。

Spring Boot的主要特点

无需配置XML文件：Spring Boot 通过约定优于配置的原则，大多数情况下不需要编写冗长的XML配置文件。
自动化配置：Spring Boot 可以自动配置Spring应用，只需在合适的场景下引入相应的依赖，即可实现快速开发。
内置静态web内容支持：Spring Boot 内置了支持静态web内容的功能，开发者可以将静态文件放在项目的src/main/resources/static目录下，方便部署。
内嵌的Tomcat/Jetty服务器：Spring Boot 提供内置的Tomcat或Jetty服务器，使得应用可以直接启动，无需单独安装和配置应用服务器。
Spring MVC：Spring Boot 提供了对Spring MVC的支持，可以快速开发RESTful服务。
自动配置数据库连接：通过JDBC或JPA等技术，Spring Boot 可以自动配置数据库连接，简化了数据库的接入过程。
测试支持：Spring Boot 提供Spring MVC的单元测试支持，可以方便地进行单元测试和集成测试。

为什么选择Spring Boot

简化开发流程：Spring Boot 通过其自动化配置和约定优于配置的原则，简化了开发流程，减少了开发者配置的时间。
快速启动应用：Spring Boot 提供了丰富的内置支持，可以直接运行应用，无需单独配置应用服务器。
易于维护：Spring Boot 应用的配置简单，维护起来较为方便。
社区支持：Spring Boot 拥有强大的社区支持，可以在遇到问题时获得帮助。
微服务支持：Spring Boot 是微服务架构的优秀选择，可以快速搭建微服务架构，实现服务的拆分、部署和管理。
生态系统丰富：Spring Boot 与Spring Cloud等其他框架配合，构建了强大的生态系统，支持各种开发需求。

环境搭建与开发工具

安装Java开发环境

安装Java JDK
- 首先，从Oracle官方网站下载最新版本的JDK安装包。
- 例如，下载JDK 11版本，安装包名称为jdk-11.0.11_windows-x64_bin.exe。
- 双击安装包，按照提示进行安装，安装完成后，配置环境变量，确保Java能被系统识别。
- 在命令行窗口中输入java -version来验证安装是否成功。
- 示例输出：
```
java version "11.0.11" 2021-02-22 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.11+8-LTS)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.11+8-LTS, mixed mode, sharing)
```
下载并配置JDK
- 下载JDK安装包后，解压到指定目录。
- 配置环境变量：在系统环境变量中增加JAVA_HOME，指向JDK的安装目录，并将%JAVA_HOME%\bin添加到PATH变量中。
- 验证安装：在命令行中输入java -version，确保输出正确。
- 示例输出：
```
java version "11.0.11" 2021-02-22 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.11+8-LTS)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.11+8-LTS, mixed mode, sharing)
```

安装并配置IDE（如IntelliJ IDEA或Spring Tool Suite）

安装IntelliJ IDEA
- 下载IntelliJ IDEA的最新版本。
- 解压安装包，运行idea.sh或idea.exe启动程序。
- 注册或使用试用版本，进入IDE。
- 在IDE中配置项目设置，确保Java SDK被正确识别。
- 通过File -> Settings -> Build, Execution, Deployment -> Compiler配置编译器，设置编译器的默认编译级别。
- 通过File -> Settings -> Build, Execution, Deployment -> Build Tools -> Maven配置Maven，设置Maven的Home目录。
安装并配置Spring Tool Suite
- 下载Spring Tool Suite的最新版本。
- 解压安装包，运行sts.sh或sts.exe启动程序。
- 注册或使用试用版本，进入IDE。
- 在IDE中配置项目设置，确保Java SDK被正确识别。
- 通过Window -> Preferences -> Java -> Installed JREs配置Java SDK路径。
- 通过Window -> Preferences -> Maven -> User Settings配置Maven的Home目录，设置Maven本地存储库位置。
- 通过Window -> Preferences -> Java -> Compiler配置编译器，设置编译器的默认编译级别。

创建第一个Spring Boot项目

使用Spring Initializr创建项目
- 访问https://start.spring.io/
- 选择项目类型为Maven，语言为Java，依赖选择Spring Web。
- 点击Generate按钮下载生成的项目压缩包，解压后导入到IDE中。
- 在pom.xml文件中找到以下依赖：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
```
- 添加Spring Boot的父依赖，确保项目可以自动配置：
```
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>
```
使用IDE创建项目
- 打开IntelliJ IDEA或Spring Tool Suite，在菜单栏中选择File -> New -> Project。
- 选择Spring Initializr，配置项目类型为Maven，语言为Java，依赖选择Spring Web。
- 点击Next并完成创建，IDE会自动生成项目结构。
- 在项目根目录下的pom.xml文件中，确保添加了以下依赖：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
```
- 同时添加Spring Boot的父依赖：
```
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>
```

编写启动类

在src/main/java目录下创建包com.example.demo，并在该包下创建一个Java类DemoApplication。
编写启动类，类中包含main方法，使用@SpringBootApplication注解启动应用。

示例代码：

package com.example.demo;

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

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

编译并运行项目，确保应用可以正常启动。

示例输出：

2023-01-20 11:00:00,000  INFO 12345 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 2.477 seconds (JVM running for 3.627)

Spring Boot的核心概念

自动配置

自动配置的原理
- Spring Boot 通过@SpringBootApplication注解自动配置Spring应用。该注解组合了@Configuration、@EnableAutoConfiguration和@ComponentScan注解。
- @EnableAutoConfiguration注解允许Spring Boot自动配置项目。
- @ComponentScan注解允许扫描指定包下的组件（例如@Controller、@Service等）。
- @SpringBootApplication注解相当于组合了以上三个注解，简化了配置过程。
配置文件优先级
- Spring Boot 会读取并合并application.properties和application.yml文件中的配置项。
- 如果同时存在多个配置文件，Spring Boot 按照一定的优先级顺序读取配置，优先级从低到高为：
  - @Configuration类中的配置
  - application.properties或application.yml文件中的配置
  - bootstrap.properties或bootstrap.yml文件中的配置

起步依赖

起步依赖的定义
- 起步依赖是指一组相关联的依赖，它们共同完成某项具体的任务。
- 起步依赖通常会自动引入一些通用的库和配置。
- 例如，使用spring-boot-starter-web依赖来构建Web应用，会自动引入Tomcat服务器和Spring MVC的配置。
使用起步依赖
- 在pom.xml文件中添加起步依赖，例如：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
```
- 这样，Spring Boot 就会自动配置Web应用所需的组件，无需手动配置Spring MVC或Tomcat。

配置文件（application.properties和application.yml）

配置文件的区别
- application.properties是一个简单的键值对配置文件，使用等号=或冒号:分隔键值。
```
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/test
```
- application.yml则使用缩进和冒号来定义配置结构，适合更复杂的配置。
```
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
```

在代码中读取配置

在Java代码中，可以通过@Value注解来读取配置文件中的值：
```
@Value("${server.port}")
private int serverPort;
```

也可以使用@ConfigurationProperties注解将配置文件中的属性映射到POJO类中：

@Configuration
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties {
    private String url;
    private String username;
    private String password;
    // Getter and Setter
}

Spring Boot项目实践

创建RESTful服务

定义控制器

创建一个新的Java类UserController，并使用@RestController注解标记为REST控制器。
使用@RequestMapping注解定义URL路径。

示例代码：

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @GetMapping("/users")
    public String getUsers() {
        return "Hello Spring Boot!";
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

运行应用
- 通过IDE的运行按钮启动Spring Boot应用，或者在命令行中运行mvn spring-boot:run。
- 访问http://localhost:8080/users，页面会显示Hello Spring Boot!。

使用Spring Boot的内置服务器

内嵌的Tomcat服务器
- Spring Boot 内置了Tomcat服务器，可以自动配置并启动。
- 在IDE中直接运行DemoApplication类的main方法，即可启动应用，无需单独配置Tomcat服务器。
- 示例代码：
```
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
```
内嵌的Jetty服务器
- Spring Boot 也支持Jetty服务器，只需在pom.xml文件中添加spring-boot-starter-jetty依赖即可。
- 示例代码：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
```

集成数据库（如MySQL、H2）

集成MySQL数据库

在pom.xml文件中添加spring-boot-starter-data-jpa和mysql-connector-java依赖。

示例代码：

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

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

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

创建一个具体的实体类User，并使用@Entity注解标记为持久化实体。

示例代码：

package com.example.demo.entity;

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 int age;

    // Getter and Setter
}

创建一个持久化仓库UserRepository，继承JpaRepository接口。

示例代码：

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

集成H2内存数据库

在pom.xml文件中添加spring-boot-starter-data-jpa和spring-boot-starter-h2依赖。

示例代码：

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

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

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

使用Spring Boot的单元测试

编写Spring Boot单元测试

创建一个测试类，例如UserControllerTest，并使用@SpringBootTest注解标记为Spring Boot测试。
使用@Autowired注解注入控制器或其它需要测试的组件。
使用MockMvc进行HTTP请求模拟。

示例代码：

package com.example.demo.controller;

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.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest(UserController.class)
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        mockMvc.perform(get("/users"))
                .andExpect(status().isOk())
                .andExpect(content().string("Hello Spring Boot!"));
    }
}

编写Spring Boot集成测试

创建一个集成测试类，例如ApplicationIntegrationTest，并使用@SpringBootTest注解标记为Spring Boot测试。
使用@Autowired注解注入需要测试的应用程序上下文或组件。

示例代码：

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 org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.jdbc.SqlConfig;

@SpringBootTest
public class ApplicationIntegrationTest {

    @Autowired
    private UserRepository userRepository;

    @Test
    @Sql(scripts = "/schema.sql", config = @SqlConfig(transactionMode = SqlConfig.TransactionMode.ISOLATED))
    public void shouldInsertUser() {
        User user = new User();
        user.setName("John");
        user.setAge(30);
        userRepository.save(user);
        Long count = userRepository.count();
        assert count == 1L;
    }
}

打包与部署

将Spring Boot应用打包成可执行的jar文件

打包为可执行jar

在pom.xml文件中，确保添加spring-boot-maven-plugin依赖。

示例代码：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

执行mvn clean package命令，生成的jar文件位于target目录下。
可以通过java -jar target/demo-0.0.1-SNAPSHOT.jar命令运行生成的jar文件。

示例输出：

2023-01-20 12:00:00,000  INFO 12345 --- [           main] com.example.demo.DemoApplication         : Started DemoApplication in 2.477 seconds (JVM running for 3.627)

配置jar包的主类

在pom.xml文件中，可以配置spring-boot-maven-plugin的mainClass属性，指定项目的主类。

示例代码：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <mainClass>com.example.demo.DemoApplication</mainClass>
            </configuration>
        </plugin>
    </plugins>
</build>

部署到Tomcat或直接运行jar文件

部署到Tomcat
- 将生成的jar文件复制到Tomcat的webapps目录下。
- 启动Tomcat，访问http://localhost:8080/yourappname/users。
- 示例输出：
```
Hello Spring Boot!
```
直接运行jar文件
- 使用java -jar target/demo-0.0.1-SNAPSHOT.jar命令启动应用。
- 访问http://localhost:8080/users，页面会显示Hello Spring Boot!。
- 示例输出：
```
Hello Spring Boot!
```

使用Docker容器化部署

创建Dockerfile

在项目根目录下创建Dockerfile文件，定义镜像的构建步骤。

示例代码：

FROM openjdk:8-jdk-alpine
VOLUME /tmp
COPY target/demo-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

构建Docker镜像

在命令行中执行docker build -t springboot-demo .命令，构建镜像。

示例输出：

Sending build context to Docker daemon 101.9MB
Step 1/4 : FROM openjdk:8-jdk-alpine
 ---> 6587440c5a0f
Step 2/4 : VOLUME /tmp
 ---> Using cache
 ---> 7a6e400364a2
Step 3/4 : COPY target/demo-0.0.1-SNAPSHOT.jar app.jar
 ---> dfc4b3265b69
Step 4/4 : ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
 ---> Running in 4ce5b00b5d5f
Removing intermediate container 4ce5b00b5d5f
 ---> 6e1d2c9b65f6
Successfully built 6e1d2c9b65f6
Successfully tagged springboot-demo:latest

运行Docker容器
- 使用docker run -p 8080:8080 springboot-demo命令启动容器。
- 访问http://localhost:8080/users，页面会显示Hello Spring Boot!。
- 示例输出：
```
Hello Spring Boot!
```

常见问题解答

Spring Boot项目中最常见的问题

依赖版本冲突

由于项目中引入了多个依赖，可能会导致版本冲突。
解决方法：使用mvn dependency:tree命令查看依赖树，手动调整依赖版本，确保版本一致。

示例输出：

[INFO] com.example:demo:jar:0.0.1-SNAPSHOT
[INFO] +- org.springframework.boot:spring-boot-starter-web:jar:2.3.4.RELEASE:compile
[INFO] |  +- org.springframework.boot:spring-boot-starter:jar:2.3.4.RELEASE:compile
[INFO] |  |  +- org.springframework.boot:spring-boot:jar:2.3.4.RELEASE:compile
[INFO] |  |  +- org.springframework.boot:spring-boot-starter-logging:jar:2.3.4.RELEASE:compile
[INFO] |  |  |  +- ch.qos.logback:logback-classic:jar:1.2.3:compile
[INFO] |  |  |  |  \- ch.qos.logback:logback-core:jar:1.2.3:compile
[INFO] |  |  |  \- org.slf4j:jul-to-slf4j:jar:1.7.30:compile
[INFO] |  |  \- org.yaml:snakeyaml:jar:1.25:runtime
[INFO] |  \- org.springframework.boot:spring-boot-starter-tomcat:jar:2.3.4.RELEASE:compile
[INFO] |     \- org.apache.tomcat.embed:tomcat-embed-core:jar:9.0.36:compile
[INFO] |        \- org.apache.tomcat.embed:tomcat-embed-el:jar:9.0.36:compile
[INFO] |           \- org.apache.tomcat.embed:tomcat-embed-websocket:jar:9.0.36:compile
[INFO] +- org.springframework.boot:spring-boot-starter-data-jpa:jar:2.3.4.RELEASE:compile
[INFO] |  \- org.springframework.boot:spring-boot-starter-jdbc:jar:2.3.4.RELEASE:compile
[INFO] |     \- org.springframework:spring-jdbc:jar:5.2.8.RELEASE:compile
[INFO] \- mysql:mysql-connector-java:jar:8.0.22:runtime

自动配置失效
- 由于某些原因，Spring Boot 的自动配置可能失效。
- 解决方法：检查@SpringBootApplication注解是否正确使用，确保没有遗漏@EnableAutoConfiguration注解。
- 示例代码：
```
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
```
数据库连接失败
- 由于数据库连接配置错误，导致应用启动失败。
- 解决方法：检查application.properties或application.yml文件中数据库连接信息是否正确。
- 示例代码：
```
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
```

运行时异常

由于代码或配置错误，导致运行时出现异常。
解决方法：查看异常堆栈信息，定位问题原因，修复代码或配置。

示例输出：

2023-01-20 13:00:00,000 ERROR 12345 --- [           main] o.s.boot.SpringApplication               : Application run failed
org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'userController': Unsatisfied dependency expressed through field 'userRepository'; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.example.demo.repository.UserRepository' available

解决方法：检查UserController类中的UserRepository注入是否正确。

示例代码：

package com.example.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import com.example.demo.repository.UserRepository;

@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public String getUsers() {
        // 业务逻辑
        return "Hello Spring Boot!";
    }
}

一些解决方法和技巧

使用Spring Initializr创建项目
- 使用Spring Initializr在线工具创建项目，避免手动配置依赖和项目结构。
- 示例URL：https://start.spring.io/
查看日志输出
- 在控制台查看Spring Boot的日志输出，了解应用启动和运行情况。
- 使用--debug启动参数，可以输出更多调试信息。
- 示例代码：
```
java -jar target/demo-0.0.1-SNAPSHOT.jar --debug
```
使用IDE自带的调试功能
- 利用IDE的调试功能，设置断点，逐步执行代码，方便快速定位问题。
- 在IntelliJ IDEA中，可以使用Run -> Debug 'DemoApplication'命令启动应用。
- 在代码中设置断点，逐步执行代码，查看变量值。

如何调试Spring Boot应用

设置断点

在IDE中找到需要调试的代码行，右键点击代码行并选择Toggle Breakpoint设置断点。
或者直接点击代码行左侧的空白区域设置断点。

示例代码：

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @GetMapping("/users")
    public String getUsers() {
        // 设置断点
        return "Hello Spring Boot!";
    }
}

启动调试模式
- 在IDE中点击Run -> Debug 'DemoApplication'，启动调试模式。
- 在命令行中运行mvn spring-boot:run -Dspring-boot.run.jvmArguments="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005，并在IDE中配置远程调试连接。
- 配置远程调试连接：
  - 在IntelliJ IDEA中，依次点击Run -> Debug -> Edit Configurations。
  - 点击+号，选择Remote，配置Port为5005，点击OK。
- 示例代码：
```
mvn spring-boot:run -Dspring-boot.run.jvmArguments="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005"
```

查看变量值

在断点处，IDE会暂停执行，显示当前行的所有变量的值。
可以查看变量值，分析程序状态。

示例输出：

- UserController: getUsers
    - userRepository: com.example.demo.repository.UserRepository@12345
    - this: com.example.demo.controller.UserController@56789

单步执行

在断点处，点击Step Over按钮（或按F8键），执行当前行代码。
点击Step Into按钮（或按F7键），进入方法内部执行。
点击Step Out按钮（或按Shift + F8键），跳出当前方法执行。

示例代码：

package com.example.demo.controller;

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

@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public String getUsers() {
        // 设置断点
        List<User> users = userRepository.findAll();
        return "Hello Spring Boot!";
    }
}

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

牧羊人nacy

手记
篇

粉丝

5

获赞与收藏

26

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30787 345

网络编程入门教程

20个小节 12720 239

Pandas 入门教程

25个小节 18599 341

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Springboot框架入门教程

什么是Spring Boot

Spring Boot的主要特点

为什么选择Spring Boot

安装Java开发环境

安装并配置IDE（如IntelliJ IDEA或Spring Tool Suite）

创建第一个Spring Boot项目

自动配置

起步依赖

配置文件（application.properties和application.yml）

创建RESTful服务

使用Spring Boot的内置服务器

集成数据库（如MySQL、H2）

使用Spring Boot的单元测试

将Spring Boot应用打包成可执行的jar文件

部署到Tomcat或直接运行jar文件

使用Docker容器化部署

Spring Boot项目中最常见的问题

一些解决方法和技巧

如何调试Spring Boot应用

阅读免费教程