首页手记 SpringBoot学习：从入门到实践的简单教程

SpringBoot学习：从入门到实践的简单教程

标签：

SpringBoot

概述

SpringBoot学习包括环境搭建、核心概念、实战开发、常用功能扩展、项目部署及调试等多个方面，旨在帮助开发者快速掌握SpringBoot框架。文章详细介绍了SpringBoot的自动配置、依赖注入、Starter依赖以及配置文件的使用方法，同时提供了创建RESTful API和数据库操作的示例。此外，还涵盖了与Thymeleaf集成、邮件服务配置及Spring Security集成等内容，帮助开发者实现更复杂的功能。

SpringBoot简介与环境搭建

SpringBoot是什么

Spring Boot 是由Pivotal团队提供的框架，用于简化使用Spring进行开发的程序，特别是简化了配置过程。Spring Boot通过自动配置、自动装配等特性，使得开发者可以快速上手开发Web应用及企业应用。它也支持嵌入式服务，内置了Tomcat、Jetty和Undertow作为应用服务器，使得应用可以“一键”启动。对于大多数Spring开发者来说，Spring Boot大大减少了配置文件的编写量，使得应用的部署和维护变得更加简单。

Spring Boot的另一个重要特性是提供了大量的“Starters”依赖，允许开发者快速引入需要的功能模块。例如，通过引入spring-boot-starter-web，开发者可以轻松构建一个RESTful服务而不需要额外配置很多依赖。

开发环境搭建

系统要求与Java版本

开发Spring Boot应用首先需要满足以下条件：

Java 8或更高版本
Maven或Gradle构建工具
IDE（如IntelliJ IDEA或Eclipse）

创建Spring Boot项目

创建一个Spring Boot项目有多种方法，这里使用IntelliJ IDEA进行演示。

打开IntelliJ IDEA，选择“File” -> “New” -> “Project”。
在弹出的窗口中选择“Spring Initializr”，然后选择一个合适的Java版本。
输入Group ID和Artifact ID，Group ID通常是域名的反写形式，Artifact ID是项目名称。
在“Dependencies”列表中选择需要的功能模块，如Web、JPA、Thymeleaf等。
选择要创建的项目位置，点击“Finish”按钮。

如此一来，一个Spring Boot项目就已经创建完成，IDEA会自动添加需要的依赖到pom.xml文件中。

使用IDEA创建SpringBoot项目

使用Spring Initializr生成项目

在IDEA中，打开“File”菜单，选择“New” -> “Project”，然后选择“Spring Initializr”，点击“Next”。在接下来的窗口中，选择“Spring Web”依赖，以及Java 8版本，点击“Next”，输入Group ID和Artifact ID，例如：

<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>demo</name>
<description>Example Spring Boot project</description>
<properties>
    <java.version>1.8</java.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

选择项目位置，点击“Finish”，项目就会被创建出来了。此时IDEA会自动下载项目依赖，等待下载完成即可。

运行SpringBoot应用

在IDEA中打开Application类，通常在项目根目录创建的DemoApplication.java文件，该文件中会有一个main方法。双击main方法旁边的绿色箭头，或者按Shift + F10快捷键运行项目。应用成功启动后，可以在控制台看到类似以下输出：

Tomcat started on port(s): 8080 (http) with context path ''

这表示Spring Boot应用已经成功运行在8080端口上，可以通过浏览器访问http://localhost:8080来查看应用是否启动成功。

SpringBoot核心概念

自动配置

Spring Boot通过@EnableAutoConfiguration注解来实现自动配置。当Spring Boot发现@SpringBootApplication注解时，它会根据类路径中的依赖来自动配置应用程序。例如，当Spring Boot发现spring-boot-starter-web依赖时，它会自动配置一个Tomcat服务器和Spring MVC框架。自动配置是Spring Boot的核心特性之一，它使得开发者不需要手动配置大量的XML文件，极大地简化了开发过程。

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

上述代码展示了@SpringBootApplication注解，该注解包含了@Configuration、@EnableAutoConfiguration和@ComponentScan。这使得Spring Boot能够自动扫描并配置应用程序。

自定义自动配置类示例

为了展示如何创建自定义的自动配置类，以下是一个简单的示例：

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass(List.class)
public class CustomAutoConfiguration {

    @Bean
    public CustomService customService() {
        return new CustomService();
    }
}

自定义服务类

public class CustomService {
    public String customMessage() {
        return "Custom service message";
    }
}

上述代码展示了如何定义一个自定义的自动配置类，该类会在满足特定条件时自动配置一个CustomService。

依赖注入

Spring Boot继承了Spring框架的依赖注入特性，它允许开发者将对象的创建和装配交给框架，从而实现松耦合。通过使用@Component、@Service、@Repository和@Controller注解来标记类，Spring Boot能够自动发现这些组件并通过@Autowired注解来注入依赖。

例如，定义一个名为MessageService的类：

import org.springframework.stereotype.Service;

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

在其他类中，可以通过@Autowired注解注入MessageService：

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

@Component
public class MessageHandler {
    private final MessageService messageService;

    @Autowired
    public MessageHandler(MessageService messageService) {
        this.messageService = messageService;
    }

    public String displayMessage() {
        return messageService.getMessage();
    }
}

这样，MessageHandler类就可以通过MessageService对象来获取消息了。

配置类与依赖注入结合使用

为了展示如何结合配置类与依赖注入，以下是一个简单的配置类示例：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public CustomService customService() {
        return new CustomService();
    }
}

配置类中的@Bean注解用于定义一个Bean，该Bean可以在其他组件中通过依赖注入使用。

Starter依赖

Spring Boot Starter是一个依赖管理的容器，可帮助在项目中快速引入和配置一组常用的库。通常，Spring Boot Starter会包括一组依赖，这些依赖通常是Spring Boot所必需的，例如spring-boot-starter-web包含了Spring MVC的依赖。

在pom.xml中，可以通过引入starter依赖来快速添加功能：

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

上述代码展示了引入spring-boot-starter-web依赖。这会自动引入Spring MVC、Tomcat服务器等依赖，使得开发Web应用变得非常简单。

使用`spring-boot-starter-data-jpa`进行数据库操作

例如，使用spring-boot-starter-data-jpa进行数据库操作：

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

import java.util.List;

@Service
public class UserService {
    private final UserRepository userRepository;

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

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

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

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

上述代码展示了如何定义一个简单的UserService服务和一个继承自JpaRepository的UserRepository接口，并且通过@Autowired注解注入UserRepository来操作数据。

配置文件

Spring Boot使用application.properties或application.yml作为默认的配置文件。这些配置文件位于资源目录下（src/main/resources），可以用来配置应用的各种属性，例如端口、数据库连接信息、日志级别等。

例如，配置一个端口号：

server.port=8080

配置数据库连接信息，通常在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 Boot自动配置数据源。

完整配置文件示例

以下是一个完整的application.properties文件示例：

# Spring Boot server configuration
server.port=8080
spring.application.name=MySpringBootApplication

# Database configuration
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 logging configuration
logging.level.root=INFO
logging.level.org.springframework.web=DEBUG

SpringBoot实战：基本项目开发

创建基本的RESTful API

Spring Boot通过@RestController注解可以非常简单地创建RESTful服务。下面是一个简单的例子，创建一个RESTful API来获取用户信息：

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

@RestController
public class UserController {
    @GetMapping("/users")
    public List<User> getUsers() {
        // 这里获取用户列表
        List<User> users = new ArrayList<>();
        users.add(new User("John", 25));
        users.add(new User("Jane", 28));
        return users;
    }
}

上述代码展示了如何创建一个简单的RESTful API，该API提供了一个获取用户列表的端点/users。

处理POST请求和文件上传示例

以下代码展示了如何处理POST请求和文件上传：

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

@RestController
public class FileUploadController {
    @PostMapping("/upload")
    public String handleFileUpload(@RequestParam("file") MultipartFile file) {
        // 处理文件上传逻辑
        return "File uploaded successfully";
    }
}

使用JPA进行数据库操作

Spring Boot与JPA结合可以简化数据库操作。首先，在pom.xml中添加相关依赖：

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

这样配置后，就可以使用JPA来操作数据库了。下面是一个简单的示例，创建一个UserRepository接口和一个UserService服务来操作用户数据。

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

import java.util.List;

@Service
public class UserService {
    private final UserRepository userRepository;

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

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

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

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

上述代码展示了如何定义一个简单的UserService服务和一个继承自JpaRepository的UserRepository接口，并且通过@Autowired注解注入UserRepository来操作数据。

配置日志与监控

Spring Boot内置了强大的日志和监控功能。可以通过修改application.properties文件来配置日志级别，例如设置为DEBUG：

logging.level.root=DEBUG

此外，Spring Boot还提供了Actuator模块来提供应用运行时的监控信息。首先，在pom.xml中添加依赖：

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

然后在application.properties中启用端点：

management.endpoints.web.exposure.include=*

这样，访问http://localhost:8080/actuator即可查看应用的运行时信息。

SpringBoot常用功能扩展

使用Thymeleaf进行视图渲染

Thymeleaf是一个用于Web与独立环境的现代模板引擎，其语法简单易学，支持多种应用场景。要使用Thymeleaf，首先在pom.xml中添加依赖：

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

下面演示如何使用Thymeleaf渲染一个简单的HTML页面，包括条件判断和循环：

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

@Controller
public class HomeController {
    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "Hello, Thymeleaf!");
        model.addAttribute("users", List.of(
                new User("John", 25),
                new User("Jane", 28)
        ));
        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 th:text="${message}"></h1>
    <ul>
        <li th:each="user : ${users}">
            <span th:text="${user.name}"></span>
            <span th:text="${user.age}"></span>
        </li>
    </ul>
</body>
</html>

上述代码展示了如何在控制器中传递变量给Thymeleaf模板，并在模板中使用Thymeleaf的语法来渲染页面，包括条件判断和循环。

配置邮件服务

Spring Boot与Spring Email集成了发送邮件的功能。首先，需要在pom.xml中添加相关依赖：

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

然后在application.properties中配置邮件服务器信息：

spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.username=yourmail@gmail.com
spring.mail.password=yourpassword
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

下面是一个简单的邮件发送示例，包括发送成功和失败的处理：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

@Service
public class EmailService {
    private final JavaMailSender mailSender;

    @Autowired
    public EmailService(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    public void sendEmail(String to, String subject, String body) {
        try {
            SimpleMailMessage message = new SimpleMailMessage();
            message.setTo(to);
            message.setSubject(subject);
            message.setText(body);

            mailSender.send(message);
            System.out.println("Email sent successfully to " + to);
        } catch (Exception e) {
            System.out.println("Failed to send email: " + e.getMessage());
        }
    }
}

上述代码展示了如何定义一个简单的EmailService服务来发送邮件，并处理发送成功和失败的情况。

与Spring Security集成实现安全保护

Spring Boot与Spring Security集成可以实现用户认证与授权。首先，需要在pom.xml中添加依赖：

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

然后在控制器中添加安全注解，例如：

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SecureController {
    @GetMapping("/secure")
    @PreAuthorize("hasRole('ADMIN')")
    public String secureEndpoint() {
        return "This is a secure endpoint.";
    }
}

上述代码展示了如何使用@PreAuthorize注解限制访问一个控制器端点，确保只有具备特定角色的用户才能访问该端点。

完整的Spring Security配置示例

以下是一个完整的Spring Security配置示例，展示了如何定义安全端点和用户角色：

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.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

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

    @Override
    @Bean
    public UserDetailsService userDetailsService() {
        InMemoryUserDetailsManager manager = new InMemoryUserDetailsManager();
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build());
        manager.createUser(User.withDefaultPasswordEncoder()
            .username("admin")
            .password("password")
            .roles("ADMIN")
            .build());
        return manager;
    }
}

上述代码展示了如何定义用户角色和安全端点，并使用内存中的用户详情管理器来存储用户信息。

SpringBoot项目部署

打包与发布

Spring Boot提供了打包成独立的JAR或WAR文件的功能，可以通过mvn package命令生成一个可独立运行的JAR文件。Spring Boot的SpringBootServletInitializer类使得应用可以被部署到传统的Java EE应用服务器中，例如Tomcat。

打包成JAR

在IDEA中，打开Terminal窗口，执行mvn package命令：

mvn package

这将生成一个target目录下的demo-0.0.1-SNAPSHOT.jar文件，可以通过java -jar命令来运行该JAR文件。

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

打包成WAR

如果希望部署到传统应用服务器，可以修改pom.xml，将打包类型改为war，并添加spring-boot-starter-tomcat依赖：

<packaging>war</packaging>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

然后，执行mvn package命令，生成的文件将是一个WAR文件，可以部署到Tomcat服务器。

使用Docker容器化部署

创建Dockerfile

在项目根目录下创建一个Dockerfile，内容如下：

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ADD target/demo-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

构建和运行Docker镜像

在项目根目录下执行以下命令来构建和运行Docker镜像：

docker build -t demo .
docker run -p 8080:8080 demo

上述命令将构建并运行一个名为demo的Docker镜像，并将容器的8080端口映射到主机的8080端口。

使用docker-compose进行多容器部署

以下是一个使用docker-compose进行多容器部署的示例：

version: '3'
services:
  app:
    image: demo
    ports:
      - "8080:8080"
  database:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: mydb

使用docker-compose命令构建并启动应用：

docker-compose up

上述命令将构建并启动一个包含应用和数据库服务的多容器环境。

SpringBoot调试与常见问题解决

调试技巧

Spring Boot应用可以通过断点调试、日志等方式进行调试。在IDEA中，可以在代码中设置断点并启动应用进行调试。此外，Spring Boot还内置了Spring Boot DevTools，可以在开发过程中提供热部署，无需重新启动服务器。

使用DevTools

在pom.xml中添加spring-boot-devtools依赖：

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

启用DevTools后，每当应用程序资源发生变化时，Spring Boot应用将自动重新启动。

使用日志

Spring Boot支持多种日志框架，默认使用Logback，可以通过application.properties进行配置。

常见错误及解决方案

404错误

如果访问的URL没有响应，检查控制器映射的端点是否正确配置：

@GetMapping("/users")
public List<User> getUsers() {
    // 返回用户列表
}

自动配置冲突

如果自动配置导致冲突，可以通过@SpringBootApplication(exclude = {指定的类.class})排除特定的自动配置类。

性能优化与调优

配置文件中的优化

可以在application.properties中配置各种优化选项，例如：

spring.mvc.async.request-timeout=10000
spring.mvc.async.timeout=30000

使用Profiler

Spring Boot Actuator提供了/actuator/prometheus和/actuator/metrics端点来获取应用的性能指标。可以通过Prometheus等工具进行监控和分析。

代码层面的优化

减少不必要的依赖：只引入需要的依赖。
使用缓存：例如在控制器中使用@Cacheable注解。
使用异步处理：例如@Async注解。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

SMILET

手记
篇

粉丝

80

获赞与收藏

441

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30787 345

网络编程入门教程

20个小节 12720 239

Pandas 入门教程

25个小节 18599 341

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空