SpringBoot学习：初学者快速入门教程

概述

SpringBoot学习涵盖了从基础概念到实战项目的全面指南，包括快速搭建第一个SpringBoot项目、环境搭建、核心概念讲解、常用功能实现以及常见问题解决等内容。文章详细介绍了SpringBoot的优势、自动配置机制、依赖注入和配置文件的使用方法，帮助读者快速掌握SpringBoot开发技能。

SpringBoot简介

SpringBoot是什么

Spring Boot 是由 Pivotal 团队开发的一个基于 Spring 框架的开源项目。它旨在简化 Spring 应用程序的开发过程，使开发者能够更快地构建独立运行的、生产级别的 Spring 应用程序。Spring Boot 具有以下主要特点：

• 快速开发：Spring Boot 通过约定优于配置的方式，减少了开发者需要编写的配置代码量。
• 轻量级：Spring Boot 框架本身并不引入任何额外的依赖，使开发者能够快速搭建应用。
• 无需繁琐配置：Spring Boot 自动处理大部分配置细节，如自动配置数据库连接、数据库事务等。
• 内置特性：Spring Boot 内置了各种实用功能，如内置的 Web 服务器（Tomcat、Jetty 或 Undertow）、静态资源（CSS、JavaScript 和图片）支持、JPA 支持等。

SpringBoot的优势

Spring Boot 的优势主要体现在以下几个方面：

• 简化配置：Spring Boot 通过约定优于配置的原则，大部分配置只要遵循 Spring Boot 的约定即可，减少了繁琐的手动配置。
• 启动速度快：Spring Boot 提供了快速的开发和启动模式，能够快速构建、打包和启动应用。
• 依赖管理：Spring Boot 自动管理依赖，减少了依赖版本冲突的可能性。
• 零依赖的命令行应用：Spring Boot 的 spring-boot-starter-actuator 组件提供了一系列帮助监控和管理应用的端点。
• 内置的生产就绪特性：Spring Boot 内置了许多生产级应用所需的功能，如性能监控、健康检查、外部配置支持等。

第一个SpringBoot项目搭建

要搭建第一个 Spring Boot 项目，首先需要创建一个新的 Spring Boot 项目。可以使用 Spring Initializr（https://start.spring.io/）来快速创建项目。以下是具体步骤：

1. 访问 https://start.spring.io/。
2. 选择项目基本信息（例如，项目名称、语言、打包方式等）。
3. 选择需要的技术堆栈（例如，Web、JPA、Thymeleaf 等）。
4. 点击 "Generate" 按钮生成项目压缩包。
5. 解压项目压缩包，使用 IDE 打开项目。
6. 编写主启动类 DemoApplication.java，该类通常位于 src/main/java/ 目录下，代码如下：

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);
    }

}

1. 启动项目。
2. 访问项目默认的启动页面，通常是 http://localhost:8080。

SpringBoot环境搭建

开发环境准备

Spring Boot 的开发环境需要以下配置：

• Java 开发环境：Java 8 或更高版本。
• 构建工具：Maven 或 Gradle。
• 操作系统：Windows、Linux 或 macOS。
• IDE：IntelliJ IDEA、Eclipse、Spring Tool Suite 等。

创建SpringBoot项目

创建 Spring Boot 项目可以使用多种方式，例如通过 Spring Initializr 在线生成，或者使用 IDE 直接创建。以下是使用 Spring Initializr 在线生成项目的方式：

1. 访问 https://start.spring.io/。
2. 选择 Java 项目类型。
3. 输入项目基本信息，如项目名称（demo）、语言（Java）、模块（非 Maven 项目），以及仓库（默认即可）。
4. 选择所需技术栈，例如选择 Web、JPA、Thymeleaf 等。
5. 点击 "Generate" 按钮，下载项目压缩包。
6. 解压缩项目压缩包，得到项目目录结构。

以下是一个简单的 Spring Boot 项目目录结构：

demo/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── demo/
│   │   │               └── DemoApplication.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── demo/
│                       └── DemoApplicationTests.java
└── .gitignore

配置IDE开发环境

以 IntelliJ IDEA 为例，配置 Spring Boot 开发环境的步骤如下：

1. 打开 IntelliJ IDEA。
2. 创建新项目，选择 "Java" 项目类型，选择 Spring Initializr 创建的项目文件夹，点击 "Next"。
3. 选择 Java 版本（建议使用 Java 11 或更高版本）。
4. 点击 "Next"，进行下一步。
5. 点击 "Finish" 完成项目创建。
6. IDE 会自动导入 Maven 依赖，等待导入完成后，就可以开始开发了。

SpringBoot核心概念

自动配置

Spring Boot 的自动配置功能是其最大亮点之一。Spring Boot 通过类路径中的类和 Java 注解来自动配置应用。@SpringBootApplication 注解是 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 的组合。

• @Configuration：表示该类是一个配置类，其中包含其他 Bean 的定义。
• @EnableAutoConfiguration：启用自动配置。Spring Boot 根据类路径中的类和依赖关系，自动配置一个或多个 Spring Bean。
• @ComponentScan：启用组件扫描，允许从指定包扫描其他组件（例如，@Service、@Controller 等）。

@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);
    }

}

依赖注入

Spring Boot 继承自 Spring 框架，支持依赖注入。依赖注入是一种设计模式，允许将组件的依赖关系通过外部配置注入到组件中。通过这种方式，组件的实现细节与依赖关系分离，提高了代码的可测试性和可维护性。

Spring Boot 使用 @Autowired 注解进行依赖注入示例代码如下：

package com.example.demo;

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

@Component
public class ExampleService {
    public String sayHello() {
        return "Hello, World!";
    }
}

package com.example.demo;

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

@RestController
public class ExampleController {
    private final ExampleService exampleService;

    public ExampleController(ExampleService exampleService) {
        this.exampleService = exampleService;
    }

    @GetMapping("/hello")
    public String hello() {
        return exampleService.sayHello();
    }

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

配置文件使用

Spring Boot 使用 application.properties 或 application.yml 文件进行配置。这些配置文件通常位于 src/main/resources 目录下。以下是一些常见的配置示例：

• 数据源配置：

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

• 日志配置：

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

• 端口配置：

server.port=8080

SpringBoot常用功能

数据库连接与操作

Spring Boot 支持多种数据库，如 MySQL、PostgreSQL、H2、Oracle 等。这里以 MySQL 为例，介绍如何进行数据库连接和操作。

添加依赖

在 pom.xml 中添加 JPA（Java Persistence API）和 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=secret
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

创建实体类

定义一个简单的实体类 User：

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;

    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 int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

创建仓库接口

定义一个 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> {
}

使用仓库接口

在控制器中使用 UserRepository 进行数据库操作：

package com.example.demo.controller;

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

import java.util.List;

@RestController
public class UserController {
    private final UserRepository userRepository;

    @Autowired
    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

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

RESTful接口开发

Spring Boot 可以轻松地开发 RESTful API。使用 @RestController 注解定义控制器类，使用 @GetMapping、@PostMapping、@PutMapping、@DeleteMapping 等注解定义 RESTful 接口。

示例

定义一个简单的 RESTful API：

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {
    private final UserRepository userRepository;

    @Autowired
    public UserController(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

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

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

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

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User userDetails) {
        User user = userRepository.findById(id).orElse(null);

        if (user != null) {
            user.setName(userDetails.getName());
            user.setAge(userDetails.getAge());
            userRepository.save(user);
        }

        return user;
    }

    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
        return "User deleted successfully";
    }
}

静态资源访问

Spring Boot 默认支持静态资源的访问，如 CSS、JavaScript、图片等。这些静态资源通常放置在 src/main/resources/static 或 src/main/resources/public 目录下。

示例

在 src/main/resources/static 目录下创建一个 index.html 文件：

<!DOCTYPE html>
<html>
<head>
    <title>Spring Boot Example</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <h1>Hello, World!</h1>
</body>
</html>

在 src/main/resources/static 目录下创建一个 styles.css 文件：

body {
    background-color: lightblue;
}

通过浏览器访问 http://localhost:8080/，即可看到页面上的样式和内容。

SpringBoot项目实战

实战项目选题

选择一个适合初学者的项目作为实战。比如一个简单的图书管理系统，包含图书信息的增删查改功能。以下是项目需求分析：

• 用户可以浏览所有图书信息。
• 用户可以搜索图书信息。
• 用户可以添加新的图书记录。
• 用户可以编辑已有的图书记录。
• 用户可以删除已有的图书记录。

项目需求分析

需求分析的目的是明确项目需要实现哪些功能，包括数据库设计、前端展示、后端接口等。

数据库设计

数据库表设计如下：

CREATE TABLE `book` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `title` VARCHAR(255) NOT NULL,
  `author` VARCHAR(255) NOT NULL,
  `description` TEXT,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

前端展示

前端展示部分可以使用 Thymeleaf 或者 HTML、CSS、JavaScript 来实现。可以创建如下的界面：

• 列表页：展示所有图书信息。
• 编辑页：编辑图书信息。
• 删除页：删除图书信息。

后端接口

后端接口可以分为以下几部分：

• GET /books：获取所有图书信息。
• GET /books/{id}：根据 id 获取图书信息。
• POST /books：创建新的图书记录。
• PUT /books/{id}：更新已有图书记录。
• DELETE /books/{id}：删除已有图书记录。

项目开发步骤

1. 创建项目：使用 Spring Initializr 创建一个包含 Web 和 JPA 的项目。
2. 实体类定义：定义 Book 实体类。
3. 数据源配置：配置 MySQL 数据库连接信息。
4. 仓库接口：定义 BookRepository 接口。
5. 控制器定义：定义 BookController 控制器。
6. 视图设计：设计前端页面。
7. 功能测试：测试各个接口是否能正常工作。

创建项目

访问 https://start.spring.io/ 选择 Web 和 JPA 依赖，生成项目并解压缩。

实体类定义

定义 Book 实体类：

package com.example.demo.entity;

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

@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String author;
    private String description;

    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 getAuthor() {
        return author;
    }

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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

数据源配置

在 application.properties 中配置 MySQL 数据源：

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

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

仓库接口

定义 BookRepository 接口：

package com.example.demo.repository;

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

public interface BookRepository extends JpaRepository<Book, Long> {
}

控制器定义

定义 BookController 控制器：

package com.example.demo.controller;

import com.example.demo.entity.Book;
import com.example.demo.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/books")
public class BookController {
    private final BookRepository bookRepository;

    @Autowired
    public BookController(BookRepository bookRepository) {
        this.bookRepository = bookRepository;
    }

    @GetMapping
    public List<Book> getAllBooks() {
        return bookRepository.findAll();
    }

    @GetMapping("/{id}")
    public Book getBookById(@PathVariable Long id) {
        return bookRepository.findById(id).orElse(null);
    }

    @PostMapping
    public Book createBook(@RequestBody Book book) {
        return bookRepository.save(book);
    }

    @PutMapping("/{id}")
    public Book updateBook(@PathVariable Long id, @RequestBody Book bookDetails) {
        Book book = bookRepository.findById(id).orElse(null);

        if (book != null) {
            book.setTitle(bookDetails.getTitle());
            book.setAuthor(bookDetails.getAuthor());
            book.setDescription(bookDetails.getDescription());
            bookRepository.save(book);
        }

        return book;
    }

    @DeleteMapping("/{id}")
    public String deleteBook(@PathVariable Long id) {
        bookRepository.deleteById(id);
        return "Book deleted successfully";
    }
}

视图设计

使用 Thymeleaf 创建简单的视图页面。在 src/main/resources/templates 目录下创建 index.html 文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Book Management</title>
    <link rel="stylesheet" type="text/css" href="/styles.css">
</head>
<body>
    <h1>Books</h1>
    <ul th:each="book : ${books}">
        <li th:text="${book.title}"></li>
    </ul>
    <a href="/add">Add New Book</a>
</body>
</html>

创建 styles.css 文件：

body {
    font-family: Arial, sans-serif;
    max-width: 800px;
    margin: 0 auto;
}

功能测试

启动项目后，访问 http://localhost:8080/api/books。使用 Postman 或者其他测试工具，测试各个接口是否正常工作。

SpringBoot常见问题与调试

常见错误及解决方案

1. 找不到主类
   • 确保主类已经被正确标记为 @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);
    }

}

1. 启动时找不到依赖

   • 检查 pom.xml 或 build.gradle 文件中是否包含了所有必要的依赖。
   • 确保 Maven/Gradle 已经正确配置。
2. 配置文件不正确
   • 检查 application.properties 或 application.yml 文件中的配置是否正确。
   • 确保配置文件路径正确。

调试技巧

1. 使用断点调试

   • 在 IntelliJ IDEA 或其他 IDE 中设置断点，逐步执行代码。
   • 使用 Spring Boot DevTools 进行热重载，方便快速调试。
2. 日志输出
   • 修改 application.properties 中的日志级别，以便输出更多的日志信息。

logging.level.root=DEBUG

1. IDE 插件
   • 使用 Spring Boot 插件，如 Spring Boot DevTools，可以方便地重新加载应用或重启应用。

性能优化入门

Spring Boot 应用的性能优化可以从以下几个方面入手：

1. 使用缓存
   • 使用 @Cacheable、@CachePut 和 @CacheEvict 注解进行缓存操作。
   • 配置缓存管理器，例如使用 Caffeine 或 Guava 缓存库。

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    @Cacheable("books")
    public Book getBookById(Long id) {
        // 查询数据库
        return bookRepository.findById(id).orElse(null);
    }
}

1. 异步任务处理
   • 使用 @Async 注解标记异步方法。
   • 配置异步任务执行器。

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;

@Service
@EnableAsync
public class AsyncService {
    @Async
    public void asyncMethod() {
        // 异步执行的任务
    }
}

1. 数据库优化
   • 使用连接池技术，如 HikariCP。
   • 调整数据库连接数，优化查询语句。

spring.datasource.hikari.maximum-pool-size=10

通过以上方法，可以有效地提高 Spring Boot 应用的性能和响应速度。