Spring Boot 快速入门

从零开始构建 Spring Boot 应用，掌握核心功能与最佳实践

咔咔收录于技术框架

2026-04-09 约 728 字预计阅读 4 分钟

什么是 Spring Boot

Spring Boot 是 Spring 框架的扩展，简化了 Spring 应用的初始搭建和开发过程。它提供了自动配置、起步依赖和嵌入式服务器等功能。

特点：

自动配置
起步依赖（Starter）
嵌入式服务器
生产级特性（监控、健康检查）

创建项目

方式一：Spring Initializr 网站

访问 https://start.spring.io/，选择：

Project: Maven
Language: Java
Spring Boot: 3.x
Dependencies: Spring Web

方式二：IDEA

File → New → Project → Spring Initializr

方式三：命令行

curl https://start.spring.io/starter.zip \
  -d dependencies=web \
  -d type=maven-project \
  -d baseDir=demo \
  -o demo.zip

项目结构

demo/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       └── DemoApplication.java
│   │   └── resources/
│   │       ├── static/        # 静态资源
│   │       ├── templates/     # 模板文件
│   │       └── application.properties
│   └── test/
│       └── java/
├── pom.xml
└── mvnw / mvnw.cmd

第一个应用

主类

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

REST Controller

@RestController
@RequestMapping("/api")
public class HelloController {

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

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable Long id) {
        return new User(id, "Alice", 25);
    }

    @PostMapping("/user")
    public User createUser(@RequestBody User user) {
        // 保存用户
        return user;
    }
}

实体类

public class User {
    private Long id;
    private String name;
    private Integer age;

    // 构造函数、Getter、Setter
    public User() {}

    public User(Long id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    // 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 Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
}

运行应用

./mvnw spring-boot:run

访问 http://localhost:8080/api/hello

配置文件

application.properties

# 服务器端口
server.port=8080

# 应用名称
spring.application.name=demo

# 日志级别
logging.level.root=INFO
logging.level.com.example=DEBUG

# 自定义属性
app.name=My Application
app.version=1.0.0

application.yml（推荐）

server:
  port: 8080

spring:
  application:
    name: demo
  profiles:
    active: dev

logging:
  level:
    root: INFO
    com.example: DEBUG

app:
  name: My Application
  version: 1.0.0

读取配置

@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private String version;
    // getters and setters
}

// 或者使用 @Value
@Component
public class SomeService {
    @Value("${app.name}")
    private String appName;
}

数据库访问（Spring Data JPA）

添加依赖

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

实体类

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

    @Column(nullable = false)
    private String name;

    @Column
    private Integer age;

    // getters and setters
}

Repository

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByName(String name);
    List<User> findByAgeGreaterThan(Integer age);
    
    @Query("SELECT u FROM User u WHERE u.name LIKE %:keyword%")
    List<User> searchByName(@Param("keyword") String keyword);
}

Service

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

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

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

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

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

全局异常处理

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
        ErrorResponse error = new ErrorResponse(
            HttpStatus.NOT_FOUND.value(),
            ex.getMessage()
        );
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAll(Exception ex) {
        ErrorResponse error = new ErrorResponse(
            HttpStatus.INTERNAL_SERVER_ERROR.value(),
            "An error occurred"
        );
        return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

拦截器

@Component
public class LoggingInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) {
        System.out.println("Request URL: " + request.getRequestURI());
        return true;
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoggingInterceptor loggingInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loggingInterceptor)
                .addPathPatterns("/api/**");
    }
}

定时任务

@Component
public class ScheduledTasks {

    // 每5秒执行一次
    @Scheduled(fixedRate = 5000)
    public void reportCurrentTime() {
        System.out.println("Current time: " + LocalDateTime.now());
    }

    // Cron表达式
    @Scheduled(cron = "0 0 9 * * MON")
    public void weeklyReport() {
        System.out.println("Weekly report");
    }
}

启用定时任务：

@SpringBootApplication
@EnableScheduling
public class DemoApplication {
    // ...
}

异步方法

@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> asyncMethod() {
        // 耗时操作
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("Done");
    }
}

启用异步：

@SpringBootApplication
@EnableAsync
public class DemoApplication {
    // ...
}

配置线程池：

spring:
  task:
    execution:
      pool:
        core-size: 5
        max-size: 10
        queue-capacity: 100

打包部署

打包 JAR

./mvnw clean package

# 跳过测试
./mvnw clean package -DskipTests

运行 JAR

java -jar target/demo-0.0.1-SNAPSHOT.jar

# 指定配置文件
java -jar demo.jar --spring.profiles.active=prod

Spring Boot Actuator

添加依赖

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

配置

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always

常用端点

/actuator/health - 健康检查
/actuator/info - 应用信息
/actuator/metrics - 指标数据
/actuator/loggers - 日志级别

总结

Spring Boot 极大地简化了 Spring 应用的开发，核心优势：

快速启动 - 起步依赖简化配置
自动配置 - 根据依赖自动配置
内嵌服务器 - 无需外部部署
生产就绪 - 内置监控和健康检查

继续学习：

Spring Security
Spring Cloud 微服务
Spring Data 高级特性
Reactive Programming（WebFlux）

目录

Spring Boot 快速入门

从零开始构建 Spring Boot 应用，掌握核心功能与最佳实践

什么是 Spring Boot

创建项目

方式一：Spring Initializr 网站

方式二：IDEA

方式三：命令行

项目结构

第一个应用

主类

REST Controller

实体类

运行应用

配置文件

application.properties

application.yml（推荐）

读取配置

数据库访问（Spring Data JPA）

添加依赖

实体类

Repository

Service

全局异常处理

拦截器

定时任务

异步方法

打包部署

打包 JAR

运行 JAR

Spring Boot Actuator

添加依赖

配置

常用端点

总结