Springboot项目开发实战：新手入门与初级教程-原创手记-慕课网

概述

本文详细介绍了Spring Boot项目开发的全过程，包括环境搭建、基本功能开发、静态资源管理、用户认证与授权、文件上传与下载，以及异常处理和日志记录等内容。通过本文，读者能够快速掌握Spring Boot的核心技术和开发技巧。

Spring Boot 项目开发实战：新手入门与初级教程

1. Spring Boot 简介

1.1 什么是 Spring Boot

Spring Boot 是由 Pivotal 团队提供的基于 Spring 平台的框架，用于构建独立的、生产级别的应用。Spring Boot 的目标是简化开发流程，提高开发效率，使得开发者能够快速搭建一个独立运行的 Spring 应用程序。

1.2 Spring Boot 的优势

快速启动：提供了一个快速的启动机制，使得开发者能够快速创建和运行 Spring 应用程序。
自动配置：Spring Boot 通过约定优于配置的原则，自动配置了许多常用的配置项，使得开发者不必手动配置大量的 XML 文件。
嵌入式服务器：Spring Boot 支持将应用打包为可执行的 jar 或 war 文件，并自带嵌入式 Tomcat、Jetty 或者 Undertow 服务器，简化了部署过程。
依赖管理：Spring Boot 提供了一站式的依赖管理，能够自动处理依赖关系，简化了版本管理的复杂性。
开发性：Spring Boot 提供了许多开发工具，如 Spring CLI 和 Spring Boot DevTools，提高了开发效率和调试体验。

1.3 Spring Boot 的核心概念

Spring Boot Starter：一组可重用的依赖管理模块，大大简化了构建过程。例如，spring-boot-starter-web 用于创建 Web 应用程序，spring-boot-starter-data-jpa 用于集成 Spring Data JPA。
自动配置：Spring Boot 使用配置类（如 @Configuration 注解）和配置属性（如 application.properties 或 application.yml）自动配置应用。
命令行界面 (CLI)：Spring Boot 提供了 Spring CLI 工具，允许通过命令行快速创建和运行 Spring Boot 应用程序。
Actuator：Spring Boot Actuator 提供了一系列的生产环境监控端点，帮助开发者监控应用运行情况。
DevTools：Spring Boot DevTools 提供了快速的开发体验，如自动重启、静态资源缓存等。

2. 环境搭建与配置

2.1 安装 Java 开发环境

Spring Boot 应用开发需要一个完整的 Java 开发环境。以下步骤将帮助你在本地安装和配置 Java 开发环境：

下载 Java JDK：访问 Oracle 官网下载 Java JDK，建议下载最新版本。下载地址为：https://www.oracle.com/java/technologies/javase-downloads.html。
安装 JDK：按照下载页面的说明进行安装。安装完成后，设置 Java 环境变量：
- 设置 JAVA_HOME 环境变量为 JDK 安装路径。
- 设置 PATH 环境变量，增加 %JAVA_HOME%\bin（Windows 系统）或 $JAVA_HOME/bin（Linux 和 macOS 系统）。
验证 Java 安装：打开命令行工具，输入 java -version 检查是否安装成功。

java -version

如果安装成功，将显示 Java 版本信息。

2.2 下载并配置 Spring Boot

下载 Spring Boot：访问 Spring Boot 官网下载最新版的 Spring Boot：https://spring.io/projects/spring-boot。
创建项目：Spring Boot 提供了一个在线的项目初始化器，可以通过网站 https://start.spring.io/ 创建一个新项目。按照界面提示选择项目名称、语言、版本等信息。
导入 Spring Boot 模板：项目创建完成后，可以下载压缩包并解压，或直接导入到 IDE（如 IntelliJ IDEA 或 Eclipse）中进行开发。

2.3 创建第一个 Spring Boot 项目

使用 Spring Boot CLI 工具创建一个简单的 Hello World 应用：

安装 Spring Boot CLI：通过 Maven 下载 Spring Boot CLI 工具：

mvn install -DskipTests=true org.springframework.boot:spring-boot-cli:2.7.3

安装的是 Spring Boot CLI 版本 2.7.3

创建 Spring Boot 应用：在命令行工具中，执行以下命令创建一个名为 hello 的 Spring Boot 应用：

spring init hello

运行应用：在项目目录下，执行以下命令启动应用：

mvn spring-boot:run

查看应用：打开浏览器，访问 http://localhost:8080/，将看到应用输出的 "Hello World!" 文本。

3. 基本功能开发

3.1 控制器与路由设置

3.1.1 创建控制器

在 Spring Boot 中，控制器负责处理 HTTP 请求，返回 HTTP 响应。以下示例展示了如何创建一个简单的控制器来处理 GET 请求。

创建控制器类：在 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 sayHello() {
        return "Hello World!";
    }
}

启动应用：运行 Spring Boot 应用，访问 http://localhost:8080/hello，将看到输出的 "Hello World!"。

3.1.2 路由设置

路由设置是指如何将 HTTP 请求映射到控制器的方法上。以上示例中，@GetMapping("/hello") 注解定义了一个 GET 请求的路由，当用户访问 /hello 路径时，将调用 sayHello 方法。

3.2 模板引擎的使用

3.2.1 引入模板引擎依赖

Spring Boot 可以与多种模板引擎集成，如 Thymeleaf、Freemarker 等。这里以 Thymeleaf 为例，介绍如何引入 Thymeleaf 模板引擎依赖。

添加依赖：在 pom.xml 文件中添加 Thymeleaf 依赖：

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

创建 HTML 模板：在 src/main/resources/templates 目录下创建一个名为 hello.html 的文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello Page</title>
</head>
<body>
    <h1 th:text="'Hello, ' + ${name} + '!'">Hello World!</h1>
</body>
</html>

修改控制器：更新控制器代码，返回 Thymeleaf 模板：

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("name", "World");
        return "hello";
    }
}

运行应用：启动应用并访问 http://localhost:8080/hello，将看到使用 Thymeleaf 渲染的 HTML 页面。

3.3 数据库的集成与操作

3.3.1 引入数据库依赖

Spring Boot 支持多种数据库，这里以 MySQL 为例，介绍如何引入 MySQL 数据库依赖。

添加依赖：在 pom.xml 文件中添加 MySQL 依赖：

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

配置数据库连接：在 application.properties 文件中配置数据库连接信息：

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.jpa.hibernate.ddl-auto=update

创建实体类：在 src/main/java/com/example/demo 目录下创建一个名为 User.java 的实体类：

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;

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

创建仓库接口：创建一个接口来操作数据库中的 User 实体：

package com.example.demo;

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

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

创建服务类：创建一个服务类来处理 User 实体的业务逻辑：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

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

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

创建控制器：更新控制器代码，调用服务类中的方法：

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

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

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

运行应用：启动应用并访问 http://localhost:8080/users，将看到返回的所有用户列表。

4. 静态资源与视图处理

4.1 静态资源文件的管理

Spring Boot 支持管理多种静态资源文件，如 CSS、JavaScript、图片等。静态资源文件默认位于 src/main/resources/static 目录下。

创建静态资源文件：在 src/main/resources/static 目录下创建一个简单的 CSS 文件 style.css：

body {
    background-color: lightblue;
}

引用静态资源文件：在 HTML 模板中引用静态资源文件：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello Page</title>
    <link rel="stylesheet" th:href="@{/css/style.css}" href="/css/style.css" />
</head>
<body>
    <h1 th:text="'Hello, ' + ${name} + '!'">Hello World!</h1>
</body>
</html>

4.2 视图解析与模板渲染

Spring Boot 使用 Thymeleaf 或其他模板引擎来渲染视图。视图解析器根据控制器返回的视图名，从模板文件中渲染 HTML 页面。

配置视图解析器：Spring Boot 默认配置了视图解析器，自动将控制器返回的视图名转换为实际的模板文件路径。
渲染视图：在控制器中返回视图名，由视图解析器负责渲染：

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("name", "World");
        return "hello";
    }
}

4.3 使用 Thymeleaf 或其他模板引擎

Spring Boot 支持多种模板引擎，如 Thymeleaf、Freemarker 等。本节以 Thymeleaf 为例进行说明。

引入依赖：确保在 pom.xml 文件中添加了 Thymeleaf 依赖。
创建模板文件：在 src/main/resources/templates 目录下创建 Thymeleaf 模板文件，如 hello.html。
渲染模板：控制器返回模板名，视图解析器将调用模板引擎进行渲染。

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello Page</title>
</head>
<body>
    <h1 th:text="'Hello, ' + ${name} + '!'">Hello World!</h1>
</body>
</html>

5. 深入实践案例

5.1 用户认证与授权

Spring Boot 提供了 Spring Security 模块，用于处理用户认证与授权。以下示例介绍如何使用 Spring Security 实现基本的用户认证与授权。

引入 Spring Security 依赖：在 pom.xml 文件中添加 Spring Security 依赖：

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

配置 Spring Security：创建一个配置类来配置 Spring Security：

package com.example.demo;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
            .and()
            .logout()
                .permitAll();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

创建登录页面：在 src/main/resources/templates 目录下创建一个登录页面 login.html：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login Page</title>
</head>
<body>
    <form th:action="@{/login}" method="post">
        <label>Email:</label>
        <input type="text" name="username" />
        <label>Password:</label>
        <input type="password" name="password" />
        <input type="submit" value="Login" />
    </form>
</body>
</html>

创建控制器：创建一个控制器来处理登录请求：

package com.example.demo;

import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/public")
public class PublicController {

    @GetMapping("/login")
    public String login() {
        return "login";
    }

    @GetMapping("/home")
    public String home(Model model, @AuthenticationPrincipal UserDetails user) {
        model.addAttribute("username", user.getUsername());
        return "home";
    }
}

创建主页页面：在 src/main/resources/templates 目录下创建一个主页页面 home.html：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Home Page</title>
</head>
<body>
    <h1>Welcome, [[${username}]]!</h1>
</body>
</html>

运行应用：启动应用并访问 http://localhost:8080/public/home，将看到登录表单。输入正确的用户名和密码后，将重定向到主页页面。

5.2 文件上传与下载

Spring Boot 支持文件上传与下载功能，可以使用 Spring MVC 提供的 MultipartFile 类来处理文件上传。

5.2.1 文件上传

创建控制器：在控制器中处理文件上传请求：

package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

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

@Controller
public class FileUploadController {

    @PostMapping("/upload")
    public String handleFileUpload(@RequestParam("file") MultipartFile file) {
        if (!file.isEmpty()) {
            try {
                byte[] bytes = file.getBytes();
                Path path = Paths.get("uploads/" + file.getOriginalFilename());
                Files.write(path, bytes);
                return "file-uploaded";
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return "upload-failed";
    }
}

创建上传页面：在 src/main/resources/templates 目录下创建一个上传文件页面 upload.html：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>File Upload Page</title>
</head>
<body>
    <form th:action="@{/upload}" method="post" enctype="multipart/form-data">
        <input type="file" name="file" />
        <input type="submit" value="Upload" />
    </form>
</body>
</html>

5.2.2 文件下载

创建控制器：在控制器中处理文件下载请求：

package com.example.demo;

import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.net.MalformedURLException;

@RestController
@RequestMapping("/download")
public class FileDownloadController {

    @GetMapping("/{fileName}")
    public ResponseEntity<Resource> getFile(@PathVariable String fileName, HttpServletRequest request) throws IOException {
        Path path = Paths.get("uploads/" + fileName);
        UrlResource urlResource = new UrlResource(path.toUri());
        String contentType = request.getServletContext().getMimeType(path.toString());
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + urlResource.getFilename())
            .contentType(MediaType.parseMediaType(contentType))
            .body(urlResource);
    }
}

创建下载页面：在 src/main/resources/templates 目录下创建一个下载文件页面 download.html：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>File Download Page</title>
</head>
<body>
    <a th:href="@{/download/{fileName}(fileName='example.txt')}">Download Example.txt</a>
</body>
</html>

5.3 异常处理与日志记录

Spring Boot 提供了统一的异常处理机制和日志记录功能，帮助开发者更好地管理和调试应用。

5.3.1 异常处理

创建全局异常处理器：创建一个全局异常处理器来统一处理应用中的异常：

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;
import org.springframework.web.bind.annotation.ResponseBody;

@ControllerAdvice
public class GlobalExceptionHandler {

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

模拟异常：在控制器中模拟一个异常：

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ExceptionController {

    @GetMapping("/throw")
    public String throwException() {
        throw new RuntimeException("An unexpected error occurred");
    }
}

5.3.2 日志记录

配置 Logback：在 resources 目录下创建 logback-spring.xml 文件来配置日志：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

使用日志：在控制器中使用 @Log 注解注入日志对象，并进行日志记录：

package com.example.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LogController {

    private static final Logger logger = LoggerFactory.getLogger(LogController.class);

    @GetMapping("/log")
    public String logMessage() {
        logger.info("Info level log message");
        logger.error("Error level log message");
        return "Logging test";
    }
}

6. 项目部署与调试

6.1 打包与发布 Spring Boot 应用

Spring Boot 提供了打包功能，可以将应用打包为可执行的 jar 或 war 文件。

打包 jar 文件：使用 Maven 打包应用：

mvn clean package

运行打包后的 jar 文件：使用 Java 命令运行打包后的 jar 文件：

java -jar target/myapp.jar

6.2 应用的配置与环境切换

Spring Boot 支持多环境配置，可以通过 application-{profile}.properties 文件来切换不同环境的配置。

创建环境配置文件：在 resources 目录下创建不同环境的配置文件，如 application-dev.properties 和 application-prod.properties。
切换环境：启动应用时指定环境：

java -jar -Dspring.profiles.active=dev target/myapp.jar

6.3 常见问题及解决方案

找不到静态资源文件：确保静态资源文件路径正确且放置在 resources/static 目录下。
数据库连接失败：检查数据库连接信息是否正确，确保数据库服务已启动。
应用启动失败：查看应用日志，根据错误信息排查问题。

总结

本文详细介绍了 Spring Boot 的基本概念、环境搭建、基本功能开发、静态资源管理、深入实践案例以及项目部署与调试等内容。通过本文的学习，你将能够快速搭建和运行一个简单的 Spring Boot 应用，并掌握一些常见的开发技巧和最佳实践。希望这些内容能够帮助你在 Spring Boot 的开发之旅上更加顺利。