此快速参考备忘单提供了使用 Spring Boot 的用法
注:开发 springboot 需要要基本的 java 基础和 maven 基础。
Spring Boot 是一个用于简化 Spring 应用程序开发的框架。它提供了一种简单的方式来创建、运行和部署 Spring 应用程序,并简化了配置和依赖管理。
Spring Initializr
创建项目Spring Initializr
创建项目,选择依赖项(如Web、JPA、Security)和 Spring Boot 版本pom.xml
(Maven) 或 build.gradle
(Gradle) 文件中src/main/resources
目录下创建 application.properties
或application.yml
文件,配置应用程序属性,例如数据库连接信息、端口号等在Spring Boot应用程序中,通常使用YAML格式(.yml
文件)来配置应用程序的属性和设置。相比于传统的.properties
文件,YAML格式更加清晰易读,并且支持层级结构和列表等复杂数据类型。以下是一些常用的Spring Boot YAML配置字段及其说明:
server.port
: 配置应用程序的端口号。spring.application.name
: 配置应用程序的名称。spring.datasource.url
: 配置数据库连接的URL。spring.datasource.username
: 配置数据库连接的用户名。spring.datasource.password
: 配置数据库连接的密码。logging.level
: 配置日志记录的级别,如DEBUG
、INFO
、WARN
、ERROR
等。management.endpoints.web.exposure.include
: 配置哪些管理端点(如health
、info
)可以通过Web访问。spring.jpa.hibernate.ddl-auto
: 配置Hibernate的DDL模式,如update
、create
、create-drop
等。spring:
application:
name: my-application
spring.application.name
: 应用程序的名称。在集成服务发现和配置管理时特别有用,也会影响Actuator端点的路径。
server:
port: 8080
server.port
: 应用程序监听的HTTP端口号。默认为8080,可以根据需要进行配置。
spring:
datasource:
url: jdbc:mysql://localhost:3306/mydatabase
username: root
password: password
driver-class-name: com.mysql.cj.jdbc.Driver # 这里是 MySQL8.0 版本配置,5.0 则是 com.mysql.jdbc.Driver
spring.datasource.url
: 数据库连接URL。spring.datasource.username
和 spring.datasource.password
: 数据库的用户名和密码。spring.datasource.driver-class-name
: 数据库驱动类名。spring:
jpa:
show-sql: true
hibernate:
ddl-auto: update
spring.jpa.show-sql
: 是否在控制台显示SQL语句。spring.jpa.hibernate.ddl-auto
: Hibernate自动建表策略,如update
、create
、validate
等。logging:
level:
org.springframework: INFO
com.example: DEBUG
logging.level
: 日志级别配置,可以针对不同的包或类设置不同的日志级别。spring:
security:
user:
name: user
password: password
basic:
enabled: true
spring.security.user.name
和 spring.security.user.password
: 基本认证的用户名和密码。spring.security.basic.enabled
: 是否启用基本认证。management:
endpoints:
web:
exposure:
include: health, info
management.endpoints.web.exposure.include
: 暴露给外部的Actuator端点,可以设置为*
来暴露所有端点。spring:
profiles:
active: dev
spring.profiles.active
: 指定当前激活的环境配置文件,可以根据需要选择dev
、prod
等不同的配置文件。myapp:
custom:
property: value
@Value
注解或Environment
对象访问。Spring Boot 的 Starter 依赖项是预先配置的一组依赖项集合,它们以 spring-boot-starter-*
的命名格式提供。这些 Starter 依赖项可以按照功能领域进行分类,例如:
spring-boot-starter-web
: 支持构建Web应用程序,包括Spring MVC和内嵌的Servlet容器(如Tomcat)。spring-boot-starter-data-jpa
: 支持使用Spring Data JPA访问数据库,包括Hibernate和JPA实现。spring-boot-starter-security
: 支持Spring Security,用于身份验证和授权。spring-boot-starter-test
: 支持单元测试和集成测试,包括JUnit、Mockito等。spring-boot-starter-actuator
: 支持集成Actuator,用于监控和管理应用程序。引入Starter依赖项可以快速添加特定功能,Spring Boot会自动配置所需的组件和设置,减少手动配置工作量。
Spring Boot的BOM(Bill of Materials)集中管理各个 Starter 依赖项的版本,通过在pom.xml
(Maven)或 build.gradle
(Gradle)中引入 BOM,可以简化依赖项版本管理。例如,在 Maven 项目中:
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.6.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
这样一来,当你在项目中引入 Spring Boot 的 Starter 依赖项时,不需要显式声明版本号,Maven 会自动使用 BOM 中指定的版本。
尽管Spring Boot提供了丰富的Starter依赖项和依赖管理功能,但有时你可能需要自定义特定的依赖项或版本。在这种情况下,你可以在pom.xml
或build.gradle
中显式声明所需的依赖项,而不使用Starter依赖项。
例如,在Maven项目中,你可以这样声明一个依赖项:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.6.0</version>
</dependency>
这样做可以覆盖Spring Boot BOM中指定的版本,允许你使用特定版本的依赖项。
在实际项目中,可能会遇到依赖项之间的冲突或不兼容性问题。Spring Boot允许你通过<exclusions>
标签来排除Starter依赖项中的某些传递性依赖,以解决冲突问题。
例如,在Maven项目中排除传递性依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
这种排除机制使得你可以更精确地控制项目中依赖项的版本和组合,以避免不必要的冲突。
依赖注入是Spring框架的核心概念之一,它通过控制反转(IoC,Inversion of Control)的方式管理对象之间的依赖关系,从而实现松耦合、可测试和可维护的代码结构。Spring Boot通过自动配置的方式支持依赖注入,以下是一些关键点:
Spring Boot根据类路径中的依赖项自动配置应用程序上下文。这包括自动扫描和注册带有特定注解(如@Component
、@Service
、@Repository
等)的Bean,以及自动解析和注入这些Bean之间的依赖关系。
开发者可以使用@Autowired
注解在需要依赖注入的地方注入其他Bean,Spring Boot会自动解析和注入所需的依赖。例如:
@RestController
public class MyContr {
private final MyService myService;
@Autowired
public MyContr(MyService myService) {
this.myService = myService;
}
// Controller methods
}
在上面的例子中,MyController
中的MyService
依赖通过构造函数注入。
Spring Boot支持根据条件选择性地注入Bean。例如,可以使用 @Conditional
注解或 @ConditionalOnProperty
注解根据特定的条件决定是否创建和注入Bean。
面向切面编程是一种软件开发方法,用于分离横切关注点(cross-cutting concerns),例如日志、事务管理、安全性等,以便更好地模块化和管理应用程序。Spring Boot通过整合Spring AOP框架支持面向切面编程,以下是相关的说明:
切面是一个模块化的类,它包含了横切关注点的逻辑。在Spring Boot中,可以使用@Aspect
注解标记一个类作为切面,并通过@Before
、@After
、@Around
等注解定义切面的具体行为。
切点定义了在应用程序中哪些位置应用切面逻辑。切点表达式使用execution
关键字指定要拦截的方法调用。例如:
@Aspect
@Component
public class LoggingAspect {
@Before("execution(* com.example.service.*.*(..))")
public void beforeServiceMethods(JoinPoint joinPoint) {
// Advice logic before service method execution
}
// Other advices (e.g., @After, @Around) can be defined similarly
}
通知是在切点处执行的具体逻辑,包括@Before
、@AfterReturning
、@AfterThrowing
、@Around
等。例如,在上面的例子中,beforeServiceMethods
方法就是一个@Before
通知,它在目标方法执行之前执行。
Spring Boot通过自动配置和注解扫描使得使用AOP变得非常简单。通常情况下,只需在切面类上加上@Aspect
注解,并确保它被Spring Boot的组件扫描机制扫描到即可。
你可以使用 Spring Initializr 创建一个新的 Spring Boot 项目。访问 start.spring.io 并按照以下配置创建项目:
点击 "Generate" 下载项目的 zip 文件。
解压下载的文件并导入到你喜欢的 IDE 中(如 IntelliJ IDEA、Eclipse 等)。
在 IDE 中打开你的项目,导航到 src/main/java/com/example/helloworld
。你会看到一个名为 HelloworldApplication.java
的类文件,这是 Spring Boot 应用程序的入口类。
在这个类的同级目录下创建一个新的 Java 类文件,例如 HelloController.java
,并添加以下内容:
package com.example.helloworld;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@GetMapping("/")
public String hello() {
return "Hello, World!";
}
}
使用 Maven 或 Gradle 构建项目并启动应用程序。可以通过 IDE 的运行功能或者命令行执行以下命令:
mvn spring-boot:run
或者
./gradlew bootRun
在浏览器中访问 http://localhost:8080/
,你应该能够看到显示 "Hello, World!" 的页面。
这样,你就成功创建了一个简单的 Spring Boot Web 应用程序,并实现了一个基本的 "Hello, World!" 示例。
注意:需要选择 jpa 和对应数据库的驱动
默认情况下,Spring Boot 使用 H2 Database 作为内嵌数据库。如果你想使用其他数据库,可以在 application.properties
(或 application.yml
)文件中配置数据库连接信息。
例如,使用 H2 Database 的默认配置:
# application.properties
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=username
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto=update
创建一个简单的控制器 UserController
,用来处理 HTTP 请求,并操作 UserRepository
来访问数据库。
package com.example.userdemo;
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 UserRepository userRepository;
// 获取所有用户
@GetMapping("/")
public List<User> getAllUsers() {
return userRepository.findAll();
}
// 通过 id 获取用户
@GetMapping("/{id}")
public User getUserById(@PathVariable("id") Long id) {
return userRepository.findById(id).orElse(null);
}
// POST 创建新用户
@PostMapping("/")
public User addUser(@RequestBody User user) {
return userRepository.save(user);
}
// PUT 更新用户
@PutMapping("/{id}")
public User updateUser(@PathVariable("id") Long id, @RequestBody User userDetails) {
User user = userRepository.findById(id).orElse(null);
if (user != null) {
user.setUsername(userDetails.getUsername());
user.setAge(userDetails.getAge());
user.setSex(userDetails.getSex());
return userRepository.save(user);
}
return null;
}
// DELETE 删除用户
@DeleteMapping("/{id}")
public void deleteUser(@PathVariable("id") Long id) {
userRepository.deleteById(id);
}
}
在同样的目录下创建一个接口 UserRepository
,继承自 JpaRepository<User, Long>
,这样 Spring Data JPA 将会自动实现一些基本的数据库操作方法。
package com.example.userdemo;
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
}
User
在 src/main/java/com/example/userdemo
目录下创建一个名为 User
的实体类:
package com.example.userdemo;
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 userId;
private String username;
private Integer age;
private String sex;
// Constructors, getters, and setters 省略
}
使用 Maven 或 Gradle 构建并运行你的应用程序。然后,可以使用 Postman 或浏览器访问以下 API 来测试你的应用程序:
http://localhost:8080/users/
获取所有用户http://localhost:8080/users/{id}
http://localhost:8080/users/
http://localhost:8080/users/{id}
http://localhost:8080/users/{id}
在 src/main/java/com/example/demo
目录下创建一个名为 HelloController.java
的类:
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!";
}
}
创建过程同 web 项目创建
在 src/test/java/com/example/demo
目录下创建一个名为 HelloControllerTest.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.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.web.SpringJUnitWebConfig;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {
@Autowired
private MockMvc mockMvc;
@Test
public void helloTest() throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/hello"))
.andExpect(MockMvcResultMatchers.status().isOk())
.andExpect(MockMvcResultMatchers.content().string("Hello, World!"))
.andDo(print());
}
}
@SpringBootTest
: 这个注解告诉 Spring Boot 在测试时启动整个 Spring 应用程序上下文。@AutoConfigureMockMvc
: 这个注解确保在测试中自动配置 MockMvc 实例,用于模拟 HTTP 请求。@Autowired private MockMvc mockMvc
: 注入 MockMvc 实例,用于执行 HTTP 请求并验证响应。@Test public void helloTest()
: 这是一个 JUnit 测试方法,用来测试 HelloController
中的 hello()
方法。mockMvc.perform(...)
: 执行一个 GET 请求到 /hello
接口。andExpect(MockMvcResultMatchers.status().isOk())
: 预期响应的状态码是 200 OK。andExpect(MockMvcResultMatchers.content().string("Hello, World!"))
: 预期响应的内容是 "Hello, World!"。andDo(print())
: 打印请求和响应的详细信息,方便调试。运行测试,确保程序正确.
Spring Boot 应用程序可以打包为以下几种方式之一:
java -jar
命令来运行。当你运行 Maven 的构建命令时,它们会执行以下几个主要步骤来打包你的应用程序:
依赖项解析和下载
:构建工具会检查你项目中的依赖项,下载缺失的依赖并构建整个依赖树。编译代码
:构建工具会编译你的 Java 代码、资源文件等。运行测试
:通常会执行单元测试和集成测试,确保代码质量和功能正确性。打包应用程序
:
输出结果
:构建工具会在指定的目录下生成打包好的 JAR 或 WAR 文件,通常位于 target
目录下(Maven)。在你的 Spring Boot 项目中,通常有一个入口类(如 Application.java
或者根据你的项目命名)。这个类使用 @SpringBootApplication
注解标记,它包含了 main
方法用来启动应用程序。
通常使用以下两种构建工具来打包 Spring Boot 应用程序:
mvn package
命令可以将应用程序打包为 JAR 或 WAR 文件。pom.xml
文件中,Spring Boot 应用程序通常会依赖于 spring-boot-starter-parent
父项目,这简化了 Maven 配置和依赖管理。假设你有一个简单的 Spring Boot 应用程序,并且已经配置好了 Maven 或 Gradle。运行以下命令即可进行打包:
mvn clean package
构建工具会执行以上步骤,生成可执行的 JAR 文件或 WAR 文件,你可以根据需要进行部署和运行。