SpringBoot企业级开发教程：从零开始的实战指南

本文提供了从零开始的SpringBoot企业级开发教程，涵盖快速入门、核心概念、实战应用和高级特性。通过详细步骤和示例代码，帮助开发者快速搭建和管理SpringBoot项目。此外，教程还介绍了数据库集成、安全认证和监控等关键内容。

SpringBoot企业级开发教程：从零开始的实战指南 SpringBoot快速入门

SpringBoot简介

Spring Boot 是由 Pivotal 团队提供的一个基于 Spring 框架的开源框架，旨在简化新 Spring 应用的初始搭建以及开发过程。它通过约定优于配置的原则来大幅度减少代码量，使开发者能够快速构建独立的、生产级别的应用。Spring Boot 不需要编写大量的配置，只需要少量的配置便能快速创建一个独立运行的 Spring 应用。

创建第一个SpringBoot项目

要创建第一个 Spring Boot 项目，需要遵循以下步骤：

1. 安装 Java 环境：确保你的开发环境中已经安装了 Java SDK。建议使用 Java 11 或更高版本。
2. 安装 Maven 或 Gradle：Spring Boot 支持 Maven 和 Gradle 作为构建工具。这里以 Maven 为例进行说明。
3. 创建项目：在 IntelliJ IDEA 或 Eclipse 中使用 Spring Initializr 来创建一个新的 Spring Boot 项目。Spring Initializr 是一个在线工具，可以自动生成项目结构和依赖配置。

例如，使用 IntelliJ IDEA 创建项目：

1. 打开 IntelliJ IDEA
2. 选择 File -> New -> Project
3. 在弹出的窗口中选择 Spring Initializr，然后点击 Next
4. 输入项目基本信息（如 Group、Artifact、Version、Name 等），选择 Java 语言和 Maven 构建工具。
5. 在依赖选项中选择需要的依赖（如 Spring Web），然后点击 Finish

生成项目后，pom.xml 中会自动生成相应的依赖配置。

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

项目结构与依赖管理

Spring Boot 项目的目录结构通常如下：

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

• DemoApplication.java：主应用程序类，用于启动 Spring Boot 应用。
• application.properties：项目配置文件。
• static：静态资源目录，例如 HTML、CSS、JavaScript 等。
• templates：模板文件目录，如果使用 Thymeleaf 等模板引擎。

创建第一个控制器

在DemoApplication.java同级目录下创建一个控制器类（Controller），命名为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 hello() {
        return "Hello, World!";
    }
}

在 application.properties 文件中添加应用端口号：

server.port=8080

运行 DemoApplication.java 类的 main 方法，启动应用。然后在浏览器中访问 http://localhost:8080/hello，可以看到输出 Hello, World!。

SpringBoot核心概念详解

自动装配与配置

Spring Boot 的核心功能之一是自动装配。自动装配意味着 Spring Boot 会自动配置并组装应用的各个部分，而无需手动配置每个组件。这通过使用注解和配置类来实现。

例如，我们可以通过添加依赖来自动配置数据库连接：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Spring Boot 会自动检测这些依赖并配置数据源、事务管理器等。

Starter依赖与扩展点

Starter 是 Spring Boot 项目中最基本的依赖管理器。每个 Starter 通常是为了在开发中提供一组常用的依赖，并且这些依赖通常会被自动配置以减少开发者的工作量。例如：

• spring-boot-starter-web：包含 Spring MVC 必要的依赖，如 Tomcat、Spring MVC、JSON 处理等。
• spring-boot-starter-data-jpa：包含 Spring Data JPA 和 JPA 实现（如 Hibernate）等。

配置文件详解

Spring Boot 支持多种配置文件，最常用的是 application.properties 和 application.yml。配置文件通常放置在src/main/resources目录下。

配置文件示例

# application.properties 示例
server.port=8080
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

# application.yml 示例
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root

实战：企业级应用开发

创建RESTful服务

RESTful API 通常用于构建可扩展且易于维护的 Web 服务。以下是创建一个简单的 RESTful 服务的步骤。

创建实体

首先，创建一个简单的实体类 User，用于表示用户。

package com.example.demo.model;

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;

    // Getters and Setters
}

创建仓库

接下来，创建一个仓库接口 UserRepository，用于与数据库进行交互。

package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

创建服务

创建一个服务类 UserService，该类将与用户相关的所有业务逻辑都封装起来。

package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
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 User createUser(User user) {
        return userRepository.save(user);
    }

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

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    public User updateUser(User updatedUser) {
        User user = userRepository.findById(updatedUser.getId()).orElse(null);
        if (user != null) {
            user.setName(updatedUser.getName());
            user.setEmail(updatedUser.getEmail());
            userRepository.save(user);
        }
        return user;
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

创建控制器

创建一个控制器 UserController，它将处理 REST API 请求。

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

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

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

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

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

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

数据库集成（JPA/MyBatis）

配置JPA

在 pom.xml 或 build.gradle 中添加 JPA 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.hsqldb</groupId>
    <artifactId>hsqldb</artifactId>
    <scope>runtime</scope>
</dependency>

在 application.properties 中配置数据源：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=create

使用 MyBatis

如果选择使用 MyBatis，需要添加 MyBatis Starter 依赖：

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

配置 MyBatis 数据源：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
mybatis.mapper-locations=classpath:mapper/*.xml

编写 Mapper 接口及 XML 映射文件。

安全认证与授权（Spring Security）

安全配置

在 pom.xml 中添加 Spring Security 依赖：

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

创建一个安全配置类 SecurityConfig：

package com.example.demo.config;

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;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 设置允许访问的资源
        http
            .authorizeRequests()
            .antMatchers("/", "/index", "/home", "/admin", "/user/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }
}

用户认证

可以创建一个简单的用户认证配置：

package com.example.demo.config;

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.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(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
            .withUser("user")
            .password(passwordEncoder().encode("password"))
            .roles("USER")
            .and()
            .withUser("admin")
            .password(passwordEncoder().encode("password"))
            .roles("ADMIN");
    }

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

添加登录页面

创建一个简单的登录页面 login.html：

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

日志与监控

日志管理

Spring Boot 内置了日志，可以方便地配置不同的日志框架，如 Logback、Log4j2 等。在 application.properties 中配置日志相关选项：

logging.level.root=INFO
logging.level.com.example=DEBUG
logging.file.name=/path/to/logfile.log

应用监控与诊断

Spring Boot 提供了 Actuator 来帮助监控和管理应用。Actuator 会暴露许多管理端点，如 /actuator/health、/actuator/info 等。

在 pom.xml 中添加 Actuator 依赖：

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

启用所有端点：

management.endpoints.web.exposure.include=*

使用Prometheus监控

为了更好地监控应用，可以使用 Prometheus 和 Grafana。

1. 在 pom.xml 中添加 Prometheus Client 依赖：

<dependency>
    <groupId>io.prometheus</groupId>
    <artifactId>simpleclient</artifactId>
    <version>0.10.0</version>
</dependency>
<dependency>
    <groupId>io.prometheus</groupId>
    <artifactId>simpleclient_springboot</artifactId>
    <version>0.10.0</version>
</dependency>

1. 配置 Actuator 以使用 Prometheus：

management.endpoints.web.exposure.include=*
management.endpoint.metrics.enabled=true
management.metrics.web.server.request.burstSize=100
management.metrics.web.server.request.rateLimit=10
management.metrics.web.server.request.timeInterval=5
management.metrics.web.server.request.includePayloadDetails=true
management.metrics.web.server.request.includeExceptionDetails=true
management.metrics.web.server.request.includeMethodDetails=true
management.metrics.web.server.request.includeUrlDetails=true
management.metrics.web.server.request.includeUserAgentDetails=true
management.metrics.web.server.request.includeRemoteAddressDetails=true
management.metrics.web.server.request.includeStatusCodeDetails=true
management.metrics.web.server.request.includeContentTypeDetails=true
management.metrics.web.server.request.includeContentLengthDetails=true
management.metrics.web.server.request.includePayloadSizeDetails=true
management.metrics.web.server.request.includeRequestTimeDetails=true
management.metrics.web.server.request.includeResponseTimeDetails=true
management.metrics.web.server.request.includeRequestPayloadDetails=true
management.metrics.web.server.request.includeResponsePayloadDetails=true
management.metrics.web.server.request.includeRequestHeadersDetails=true
management.metrics.web.server.request.includeResponseHeadersDetails=true
management.metrics.web.server.request.includeCookiesDetails=true
management.metrics.web.server.request.includeSessionDetails=true
management.metrics.web.server.request.includePrincipalDetails=true
management.metrics.web.server.request.includeRemoteUserDetails=true
management.metrics.web.server.request.includeAuthenticationDetails=true
management.metrics.web.server.request.includeSecurityContextDetails=true
management.metrics.web.server.request.includeSecurityPrincipalDetails=true
management.metrics.web.server.request.includeSecurityAuthoritiesDetails=true
management.metrics.web.server.request.includeSecurityAuthenticatedDetails=true
management.metrics.web.server.request.includeSecurityDetails=true
management.metrics.web.server.request.includeSecurityContextDetails=true
management.metrics.web.server.request.includeSecurityPrincipalDetails=true
management.metrics.web.server.request.includeSecurityAuthoritiesDetails=true
management.metrics.web.server.request.includeSecurityAuthenticatedDetails=true
management.metrics.web.server.request.includeSecurityDetails=true
management.metrics.web.server.request.includeSecurityContextDetails=true
management.metrics.web.server.request.includeSecurityPrincipalDetails=true
management.metrics.web.server.request.includeSecurityAuthoritiesDetails=true
management.metrics.web.server.request.includeSecurityAuthenticatedDetails=true
management.metrics.web.server.request.includeSecurityDetails=true

使用Spring Boot Admin监控

Spring Boot Admin 是一个开源项目，用于监控 Spring Boot 应用。在 pom.xml 中添加 Spring Boot Admin Server 依赖：

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
    <version>2.2.4</version>
</dependency>

配置 Spring Boot Admin Server：

spring.boot.admin.context-path=/admin
spring.boot.admin.client.enabled=true
spring.boot.admin.client.url=http://localhost:8080/admin

高级特性

分布式配置（Spring Cloud Config）

Spring Cloud Config 为 Spring Boot 应用提供集中式配置服务。可以通过 Git、SVN 等版本控制系统来存储配置。

在 pom.xml 中添加 Spring Cloud Config 客户端和服务器依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

配置 Spring Cloud Config Server：

spring.cloud.config.server.git.uri=https://github.com/your-repo/config-repo
spring.cloud.config.server.git.searchPaths=your-repo

配置 Spring Cloud Config Client：

spring.cloud.config.enabled=true
spring.cloud.config.uri=http://localhost:8080/config

服务发现与注册（Spring Cloud Eureka）

在 pom.xml 中添加 Spring Cloud Eureka 依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

配置 Eureka Server：

spring.application.name=eureka-server
server.port=8761
spring.cloud.netflix.eureka.server.enable-self-registration=true
spring.cloud.netflix.eureka.server.bind-hostname=localhost

配置 Eureka Client：

spring.application.name=my-service
server.port=8080
spring.cloud.netflix.eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

API网关（Spring Cloud Gateway）

在 pom.xml 中添加 Spring Cloud Gateway 依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

配置 Gateway：

spring.application.name=gateway
server.port=8090
spring.cloud.gateway.routes[0].id=path_route
spring.cloud.gateway.routes[0].uri=http://localhost:8080
spring.cloud.gateway.routes[0].predicates[0]=Path=/path/**

项目部署与运维

打包与部署

在 pom.xml 中添加 Spring Boot 的打包插件配置：

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

使用 Maven 打包：

mvn clean package

使用 Docker 部署：

version: '3'
services:
  app:
    image: your-repo:tag
    ports:
      - "8080:8080"

使用 Kubernetes 部署：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: app
  template:
    metadata:
      labels:
        app: app
    spec:
      containers:
      - name: app
        image: your-repo:tag
        ports:
        - containerPort: 8080