SpringBoot项目实战：从入门到初级应用教程

概述

本文详细介绍了SpringBoot项目实战，包括环境搭建、核心概念与配置、常用功能实现以及实战案例。通过讲解RESTful API开发、数据库集成、安全认证和监控等功能，帮助开发者快速掌握SpringBoot项目的开发流程。此外，还提供了一个简单的博客系统搭建实例，展示了前后端分离开发的优势。

SpringBoot简介与环境搭建

SpringBoot是什么？

Spring Boot 是由 Spring 团队开发的一个开源框架，它简化了传统的 Spring 应用程序开发流程，使得开发者能够快速搭建独立运行的应用程序。开发人员可以无需过多关注配置文件，只需专注于业务逻辑的实现。Spring Boot 也支持嵌入式运行，比如使用 Tomcat、Jetty 或者 Undertow 作为应用服务器。

开发环境准备

开发工具

为了开发 Spring Boot 应用，首先需要安装以下工具：

• Java 开发工具包 (JDK)
• 操作系统兼容的 IDE，如 IntelliJ IDEA 或 Eclipse
• Maven 或 Gradle 构建工具

安装Java开发工具包 (JDK)

1. 访问 Oracle 官网或 OpenJDK 网站下载最新版本的 JDK。
2. 根据下载的安装文件，按照提示进行安装。
3. 配置环境变量（在 Windows 系统中，将 JDK 的 bin 目录添加到 PATH 环境变量；在 Linux 或 macOS 系统中，编辑 ~/.bashrc 文件，添加 export JAVA_HOME=/path/to/java 和 export PATH=$JAVA_HOME/bin:$PATH）。

安装IDE

以 IntelliJ IDEA 为例：

1. 访问 IntelliJ IDEA 的官网下载页面，选择适合的操作系统版本。
2. 按照安装向导完成安装。
3. 打开 IntelliJ IDEA，选择试用版，或者注册一个合法的许可。
4. 在 IntelliJ IDEA 中安装 Spring Boot 插件，通过 File -> Settings -> Plugins，搜索 "Spring Boot"，点击安装，重启 IDE。
5. 在 IntelliJ IDEA 中安装 Maven 或 Gradle 插件，同样通过 File -> Settings -> Plugins，搜索 "Maven" 或 "Gradle"，点击安装。

创建第一个SpringBoot项目

1. 打开 IntelliJ IDEA，选择 File -> New -> Project。
2. 选择 Spring Initializr，点击 Next。
3. 在 Project 设置中，选择语言版本为 Java，并设置项目 SDK 为之前安装的 JDK。
4. 在 Spring Boot 选项卡中，输入以下信息：
   • Project SDK：选择安装的 JDK。
   • Java：选择语言版本，如 Java 11。
   • Group：项目组织标识，如 com.example。
   • Artifact：项目名称，如 demo。
   • Version：Spring Boot 版本，如 2.7.4。
   • Packaging：选择 JAR。
   • Java：选择依赖版本，如 Java 8。
   • Dependencies：选择 Spring Web 依赖。
5. 点击 Next，选择 Next，最后点击 Finish 完成项目创建。

生成的项目结构如下：

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

DemoApplication.java

这是项目的主类，通常是启动类，包含 main 方法：

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

application.properties

这是应用的配置文件：

server.port=8080
spring.application.name=demo

运行项目

在 IntelliJ IDEA 中，双击 DemoApplication.java 文件中的 main 方法，或者右键点击，选择 Run 'DemoApplication.main()'，即可运行项目。默认情况下，项目会在 http://localhost:8080/ 启动。

SpringBoot核心概念与配置

自动配置原理

Spring Boot 通过 @SpringBootApplication 注解来简化应用的启动过程，该注解包含了三个注解的功能：

• @Configuration：标记类为配置类，可以包含 @Bean 注解的配置方法。
• @EnableAutoConfiguration：启用基于类路径自动配置。
• @ComponentScan：扫描并注册 @Component 或其他Spring注解的类，如 @Service 和 @Repository 类。

当应用启动时，Spring Boot 会根据类路径中的内容自动配置应用程序，例如数据库连接、Web 应用程序等。Spring Boot 会尝试推断开发者的需求，并自动配置相应的组件。开发者可以通过 @SpringBootApplication 注解的 exclude 属性来排除某些自动配置，例如：

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

此外，Spring Boot 提供了 spring-boot-configuration-processor 依赖来生成自动配置类的注释文档，方便开发者查看和自定义自动配置。

配置文件详解（application.properties与application.yml）

Spring Boot 支持两种配置文件格式：application.properties 和 application.yml。默认情况下，Spring Boot 会先查找 application.properties 文件，如果未找到，则查找 application.yml 文件。

application.properties

application.properties 文件是一个键值对格式的配置文件，适用于简单的配置需求。例如：

# server.port 是一个内置的配置属性，用于设置服务器端口
server.port=8080

# 指定应用名称
spring.application.name=demo

# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root

application.yml

application.yml 文件使用 YAML 格式，比 application.properties 更加灵活和紧凑。例如：

server:
  port: 8080

spring:
  application:
    name: demo
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: root

项目依赖管理

Spring Boot 使用 Maven 或 Gradle 作为构建工具，通过 pom.xml 或 build.gradle 文件管理项目依赖。以下是使用 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>
    <packaging>jar</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.4</version>
    </parent>

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

    <properties>
        <java.version>1.8</java.version>
    </properties>
</project>

在 pom.xml 文件中，<dependencies> 标签定义了项目所需的依赖，例如 spring-boot-starter-web 依赖，该依赖包含了实现 web 服务所需的所有库。

SpringBoot常用功能实现

RESTful API的开发

RESTful API 是基于 REST 架构风格的 API 设计，它强调资源的表示状态转移，主要通过 HTTP 的 GET、POST、PUT、DELETE 等方法来操作资源。

创建RESTful API

1. 在项目中添加 spring-boot-starter-web 依赖，该依赖包含了开发 RESTful API 所需的所有库。
2. 创建一个控制器类，如下所示：

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

1. 在 DemoApplication.java 主类中添加 @SpringBootApplication 注解并运行项目。
2. 访问 http://localhost:8080/hello，将看到返回的消息 "Hello, Spring Boot!"。

复杂场景的RESTful API实现

1. 创建一个 RESTful API 以处理复杂的 CRUD 操作。

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.*;

@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found"));
    }

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

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        User existingUser = userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User not found"));
        existingUser.setUsername(user.getUsername());
        existingUser.setPassword(user.getPassword());
        return userRepository.save(existingUser);
    }

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

数据库集成（使用JPA与MyBatis）

使用JPA

JPA（Java Persistence API）是一种持久化规范，Spring Data JPA 是实现该规范的一种持久层解决方案。它提供了一套简化关系数据持久化的 API，并能够与 Spring Boot 无缝集成。

1. 添加 spring-boot-starter-data-jpa 依赖：

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

1. 创建实体类 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 Integer age;

    // 省略getter和setter方法
}

1. 创建 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> {
    // 可以定义额外的查询方法
}

1. 创建 UserMapper 类：

package com.example.demo.mapper;

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper {
    User selectUserById(Long id);
    User selectUserByName(String name);
    int insertUser(User user);
    int updateUser(User user);
    int deleteUser(Long id);
}

使用MyBatis

MyBatis 是一个优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。Spring Boot 通过 spring-boot-starter-mybatis 依赖支持 MyBatis 集成。

1. 添加 spring-boot-starter-mybatis 依赖：

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

1. 配置 mybatis.mapper-locations 属性：

mybatis:
  mapper-locations: classpath*:mapper/*.xml

1. 创建 UserMapper 接口：

package com.example.demo.mapper;

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper {
    User selectUserById(Long id);
}

1. 创建 UserMapper.xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper SYSTEM "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
    <select id="selectUserById" resultType="com.example.demo.entity.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

SpringSecurity安全认证

Spring Security 是一个强大的、灵活的 Java 安全框架，基于 Spring 框架构建，提供了认证和授权功能。它支持多种认证方式，如内存认证、表单登录、JWT 等。

1. 使用 spring-security-data-jpa 依赖，添加如下依赖：

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

1. 创建 UserDetails 类：

package com.example.demo.security;

import org.springframework.security.core.userdetails.UserDetails;

public class UserPrincipal implements UserDetails {
    private final User user;

    public UserPrincipal(User user) {
        this.user = user;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return List.of(new SimpleGrantedAuthority("USER"));
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getUsername();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

1. 创建 UserDetailsService 实现类：

package com.example.demo.security;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("User not found"));
        return new UserPrincipal(user);
    }
}

1. 配置 Spring Security：

spring:
  security:
    user:
      name: admin
      password: admin

1. 创建 SecurityConfig 类：

package com.example.demo.config;

import com.example.demo.security.UserDetailsServiceImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
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 {
    @Autowired
    private UserDetailsServiceImpl userDetailsService;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }

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

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

日志管理与SpringBoot Actuator监控

日志管理

Spring Boot 默认使用 logback 进行日志管理，可以通过 application.properties 或 application.yml 文件进行配置：

# 配置日志文件位置及格式
logging.file.path=/path/to/log
logging.file.name=demo.log

或者

logging:
  file:
    path: /path/to/log
    name: demo.log

SpringBoot Actuator监控

Spring Boot Actuator 提供了一系列 RESTful API，用于监控和管理应用的运行状态。启用 Actuator 需要添加以下依赖：

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

启用Actuator监控

配置文件中添加 management.endpoints.web.exposure.include 属性，启用 Actuator 监控端点：

management:
  endpoints:
    web:
      exposure:
        include: "*"

运行应用后，访问 http://localhost:8080/actuator 可以查看 Actuator 提供的各种监控端点。

实战案例：搭建一个简单的博客系统

需求分析与系统设计

需求分析

一个简单的博客系统通常需要具备以下功能：

• 文章管理：包括发布、编辑和删除文章。
• 用户管理：包括注册、登录、修改个人信息等。
• 评论管理：允许读者对文章进行评论。
• 分类管理：为文章设置不同的分类。
• 标签管理：为文章添加标签。
• 阅读量统计：显示文章阅读次数。

系统设计

根据需求分析，设计以下主要实体类：

• User：表示用户实体。
• Article：表示文章实体。
• Comment：表示评论实体。
• Category：表示分类实体。
• Tag：表示标签实体。

功能模块实现

用户管理

1. 创建 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 username;
    private String password;

    // 省略getter和setter方法
}

1. 创建 UserRepository 接口：

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> {
    User findByUsername(String username);
}

1. 创建 UserController 控制器：

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.*;

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

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

    @GetMapping("/login")
    public User login(@RequestParam String username, @RequestParam String password) {
        return userRepository.findByUsername(username);
    }
}

文章管理

1. 创建 Article 实体：

package com.example.demo.entity;

import javax.persistence.*;
import java.util.Date;

@Entity
public class Article {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;
    private Date publishDate;
    private Long userId;
    private Integer views;

    // 省略getter和setter方法
}

1. 创建 ArticleRepository 接口：

package com.example.demo.repository;

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

public interface ArticleRepository extends JpaRepository<Article, Long> {
    Article findByTitle(String title);
}

1. 创建 ArticleController 控制器：

package com.example.demo.controller;

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

@RestController
@RequestMapping("/articles")
public class ArticleController {
    @Autowired
    private ArticleRepository articleRepository;

    @PostMapping("/publish")
    public Article publishArticle(@RequestBody Article article) {
        return articleRepository.save(article);
    }

    @GetMapping("/read/{id}")
    public Article readArticle(@PathVariable Long id) {
        Article article = articleRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Article not found"));
        article.setViews(article.getViews() + 1);
        return articleRepository.save(article);
    }

    @GetMapping("/list")
    public List<Article> listArticles() {
        return articleRepository.findAll();
    }
}

前后端分离开发简介

前后端分离开发是指前端和后端开发相对独立，前端主要负责用户界面的展示和交互，后端主要负责业务逻辑和数据处理。这种开发模式的优点包括：

• 更好的可维护性：前后端代码分离，降低了复杂度。
• 更高的开发效率：前后端可以并行开发，加快项目进度。
• 更佳的用户体验：前端可以使用最新的技术栈，提供优秀的用户体验。

在博客系统中，前端可以使用 Vue.js、React 或者 Angular 等前端框架，后端则使用 Spring Boot 提供 RESTful API。

打包与部署

打包SpringBoot应用

在 IntelliJ IDEA 中，通过 File -> Project Structure -> Artifacts，添加一个新的 JAR 配置文件，勾选 Main Class 选项，输入 DemoApplication，点击 OK。

然后执行 Build -> Build Artifacts... -> Build 操作来生成一个可执行的 JAR 文件，具体命令为：

mvn package

或者使用 Gradle：

./gradlew build

部署到Tomcat与Docker容器

部署到Tomcat

1. 下载并安装 Tomcat，例如 Apache Tomcat 9.0。
2. 将生成的 JAR 文件复制到 Tomcat 的 webapps 目录。
3. 启动 Tomcat 服务器，访问 http://localhost:8080/，Tomcat 会将 JAR 文件解压，并自动部署应用。

部署到Docker容器

1. 编写 Dockerfile，配置 Spring Boot 应用的 Docker 镜像：

FROM openjdk:8-jdk-alpine
VOLUME /tmp
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

1. 执行 docker build -t demo:latest . 命令构建镜像。
2. 执行 docker run -p 8080:8080 demo:latest 命令启动容器。

部署到云服务器

1. 使用 SSH 登录云服务器。
2. 将生成的 JAR 文件上传至服务器，例如使用 scp 命令：

scp target/demo.jar user@server:/path/to/server/

1. 在服务器上执行 java -jar demo.jar 命令启动应用。
2. 访问服务器的 IP 地址，测试应用是否正常运行。