Springboot教程：从入门到实践的详细指南-原创手记-慕课网

概述

Spring Boot教程介绍了如何简化Spring应用程序的开发过程，通过自动配置和起步依赖等功能，帮助开发者快速搭建独立的Spring应用。文章详细讲解了Spring Boot的核心特性和配置方法，并提供了创建和运行第一个Spring Boot应用的步骤。

Spring Boot简介

Spring Boot 是一个开源框架，旨在简化Spring应用程序的开发过程。它通过提供默认配置和自动化配置支持，允许开发人员快速搭建独立的、生产级别的Spring应用。

Spring Boot是什么

Spring Boot 是Spring框架的扩展，旨在简化Spring应用的初始搭建以及配置，并且为每个Spring开发者提供了一种一致的开发体验。Spring Boot使开发人员能够专注于业务逻辑的开发，而无需深入了解底层配置的细节。它通过约定优于配置的原则，减少了样板代码的编写，使得开发人员能够更快地上手开发。

Spring Boot的核心特性

Spring Boot 的核心特性包括自动配置、起步依赖、健康检查、内置Web服务器、命令行界面（CLI）以及Swagger集成等。

自动配置：Spring Boot 可以自动配置Spring应用程序的许多方面。例如，它可以根据类路径中的依赖关系来自动配置日志框架、Web服务器、数据库连接等。
起步依赖：Spring Boot 提供了一种依赖管理机制，可以简化项目的依赖管理。通过在 pom.xml 或 build.gradle 文件中声明 "起步依赖"，Spring Boot 自动地为项目添加必要的依赖。
健康检查：Spring Boot 提供了一组内置的健康检查端点，可以检查应用程序的健康状况。这些端点可以提供有关应用程序运行状况、数据库连接情况等信息。
内置Web服务器：Spring Boot 可以内置Tomcat、Jetty或Undertow等Web服务器，使得应用程序可以直接运行而无需外部服务器。
命令行界面：Spring Boot CLI 使得开发人员可以直接在命令行界面中运行Spring应用程序，简化了开发流程。
Swagger集成：Spring Boot 通常与Swagger集成，提供强大的API文档生成和测试功能。

安装与配置开发环境

安装和配置Spring Boot开发环境需要以下步骤：

安装Java开发工具包（JDK）：确保系统上安装了Java开发工具包。可以从Oracle官方网站或其他JDK发行版网站（如OpenJDK）下载并安装最新版的Java。
安装Maven或Gradle构建工具：Spring Boot项目通常使用Maven或Gradle作为构建工具。可以从Maven或Gradle的官方网站下载并安装这些工具。
安装IDE：推荐使用IntelliJ IDEA或Eclipse作为开发IDE。这些IDE都有强大的支持Spring Boot的插件，可以帮助你更高效地开发应用程序。
配置本地仓库：确保在Maven或Gradle配置文件中已经正确配置了本地仓库路径。

以下是Maven的 pom.xml 示例配置：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

第一个Spring Boot应用

本节将介绍如何创建和运行第一个Spring Boot应用。

创建Spring Boot项目

创建Spring Boot项目的方式有几种，可以使用Spring Initializr网站、IDE插件或直接在IDE内创建项目。

使用Spring Initializr：
- 访问Spring Initializr网站（https://start.spring.io/）。
- 选择项目类型（例如，Web应用）、语言（Java）、依赖（例如，Web的starter）。
- 提供项目组ID（com.example）和项目名（demo）。
- 选择构建工具（Maven或Gradle），并生成项目。
使用IDE插件：
- 在IntelliJ IDEA或Eclipse中，使用Spring Boot插件创建一个新的Spring Boot项目。
- 在Eclipse中，可以使用Spring Boot Tools插件，创建Spring Boot项目。
直接在IDE中创建项目：
- 在IntelliJ IDEA中，选择“New Project”并选择Spring Initializr。
- 在Eclipse中，选择“File -> New -> Spring Starter Project”。

配置项目基本设置

在 pom.xml（对于Maven）或 build.gradle（对于Gradle）文件中配置项目的依赖和基本设置。

以下是一个基于Maven的项目的基本配置示例：

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

运行第一个Spring Boot应用

创建一个简单的Spring Boot应用，提供一个简单的HTTP服务。在项目根目录下创建一个主类 Application.java，并添加一个简单的REST API。

package com.example.demo;

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
    public class HelloController {
        @GetMapping("/")
        public String home() {
            return "Hello, World!";
        }
    }
}

运行应用：

在IDE中右键点击 Application.java，选择 "Run"。
或者通过命令行运行 mvn spring-boot:run。

访问 http://localhost:8080，可以看到返回了 "Hello, World!"。

Spring Boot常用注解与配置

Spring Boot 使用注解简化了配置过程，同时提供了灵活的配置机制来满足不同需求。

常用注解介绍

Spring Boot 使用多种注解来简化配置和开发过程。以下是一些常用的注解：

@SpringBootApplication：组合了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan。用于启动Spring Boot应用程序。
@Controller 和 @RestController：用于定义控制器类。@RestController 是 @Controller 和 @ResponseBody 的组合，用于简化REST API的开发。
@Service：用于定义服务类，通常用于业务逻辑的实现。
@Repository：用于定义数据访问层（DAO层）的类，通常用于数据操作。

以下是一个简单的 @Service 类和 @RestController 类的示例：

package com.example.demo;

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

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

@RestController
public class HelloController {
    @Autowired
    private HelloService helloService;

    @GetMapping("/")
    public String home() {
        return helloService.sayHello();
    }
}

配置文件的使用

Spring Boot 配置文件包括 application.properties 和 application.yml，可以用于存储配置信息。例如，数据库连接配置、端口号、日志级别等。

以下是一个 application.properties 示例：

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

以下是一个 application.yml 示例：

server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
    driverClassName: com.mysql.cj.jdbc.Driver

自动配置原理

Spring Boot 的自动配置基于约定优于配置的原则，通过 @EnableAutoConfiguration 注解来启用自动配置。Spring Boot 会根据类路径中的资源自动配置适当的Spring Bean。

例如，当Spring Boot检测到 spring-boot-starter-web 依赖时，它会自动配置 DispatcherServlet、RequestMappingHandlerMapping、RequestMappingHandlerAdapter、ExceptionHandler、ErrorPageRegistrar 和 ContentNegotiationManager 等Bean。

Spring Boot RESTful服务开发

Spring Boot 使得开发RESTful API变得简单。以下将介绍如何创建RESTful API，并介绍Spring MVC框架的基础知识。

创建RESTful API

创建RESTful API通常涉及定义控制器、服务和资源表示。以下是一个完整的REST API示例：

定义控制器：
- 使用 @RestController 注解标记控制器。
- 使用 @GetMapping 和 @PostMapping 注解标记处理请求的方法。
定义服务：
- 使用 @Service 注解标记服务类。
- 创建业务逻辑和数据操作方法。
定义资源表示：
- 使用Java对象表示资源，通常定义为POJO（Plain Old Java Object）。

以下是一个简单的REST API示例：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

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

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

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

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        return userService.updateUser(id, user);
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
    }
}

package com.example.demo;

import org.springframework.stereotype.Service;

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

@Service
public class UserService {

    private List<User> users = new ArrayList<>();
    private Long nextId = 1L;

    public UserService() {
        users.add(new User(nextId++, "John Doe", "john.doe@example.com"));
        users.add(new User(nextId++, "Jane Doe", "jane.doe@example.com"));
    }

    public List<User> getAllUsers() {
        return users;
    }

    public Optional<User> getUserById(Long id) {
        return users.stream().filter(user -> user.getId().equals(id)).findAny();
    }

    public User createUser(User user) {
        user.setId(nextId++);
        users.add(user);
        return user;
    }

    public User updateUser(Long id, User user) {
        User updatedUser = users.stream()
                .filter(u -> u.getId().equals(id))
                .peek(u -> u.setName(user.getName()))
                .peek(u -> u.setEmail(user.getEmail()))
                .findFirst()
                .orElse(null);
        return updatedUser;
    }

    public void deleteUser(Long id) {
        users.removeIf(user -> user.getId().equals(id));
    }
}

package com.example.demo;

public class User {
    private Long id;
    private String name;
    private String email;

    public User() {}

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

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

使用Spring MVC框架

Spring MVC 是Spring框架中的一个模块，用于构建Web应用程序。它提供了一种基于组件的开发模式，并且与Spring Boot无缝集成。

Spring MVC的核心组件包括：

DispatcherServlet：作为控制器和视图之间的中心枢纽，处理HTTP请求和响应。
HandlerMapping：负责根据URL将请求映射到控制器。
HandlerAdapter：负责根据控制器的实现来处理请求。
ViewResolver：负责将视图解析为具体的视图实现，例如JSP或Thymeleaf。

在Spring Boot中，通常不直接使用这些组件，而是通过注解来定义控制器和处理请求的方法。

数据绑定与验证

Spring MVC 提供了数据绑定功能，可以将HTTP请求参数自动绑定到控制器方法参数或模型对象。数据绑定可以与验证机制结合使用，确保数据的有效性。

以下是一个数据绑定和验证的示例：

package com.example.demo;

import org.springframework.web.bind.annotation.*;

@RestController
public class UserController {

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

    private void validateUser(User user) {
        if (user.getName() == null || user.getName().isEmpty()) {
            throw new IllegalArgumentException("Name cannot be empty");
        }
        if (user.getEmail() == null || !user.getEmail().matches("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")) {
            throw new IllegalArgumentException("Invalid email address");
        }
    }
}

数据访问与整合框架

在Spring Boot中，可以使用多种数据访问框架，包括JPA、MyBatis等。本节将介绍如何使用这些框架进行数据库连接和操作。

数据库连接与操作

在Spring Boot中，数据库连接和操作通常通过配置 application.properties 来实现。以下是一个简单的MySQL数据库连接配置示例：

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

Spring Data JPA简介

Spring Data JPA 是Spring Data的一部分，用于简化JPA（Java Persistence API）的使用。它提供了通用的数据库操作接口，并允许通过简单的配置进行操作。

以下是一个简单的Spring Data JPA示例：

添加依赖：

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

创建实体类：

package com.example.demo;

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;

   // Getter and Setter methods
}

创建Repository接口：

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

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

使用Repository接口：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
public class UserController {

   @Autowired
   private UserRepository userRepository;

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

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

集成MyBatis

MyBatis 是一个持久层框架，与Spring Boot集成可以简化数据库操作。以下是一个简单的MyBatis集成示例：

添加依赖：

<dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>2.1.4</version>
</dependency>

创建Mapper接口：

package com.example.demo;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {
   @Select("SELECT * FROM user WHERE id = #{id}")
   User getUserById(Long id);
}

创建Mapper XML配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.UserMapper">
   <select id="getUserById" resultType="com.example.demo.User">
       SELECT * FROM user WHERE id = #{id}
   </select>
</mapper>

创建Service类：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

   @Autowired
   private UserMapper userMapper;

   public User getUserById(Long id) {
       return userMapper.getUserById(id);
   }
}

使用Service类：

package com.example.demo;

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

@RestController
public class UserController {

   @Autowired
   private UserService userService;

   @GetMapping("/users/{id}")
   public User getUserById(@PathVariable Long id) {
       return userService.getUserById(id);
   }
}

日志与异常处理

Spring Boot 提供了多种日志框架的支持，包括Logback、Log4j等。同时，Spring Boot也提供了强大的异常处理机制，使得开发人员可以更方便地处理应用程序中的异常。

使用Spring Boot的日志框架

Spring Boot 默认使用Logback作为日志框架。可以通过配置 application.properties 或 application.yml 文件来调整日志级别和格式。

以下是一个简单的日志配置示例：

logging.level.root=INFO
logging.file=/var/log/myapp.log
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n

异常处理机制

Spring Boot 提供了多种机制来处理应用程序中的异常，包括全局异常处理器、@ControllerAdvice 和 @ExceptionHandler 注解。

以下是一个简单的全局异常处理器示例：

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception ex) {
        return new ResponseEntity<>("Error: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

实战案例：创建简单的异常处理器

以下是一个更复杂的异常处理器示例，用于处理特定类型的异常：

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class CustomExceptionHandler {

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<String> handleIllegalArgumentException(IllegalArgumentException ex) {
        return new ResponseEntity<>("Invalid input: " + ex.getMessage(), HttpStatus.BAD_REQUEST);
    }

    @ExceptionHandler(DataNotFoundException.class)
    public ResponseEntity<String> handleDataNotFoundException(DataNotFoundException ex) {
        return new ResponseEntity<>("Data not found: " + ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}

总结

通过本教程，你已经学习了如何使用Spring Boot创建和运行一个简单的应用程序，并了解了如何使用Spring Boot的注解、配置文件、RESTful API开发、数据访问框架、日志和异常处理等特性。希望这些内容能够帮助你快速上手Spring Boot开发。