Spring Boot企业级开发学习入门教程-原创手记-慕课网

概述

Spring Boot企业级开发学习涵盖了从环境搭建到核心概念、企业级开发基础、安全与权限管理、性能优化与部署等多方面内容。本文通过详细的示例代码引导开发者快速掌握Spring Boot的核心特性和最佳实践。从入门到进阶，帮助开发者构建独立的、生产级别的基于Spring的应用程序。

Spring Boot简介与环境搭建

Spring Boot简介

Spring Boot是由Pivotal团队提供的一个开源框架，旨在简化新Spring应用程序的初始搭建和配置过程。通过Spring Boot，开发者能快速构建独立的、生产级别的基于Spring的应用程序。

Spring Boot的核心特性如下：

聚合大量常用的库，例如Spring MVC、Spring Data JPA等，简化项目配置。
提供默认配置，让开发者可以快速上手。
提供一套启动类注解，简化传统Spring配置。
自动配置，减少配置文件的编写。

开发环境搭建

开发Spring Boot应用前，需要安装好Java和Maven或Gradle。Spring Boot支持Java 8及以上版本。

安装Java

访问Oracle官网或AdoptOpenJDK下载Java安装包。
按照安装向导完成安装。
设置环境变量。
- 系统环境变量JAVA_HOME指向Java安装目录。
- PATH环境变量添加%JAVA_HOME%\bin。
验证安装：在命令行输入java -version，显示版本信息即表示安装成功。

安装Maven

访问Maven官网下载Maven安装包。
解压下载包并设置环境变量。
- 系统环境变量MAVEN_HOME指向Maven解压目录。
- PATH环境变量添加%MAVEN_HOME%\bin。
验证安装：在命令行输入mvn -version，显示版本信息即表示安装成功。

快速创建Spring Boot项目

使用Spring Initializr网站或IDE插件快速创建Spring Boot项目。

访问https://start.spring.io。
选择项目配置：
- 语言：Java
- 版本：8或更高版本
- 依赖：Spring Web、Thymeleaf等。
下载并解压项目。
导入到IDE中。

使用Maven创建Spring Boot项目

创建一个Maven项目，添加Spring Boot依赖。项目结构如下：

my-spring-boot-app
│── src
│   ├── main
│   │   ├── java
│   │   │   └── com.example
│   │   │       └── MySpringBootApplication.java
│   │   └── resources
│   │       └── application.properties
│   └── test
│       └── java
│           └── com.example
│               └── MySpringBootApplicationTests.java
└── pom.xml

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

<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>my-spring-boot-app</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.3</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使用Maven或Gradle等构建工具管理项目依赖。在pom.xml或build.gradle文件中声明依赖。

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <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>
</dependencies>

配置文件

Spring Boot使用application.properties或application.yml配置文件。配置文件位于src/main/resources目录下。

# 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核心概念与特性

自动配置机制

Spring Boot通过@SpringBootApplication注解启动自动配置。自动配置根据类路径中的依赖类自动生成配置。例如，使用Spring Data JPA自动配置数据库。

示例代码

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

起步依赖

起步依赖是一组预定义的依赖集合。例如spring-boot-starter-web包含构建web应用所需的所有依赖，包括Spring MVC。

示例代码

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

配置属性绑定

Spring Boot允许将配置属性绑定到Java对象中。可以使用@ConfigurationProperties注解将属性绑定到Java Bean。

示例代码

创建一个Java Bean用于绑定配置属性：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "example")
public class ExampleProperties {
  private String name;
  private int age;

  // getters and setters
}

在配置文件中设置属性：

# application.properties
example.name=John Doe
example.age=30

Actuator监控与管理

Spring Boot Actuator提供生产中应用的运行时监控，包括健康检查、信息暴露等。

示例代码

添加依赖：

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

配置文件中启用健康检查和信息端点：

# application.properties
management.endpoints.web.exposure.include=health,info

Spring Boot企业级开发基础

数据库集成与操作

Spring Boot支持多种数据库，包括关系型数据库（如MySQL、PostgreSQL）和NoSQL数据库（如MongoDB）。

示例代码

使用Spring Data JPA操作MySQL数据库：

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

配置文件中的数据库连接：

# 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

定义一个JPA实体：

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private Long id;
  private String name;

  // getters and setters
}

使用JPA Repository：

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

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

示例代码

定义控制器：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

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

  @GetMapping("/users")
  public List<User> getUsers() {
    return userRepository.findAll();
  }
}

RESTful API设计与开发

Spring Boot支持快速构建RESTful API。使用控制器（Controller）、RESTful风格的URL、HTTP动词（GET, POST, PUT, DELETE）等。

示例代码

定义一个API控制器：

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 UserRepository userRepository;

  @GetMapping
  public List<User> getUsers() {
    return userRepository.findAll();
  }

  @PostMapping
  public User addUser(@RequestBody User user) {
    return userRepository.save(user);
  }

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

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

常见错误处理与日志管理

使用@ControllerAdvice处理全局异常。使用slf4j进行日志记录。

示例代码

全局异常处理：

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

@ControllerAdvice
public class GlobalExceptionHandler {
  @ExceptionHandler(Exception.class)
  @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  public String handleException() {
    return "An unexpected error occurred.";
  }
}

日志记录：

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 UserController {
  private static final Logger logger = LoggerFactory.getLogger(UserController.class);

  @GetMapping("/users")
  public List<User> getUsers() {
    logger.info("Fetching users");
    return userRepository.findAll();
  }
}

Spring Boot安全与权限管理

使用Spring Security实现认证与授权

Spring Security是Spring Boot中的安全框架，实现认证与授权。

示例代码

添加依赖：

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

配置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.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http
      .authorizeRequests()
        .antMatchers("/api/users").hasRole("ADMIN")
        .antMatchers("/api/users/**").hasRole("ADMIN")
        .and()
      .formLogin()
        .loginPage("/login")
        .permitAll()
        .and()
      .logout()
        .permitAll();
  }
}

JWT令牌与Session管理

JWT（JSON Web Token）是一种开放标准，用于在各方之间安全地将信息作为JSON对象传输。

示例代码

添加依赖：

<dependency>
  <groupId>io.jsonwebtoken</groupId>
  <artifactId>jjwt</artifactId>
  <version>0.9.1</version>
</dependency>

创建Token生成器：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public class TokenUtil {
  private static final String SECRET = "secret";
  private static final long EXPIRATION = 3600000;

  public static String generateToken(String username) {
    return Jwts.builder()
        .setSubject(username)
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
        .signWith(SignatureAlgorithm.HS512, SECRET)
        .compact();
  }

  public static Claims parseToken(String token) {
    return Jwts.parser()
        .setSigningKey(SECRET)
        .parseClaimsJws(token)
        .getBody();
  }
}

用户权限控制与角色管理

Spring Security提供角色和权限的定义。

示例代码

定义用户和角色：

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
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;

import java.util.ArrayList;
import java.util.List;

@Service
public class CustomUserDetailsService implements UserDetailsService {
  @Override
  public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    // 实际应用中从数据库加载用户信息
    List<GrantedAuthority> authorities = new ArrayList<>();
    authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
    if ("admin".equals(username)) {
      authorities.add(new SimpleGrantedAuthority("ROLE_ADMIN"));
    }
    return new org.springframework.security.core.userdetails.User(username, "password", authorities);
  }
}

验证JWT令牌：

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Component
public class JwtAuthenticationFilter extends GenericFilterBean {
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest httpRequest = (HttpServletRequest) request;
    String token = httpRequest.getHeader("Authorization");
    if (token != null) {
      Claims claims = Jwts.parser().setSigningKey(SECRET).parseClaimsJws(token).getBody();
      String username = claims.getSubject();
      UserDetails userDetails = customUserDetailsService.loadUserByUsername(username);
      UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
      authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpRequest));
      SecurityContextHolder.getContext().setAuthentication(authentication);
    }
    chain.doFilter(request, response);
  }
}

Spring Boot性能优化与部署

代码优化与性能调优

性能优化包括代码优化、减少资源加载时间、使用缓存策略等。

示例代码

使用Spring的@Cacheable注解缓存数据：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserService {
  @Cacheable("users")
  public User getUserById(Long id) {
    // 从数据库查询用户
    return userRepository.findById(id).orElse(null);
  }
}

使用Spring Boot DevTools提升开发效率

Spring Boot DevTools提供热重载、自动恢复等特性，提升开发效率。

示例代码

添加依赖：

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

应用打包与部署

使用mvn package或gradle build命令打包应用。打包后的应用包含所有依赖的jar包，可以直接运行。

示例代码

打包命令：

mvn clean package

运行打包后的应用：

java -jar target/my-spring-boot-app-0.0.1-SNAPSHOT.jar

容器化部署（Docker）

使用Docker将应用容器化部署。

示例代码

创建Dockerfile：

FROM openjdk:11-jre-slim

WORKDIR /app

COPY target/my-spring-boot-app-0.0.1-SNAPSHOT.jar my-spring-boot-app.jar

EXPOSE 8080

CMD ["java", "-jar", "my-spring-boot-app.jar"]

构建Docker镜像：

docker build -t my-spring-boot-app .

运行Docker容器：

docker run -p 8080:8080 -d my-spring-boot-app

总结

本教程详细介绍了Spring Boot企业级开发入门知识，包括环境搭建、核心概念、企业级开发基础、安全与权限管理、性能优化与部署等内容。通过示例代码帮助开发者快速上手，掌握Spring Boot的核心特性和最佳实践。