Springboot资料：入门与初级使用教程

本文提供了Spring Boot的详细介绍，包括其优势、环境搭建和基本应用开发。文章还涵盖了Spring Boot的核心概念、常用功能以及项目实战和部署方法。通过本文，读者可以快速掌握Spring Boot的基本使用方法并应用于实际开发中。

什么是Spring Boot

Spring Boot 是由Pivotal团队提供的一个基于Spring平台的快速开发框架。它通过自动配置功能简化了应用开发、依赖管理和部署流程，使得开发者可以更加专注于业务逻辑的实现，而不是框架的配置。Spring Boot的核心目标是简化Spring应用的开发和部署，使得开发者可以快速构建独立运行的、生产级别的应用。

Spring Boot的优势

1. 自动配置：Spring Boot通过约定大于配置的思想自动配置应用程序，减少配置文件的编写工作。
2. 独立运行：可以方便地将Spring Boot应用打包为独立的war或jar包，其中包含了运行应用所需的所有依赖库。
3. 无依赖配置：引入了Spring Boot Starter的概念，通过一个starter就可以引入所有需要的依赖，极大简化了依赖管理。
4. 无需XML配置：几乎所有的配置都可以通过注解或属性配置来完成，不需要编写大量的XML配置文件。
5. 内嵌Web服务器：Spring Boot支持内嵌的Web服务器，如Tomcat、Jetty或Undertow，可以不借助外部容器直接运行应用。

Spring Boot的环境搭建

1. 安装Java环境：确保已经安装了Java开发工具包（JDK），建议使用JDK 8或更高版本。
2. 安装Maven或Gradle：Spring Boot支持使用Maven或Gradle构建项目。
3. 安装IDE：推荐使用IntelliJ IDEA或Eclipse，它们都提供了Spring Boot的相关插件支持。
4. 安装STS（Spring Tool Suite）：STS是一个专门为Spring开发者设计的IDE，提供了许多便利的功能，如快速创建Spring Boot项目、自动配置等。

使用Spring Initializr创建项目

Spring Initializr是一个在线的项目生成器，可以通过指定项目的一些基本信息来生成Spring Boot项目。以下是具体步骤：

1. 访问Spring Initializr官网：https://start.spring.io/
2. 选择项目的基本信息，如语言（Java）、版本（Java 11）、项目类型（Maven项目）、依赖（Spring Web、Spring Data JPA等）、依赖管理（Spring Boot版本）。
3. 点击“生成项目”按钮，下载生成的项目压缩包。
4. 解压下载的压缩包，并导入到IDE中，如IntelliJ IDEA或Eclipse。

<!-- 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.3.1.RELEASE</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>
        </build>
</project>

添加依赖

示例中，使用了Spring Boot Starter Web依赖，这是一个包含所有必要的依赖的Spring Web应用的starter。它包括Spring Web MVC和一个Tomcat内嵌服务器，使得应用可以直接运行。

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

编写第一个控制器

创建一个简单的Spring Boot控制器来响应HTTP请求。在这个例子中，创建一个名为HelloController的类，使用@RestController注解来标识这个类是一个控制器，并使用@RequestMapping注解指定URL路径。

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

在src/main/java/com/example/demo/HelloController.java中编写控制器代码。运行应用后，可以访问http://localhost:8080/hello来查看结果。

自动配置

Spring Boot通过自动配置机制来简化配置工作。自动配置的主要目的是根据类路径中的jar包和一些默认设置来自动配置应用。例如，如果spring-boot-starter-web在项目的依赖中，那么Spring Boot会默认配置一个Tomcat服务器，并且会自动配置Spring MVC。

Starter依赖

Starter依赖是Spring Boot的核心概念之一，它是一个包含许多依赖的特殊依赖，这样可以简化开发人员的工作，避免手动添加大量的依赖。例如，spring-boot-starter-web包含了构建Web应用所需的所有依赖。

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

Actuator监控

Spring Boot Actuator提供了许多生产中需要的特性，如健康检查、审计、信息端点等。可以通过注册一些额外的依赖来启用这些特性，如spring-boot-starter-actuator。

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

启用后，可以访问http://localhost:8080/actuator来查看应用的各种信息端点。

配置文件详解

Spring Boot使用application.properties或application.yml作为配置文件。这些文件可以位于src/main/resources目录下。默认情况下，Spring Boot会自动读取这些配置文件，并根据其中的配置来启动应用。配置文件可以包含各种配置属性，如数据库连接、服务器端口等。

# application.properties
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

数据库集成

Spring Boot支持多种数据库，包括MySQL、PostgreSQL、SQLite等。要集成数据库，可以通过添加相应的starter依赖，并配置数据库的连接信息。

示例代码中，整合MySQL数据库。

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

在配置文件中指定数据库连接信息。

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=secret
spring.jpa.hibernate.ddl-auto=update

以下是一个简单的数据库操作示例，创建一个用户表，并插入数据：

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.annotation.Resource;

@SpringBootApplication
public class DatabaseIntegrationExample implements CommandLineRunner {

    @Resource
    private JdbcTemplate jdbcTemplate;

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

    @Override
    public void run(String... args) throws Exception {
        jdbcTemplate.execute("CREATE TABLE users (id INT, name VARCHAR(255))");
        jdbcTemplate.execute("INSERT INTO users (id, name) VALUES (1, 'John Doe')");
        jdbcTemplate.execute("INSERT INTO users (id, name) VALUES (2, 'Jane Doe')");
    }
}

日志管理

Spring Boot集成了常见的日志框架，如Logback、Log4j等。默认情况下，使用Logback作为日志框架。可以通过logging.level属性来设置不同包的日志级别。

# application.properties
logging.level.root=INFO
logging.level.com.example=DEBUG

构建RESTful API

构建RESTful API通常需要定义一些资源和操作这些资源的HTTP方法。例如，可以创建一个UserController来处理用户相关的操作。

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

import java.util.HashMap;
import java.util.Map;

@RestController
public class UserController {
    private Map<Integer, User> users = new HashMap<>();

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

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

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable int id, @RequestBody User updatedUser) {
        users.put(id, updatedUser);
        return updatedUser;
    }

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

文件上传与下载

可以使用Spring Boot的CommonsMultipartResolver来处理文件上传和下载。

import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

@RestController
public class FileController {
    private static final Path rootLocation = Paths.get("upload-dir");

    @PostMapping("/upload")
    public String handleFileUpload(@RequestParam("file") MultipartFile file) {
        try {
            Files.copy(file.getInputStream(), rootLocation.resolve(file.getOriginalFilename()));
            return "You successfully uploaded " + file.getOriginalFilename() + "!";
        } catch (IOException e) {
            e.printStackTrace();
            return "FAIL!";
        }
    }

    @GetMapping("/files/{filename:.+}")
    public ResponseEntity<Resource> serveFile(@PathVariable String filename) {
        Path file = rootLocation.resolve(filename);
        Resource resource = new UrlResource(file.toUri());
        HttpHeaders headers = new HttpHeaders();
        headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
        headers.add("Pragma", "no-cache");
        headers.add("Expires", "0");
        headers.add("Content-Type", Files.probeContentType(file));
        return ResponseEntity.ok().headers(headers).body(resource);
    }
}

异常处理

在Spring Boot中，可以通过创建一个全局异常处理器来集中处理应用中的各种异常。

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

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    @ResponseBody
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public String handleResourceNotFoundException(ResourceNotFoundException ex) {
        return ex.getMessage();
    }

    @ExceptionHandler(Exception.class)
    @ResponseBody
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public String handleGeneralException(Exception ex) {
        return "Internal server error";
    }
}

文件上传与下载资源类定义

import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.stereotype.Service;
import org.springframework.util.FileSystemUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

@Service
public class FileStorageService {

    public static final String UPLOAD_DIR = "upload-dir";

    public void init() {
        FileSystemUtils.deleteRecursively(Paths.get(UPLOAD_DIR).toFile());
        Files.createDirectory(Paths.get(UPLOAD_DIR));
    }

    public void storeFile(MultipartFile file) {
        try (InputStream inputStream = file.getInputStream()) {
            Files.copy(inputStream, Paths.get(UPLOAD_DIR, file.getOriginalFilename()), StandardCopyOption.REPLACE_EXISTING);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Resource loadFileAsResource(String filename) throws MalformedURLException {
        Path fileStorageLocation = Paths.get(UPLOAD_DIR).toAbsolutePath().normalize();
        Path filePath = fileStorageLocation.resolve(filename).normalize();
        Resource resource = new UrlResource(filePath.toUri());
        if (resource.exists()) {
            return resource;
        } else {
            throw new RuntimeException("File not found " + filename);
        }
    }
}

打包与发布

使用Maven或Gradle可以将项目打包为jar或war包。例如，使用Maven打包项目：

mvn clean package

生成的jar或war包位于target目录下。

部署到Tomcat

可以将生成的war包直接部署到Tomcat服务器。将war包复制到Tomcat的webapps目录下，然后启动Tomcat服务器即可。

部署到Docker

可以使用Docker来部署Spring Boot应用。首先构建一个包含应用的Docker镜像，然后使用该镜像来启动容器。

# Dockerfile
FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD target/*.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

构建并运行Docker镜像：

docker build -t my-spring-boot-app .
docker run -p 8080:8080 my-spring-boot-app

以上是Spring Boot入门与初级使用教程的全部内容，希望能够帮助读者快速掌握Spring Boot的基本使用方法和一些高级特性。