第2章 Spring Security 的环境设置与基础配置（2024 最新版）

已于 2024-03-26 14:27:32 修改
阅读量852 收藏 17
点赞数 30
分类专栏： 《Spring Security 简易速速上手小册》 文章标签： spring spring cloud spring boot 权限管理 人工智能 区块链 web3
于 2024-02-29 08:49:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41340258/article/details/136361156
版权

在这里插入图片描述

文章目录

2.1 安装和配置 Spring Boot

2.1.1 基础知识详解

在深入 Spring Boot 的世界之前，让我们先了解一些基础知识，这就像是在开始一场激动人心的旅行前查看地图一样。

Spring Boot 的核心概念

  1. 自动配置: Spring Boot 的自动配置机制旨在根据添加的依赖自动配置你的应用程序。这就像有一个智能助手，根据你的需求自动为你准备一切。

  2. 起步依赖（Starters）: 这些特殊的依赖项是预设的模板，它们为你提供了一切必需的依赖组合，帮助你快速启动一个特定类型的项目。比如，spring-boot-starter-web 就包含了构建 web 应用所需的所有基础设施。

  3. 内嵌服务器: Spring Boot 应用通常会内嵌一个 Tomcat、Jetty 或 Undertow 服务器，这意味着你不需要单独安装一个服务器就可以运行你的应用。

  4. 无代码生成和 XML 配置: 与传统的 Spring 框架相比，Spring Boot 允许你使用极少甚至无需任何 XML 配置来启动一个应用，让你的代码库更加整洁。

  5. 应用监控: Spring Boot Actuator 提供了一套现成的应用监控和管理功能，可以帮助你监视应用的运行状态和各种指标。

安装步骤

  1. 访问 Spring Initializr: 打开 Spring Initializr，这是一个在线工具，可以帮助你快速生成 Spring Boot 项目结构。

  2. 选择项目设置:

    • 项目类型: Maven 或 Gradle。Maven 是传统选择，而 Gradle 提供了更现代的构建工具体验。
    • Spring Boot 版本: 通常选择最新稳定版本。
    • 项目元数据: 如 Group、Artifact 等，这些将成为你的项目唯一标识。

  3. 添加起步依赖:

    • 选择你所需的起步依赖，例如 spring-boot-starter-web 用于创建 web 应用。

  4. 生成项目:

    • 生成并下载项目压缩文件。
    • 解压缩并使用你喜欢的 IDE（如 IntelliJ IDEA、Eclipse）打开。

配置和运行

  1. 配置应用属性:

    • 在 application.properties 或 application.yml 文件中设置应用的配置，如端口号、数据库配置等。

  2. 编写业务逻辑:

    • 创建模型（Model）、视图（View）和控制器（Controller）等组件。

  3. 运行应用:

    • 直接在 IDE 中运行应用，或者在命令行中使用 mvn spring-boot:run 或 gradle bootRun 命令启动应用。

通过掌握这些基础知识，你就能够顺利地开始你的 Spring Boot 旅程，并为集成 Spring Security 做好准备。这就像是为你的软件开发之旅装上了一个涡轮增压器！接下来的章节将带你深入到更具挑战性的 Spring Security 领域，准备好了吗？让我们开始吧！

2.1.2 主要案例：创建基本的 Spring Boot 应用

在这个案例中，我们将一步步创建一个基本的 Spring Boot 应用程序。这就像是在建造你自己的数字王国的第一块砖。

案例 Demo

假设我们正在开发一个简单的博客应用，它将有一个页面来显示一条欢迎信息。

步骤 1：项目初始化

  1. 访问 Spring Initializr。
  2. 选择你的项目设置，例如 Maven 作为构建工具和 Java 作为编程语言。
  3. 选择 Spring Boot 的最新稳定版本。
  4. 在依赖中添加 spring-boot-starter-web。
  5. 点击“生成”，下载项目压缩包。

步骤 2：项目结构

  1. 解压缩下载的文件。
  2. 使用你喜欢的 IDE（例如 IntelliJ IDEA 或 Eclipse）打开项目。
  3. 查看项目结构，主要关注以下目录：
    • src/main/java: 存放 Java 源代码。
    • src/main/resources: 存放资源文件，如配置文件。

步骤 3：编写 Hello World 控制器

  1. 在 src/main/java 下，找到主应用程序类（通常命名为 Application 或与你的项目名称相同）。

  2. 创建一个新的包，例如 com.example.blog。

  3. 在该包中创建一个新的 Java 类 HelloController。

    package com.example.blog;

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

@RestController
public class HelloController {

    @GetMapping("/")
    public String hello() {
        return "Welcome to the Blog!";
    }
}

步骤 4：运行应用程序

  1. 回到主应用程序类，并运行应用。
  2. 打开浏览器，访问 http://localhost:8080。
  3. 你应该看到页面上显示“Welcome to the Blog!”。

再添加一个简单的服务

假设我们想要在应用中添加一个服务来处理一些业务逻辑。

案例 Demo:

  1. 创建服务类:

    • 在 com.example.blog 包下创建一个新的类 BlogService。
    package com.example.blog;

import org.springframework.stereotype.Service;

@Service
public class BlogService {

    public String getWelcomeMessage() {
        return "Welcome to the Blog!";
    }
}

  2. 修改控制器以使用服务:

    • 注入 BlogService 到 HelloController 并使用它。
    @RestController
public class HelloController {

    private final BlogService blogService;

    public HelloController(BlogService blogService) {
        this.blogService = blogService;
    }

    @GetMapping("/")
    public String hello() {
        return blogService.getWelcomeMessage();
    }
}

  3. 运行并测试:

    • 再次运行应用程序，并验证服务是否正确返回消息。

还可以整合数据库

让我们进一步扩展应用，通过整合数据库来存储和检索数据。

案例 Demo:

  1. 添加数据库依赖:

    • 在 pom.xml 中添加 spring-boot-starter-data-jpa 和内嵌数据库（如 H2）的依赖。

  2. 配置数据库:

    • 在 application.properties 中配置数据库。

  3. 创建实体和仓库:

    • 定义一个实体类 BlogPost 和一个仓库接口 BlogPostRepository。

  4. 修改服务以使用数据库:

    • 更新 BlogService 以使用 BlogPostRepository。

  5. 运行并测试:

    • 测试应用能否正确地存取数据。

通过这个案例，你将了解到如何从零开始创建一个 Spring Boot 应用，并逐步扩展其功能，从一个简单的 “Hello World” 到集成服务和数据库。这将为你打下坚实的基础，为进一步探索 Spring Security 的世界做好准备。

2.1.3 拓展案例 1：添加数据库支持

在这个案例中，我们将在 Spring Boot 应用中添加数据库支持，以增强其数据持久化能力。我们将构建一个简单的博客应用，其中包括保存和检索博客文章的功能。

案例 Demo

假设我们的博客应用需要保存博客文章到数据库，并能够从数据库中检索这些文章。

步骤 1：添加数据库依赖

  1. 在 pom.xml 中添加 spring-boot-starter-data-jpa 依赖和一个数据库连接池依赖，例如 H2。

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

步骤 2：配置数据库

  1. 在 application.properties 中配置 H2 数据库。

    spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

步骤 3：创建实体和仓库

  1. 创建一个实体类 BlogPost。

    package com.example.blog;

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

@Entity
public class BlogPost {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String title;
    private String content;
    // 省略 getter 和 setter
}

  2. 创建一个继承自 JpaRepository 的仓库接口 BlogPostRepository。

    package com.example.blog;

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

public interface BlogPostRepository extends JpaRepository<BlogPost, Long> {
}

步骤 4：创建服务类和控制器

  1. 创建一个服务类 BlogService 来处理业务逻辑。

    package com.example.blog;

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

@Service
public class BlogService {
    private final BlogPostRepository repository;

    @Autowired
    public BlogService(BlogPostRepository repository) {
        this.repository = repository;
    }

    public BlogPost saveBlogPost(BlogPost post) {
        return repository.save(post);
    }

    public List<BlogPost> getAllBlogPosts() {
        return repository.findAll();
    }
}

  2. 在 HelloController 中添加新的端点。

    package com.example.blog;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
public class BlogController {
    private final BlogService blogService;

    @Autowired
    public BlogController(BlogService blogService) {
        this.blogService = blogService;
    }

    @PostMapping("/posts")
    public BlogPost addBlogPost(@RequestBody BlogPost post) {
        return blogService.saveBlogPost(post);
    }

    @GetMapping("/posts")
    public List<BlogPost> getAllBlogPosts() {
        return blogService.getAllBlogPosts();
    }
}

步骤 5：运行和测试

  1. 运行应用程序。
  2. 使用 REST 客户端或浏览器访问 http://localhost:8080/posts 来查看所有博客文章，或通过 POST 请求向 /posts 添加新的博客文章。

通过这个案例，你将学会如何在 Spring Boot 应用中添加和配置数据库支持，创建实体和仓库，并通过服务类和控制器与数据库交互。这些步骤为构建具有数据持久化功能的应用提供了基础，使你的 Spring Boot 之旅更加丰富多彩。

2.1.4 拓展案例 2：整合外部服务

在这个案例中，我们将演示如何将外部服务整合到 Spring Boot 应用中。我们将以集成一个简单的邮件发送服务为例。

案例 Demo

假设我们的 Spring Boot 应用需要发送欢迎邮件给新注册的用户。

步骤 1：添加邮件服务依赖

  1. 在 pom.xml 中添加 spring-boot-starter-mail 依赖。

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

步骤 2：配置邮件服务器

  1. 在 application.properties 中配置邮件服务器的属性。这里我们以 Gmail 为例：

    spring.mail.host=smtp.gmail.com
spring.mail.port=587
spring.mail.username=your-email@gmail.com
spring.mail.password=your-password
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

步骤 3：创建邮件服务类

  1. 创建一个 EmailService 类来封装邮件发送逻辑。

    package com.example.blog;

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

@Service
public class EmailService {

    @Autowired
    private JavaMailSender mailSender;

    public void sendWelcomeEmail(String to, String username) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom("noreply@example.com");
        message.setTo(to);
        message.setSubject("Welcome to the Blog!");
        message.setText("Hello " + username + ",\nWelcome to our blog!");
        mailSender.send(message);
    }
}

步骤 4：在应用中使用邮件服务

  1. 创建一个控制器来使用 EmailService 发送邮件。

    package com.example.blog;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

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

    private final EmailService emailService;

    @Autowired
    public UserController(EmailService emailService) {
        this.emailService = emailService;
    }

    @PostMapping("/register")
    public String registerUser(@RequestParam String email, @RequestParam String username) {
        // 注册用户的逻辑...
        emailService.sendWelcomeEmail(email, username);
        return "User registered successfully!";
    }
}

步骤 5：运行和测试

  1. 运行你的 Spring Boot 应用。
  2. 使用 POST 请求向 /users/register 发送一个包含邮件地址和用户名的请求。
  3. 检查指定的邮箱，确认是否收到了欢迎邮件。

通过这个案例，你将学会如何在 Spring Boot 应用中集成外部服务，如邮件服务。这不仅增强了你的应用功能，还提高了用户体验。整合外部服务是构建现代应用的关键步骤，它能让你的应用更加丰富和动态。

2.2 集成 Spring Security

2.2.1 基础知识详解

集成 Spring Security 到你的 Spring Boot 应用中是一项关键任务，它保障了应用的安全性和数据保护。在此过程中，你将了解到 Spring Security 的核心概念和实现方法。

Spring Security 的核心组件

  1. 过滤器链（Filter Chains）:

    • Spring Security 使用一系列过滤器来处理不同的安全考虑。这些过滤器负责执行认证、授权等安全操作。

  2. 认证（Authentication）:

    • 认证是确认用户身份的过程。Spring Security 提供多种认证方式，如内存认证、数据库认证、LDAP 认证等。

  3. 授权（Authorization）:

    • 授权是控制已认证用户访问应用程序资源的过程。Spring Security 支持基于角色的访问控制（RBAC）和基于表达式的访问控制。

  4. 用户详情服务（UserDetailsService）:

    • UserDetailsService 接口用于根据用户名加载用户的数据。它通常用于从数据库中加载用户信息。

  5. 密码编码器（PasswordEncoder）:

    • Spring Security 强调对密码进行加密存储。PasswordEncoder 接口用于定义密码的加密方式。

Spring Security 的配置

  1. 创建 SecurityConfig 类:

    • 通过扩展 WebSecurityConfigurerAdapter 类并覆写其方法，你可以自定义应用程序的安全配置。

  2. 定义认证规则:

    • 在 configure(AuthenticationManagerBuilder auth) 方法中定义认证规则。

  3. 定义授权规则:

    • 在 configure(HttpSecurity http) 方法中定义哪些路径应该受保护，哪些路径应该公开访问。

  4. 自定义登录和注销:

    • Spring Security 允许自定义登录和注销行为，你可以指定登录页面、默认成功登录跳转路径等。

通过理解这些基础概念和配置步骤，你将能够为你的应用添加一个强大而灵活的安全层。这不仅保护了你的应用免受未经授权的访问，还为用户提供了安全的交互环境。

2.2.2 主要案例：基本的安全配置

在这个案例中，我们将通过一个实际的示例来展示如何在 Spring Boot 应用中实现基本的安全配置。

案例 Demo

我们将构建一个简单的博客应用，它允许用户查看文章列表，但只有注册用户才能查看文章详情。

步骤 1：配置安全依赖

  1. 在你的 Spring Boot 项目的 pom.xml 中添加 Spring Security 依赖：

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

步骤 2：创建安全配置类

  1. 创建一个新的 Java 类 SecurityConfig 并扩展 WebSecurityConfigurerAdapter。

    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("/", "/posts").permitAll()
            .antMatchers("/post/*").authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }
}

    在这里，我们配置了 URL 模式的安全性。任何人都可以访问主页 (/) 和文章列表 (/posts)，但只有认证用户可以访问文章详情（例如 /post/1）。

步骤 3：创建控制器

  1. 创建一个控制器 BlogController 来处理 HTTP 请求。

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

@Controller
public class BlogController {

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

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

    @GetMapping("/post/{id}")
    public String postDetails() {
        return "post-details";
    }

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

    这里，我们定义了不同的路由和它们对应的视图。

步骤 4：创建视图

  1. 创建相应的 HTML 文件（如 home.html, posts.html, post-details.html, login.html）在 src/main/resources/templates 目录下。

步骤 5：运行应用程序

  1. 运行你的 Spring Boot 应用。
  2. 在浏览器中访问 http://localhost:8080，尝试点击不同的链接，并观察安全配置的效果。

通过这个案例，你将学会如何在 Spring Boot 应用中添加基本的 Spring Security 配置。这样做不仅提高了应用的安全性，还为今后添加更复杂的安全功能奠定了基础。

2.2.3 拓展案例 1：数据库用户存储

在这个案例中，我们将展示如何在 Spring Boot 应用中使用数据库进行用户认证，这是实际生产环境中非常常见的场景。

案例 Demo

我们将创建一个简单的 Spring Boot 应用，其中用户信息存储在数据库中，并用于认证。

步骤 1：添加依赖

  1. 在 pom.xml 文件中添加 spring-boot-starter-data-jpa 和数据库依赖（这里我们使用 H2 数据库作为示例）。

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

步骤 2：配置数据源

  1. 在 application.properties 文件中配置 H2 数据库。

    spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

步骤 3：创建用户实体和仓库

  1. 创建用户实体 User。

    package com.example.demo;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class User {

    @Id
    private String username;
    private String password;
    private String role;

    // Getters and Setters
}

  2. 创建用户仓库接口 UserRepository。

    package com.example.demo;

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

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

步骤 4：实现 UserDetailsService

  1. 创建服务 CustomUserDetailsService 实现 UserDetailsService。

    package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class CustomUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    public User loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findById(username)
            .orElseThrow(() -> new UsernameNotFoundException("User not found"));
        return new User(user.getUsername(), passwordEncoder.encode(user.getPassword()), 
                       Collections.singletonList(new SimpleGrantedAuthority(user.getRole())));
    }
}

步骤 5：配置 Spring Security

  1. 修改 SecurityConfig 类，使用自定义的 UserDetailsService 和密码编码器。

    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Autowired
private CustomUserDetailsService userDetailsService;

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

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

步骤 6：运行和测试

  1. 启动 Spring Boot 应用。
  2. 通过 H2 Console 或其他方式添加用户数据到数据库。
  3. 尝试登录，验证用户认证是否工作正常。

通过此案例，你可以学习到如何在 Spring Boot 应用中结合数据库进行用户认证。这为你提供了一个更接近真实世界应用的安全配置方案。

2.2.4 拓展案例 2：OAuth2 集成

在这个案例中，我们将在 Spring Boot 应用中集成 OAuth2，允许用户使用第三方服务（如 Google, Facebook）进行登录，这是现代应用中常见的一种用户认证方式。

案例 Demo

我们的目标是创建一个 Spring Boot 应用，其中用户可以通过 Google 账户登录。

步骤 1：添加 OAuth2 客户端依赖

  1. 在 pom.xml 中添加 spring-boot-starter-oauth2-client 依赖。

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

步骤 2：配置 OAuth2 客户端

  1. 在 application.properties 或 application.yml 文件中配置 Google OAuth2 客户端信息。

    spring.security.oauth2.client.registration.google.client-id=your-google-client-id
spring.security.oauth2.client.registration.google.client-secret=your-google-client-secret
spring.security.oauth2.client.registration.google.scope=profile,email

    您需要在 Google Cloud Console 中创建 OAuth2.0 客户端 ID，以获取客户端 ID 和秘密。

步骤 3：安全配置

  1. 修改 SecurityConfig 类，以支持 OAuth2 登录。

    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
            .anyRequest().authenticated()
            .and()
        .oauth2Login();
}

步骤 4：创建控制器来处理登录后的操作

  1. 创建一个控制器来展示用户信息。

    import org.springframework.security.oauth2.core.user.OAuth2User;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/user")
    public String user(@AuthenticationPrincipal OAuth2User principal) {
        return "Welcome, " + principal.getAttribute("name");
    }
}

步骤 5：运行和测试

  1. 启动 Spring Boot 应用。
  2. 访问 http://localhost:8080/user。
  3. 应用将重定向到 Google 的登录页面。使用 Google 账户登录。
  4. 登录成功后，应显示欢迎消息和用户信息。

通过这个案例，您可以了解到如何在 Spring Boot 应用中实现 OAuth2 集成，使用户可以通过第三方服务进行身份验证，从而提供更加流畅和安全的用户体验。这种认证方式广泛应用于现代网页和移动应用中。

2.3 测试你的配置

在集成了 Spring Security 后，测试你的配置是确保一切按预期工作的重要步骤。这不仅关乎安全性，也关乎功能的正确实现。

2.3.1 基础知识详解

在集成了 Spring Security 后，测试你的配置是确保一切按预期工作的重要步骤。这部分不仅关乎安全性，也涉及到功能性的正确实现。

重要的测试概念

  1. 安全性测试:

    • 确认认证（Authentication）和授权（Authorization）机制按预期工作。
    • 验证不同用户角色的访问权限是否正确实现。

  2. 端点测试:

    • 测试不同的 API 端点以确保安全配置正确，例如，某些端点应仅对认证用户开放。

  3. 测试类型:

    • 单元测试: 测试单个方法或类的功能。
    • 集成测试: 测试多个组件协同工作的情况。
    • 端到端测试: 测试整个应用程序的工作流程。

  4. 测试工具:

    • JUnit: Java 程序员最常用的单元测试框架。
    • MockMvc: 用于模拟 MVC 测试，可以模拟发送 HTTP 请求并验证结果。
    • Spring Security Test: 提供了一系列用于测试 Spring Security 配置的工具。

如何进行有效的安全性测试

  1. 模拟认证用户: 使用测试工具模拟不同角色的用户，以测试他们的访问权限。
  2. 测试受保护的资源: 验证受保护的资源（如 API 端点）是否仅对具有适当权限的用户开放。
  3. 测试登录流程: 确保登录流程按预期工作，包括错误处理。
  4. CSRF 防护测试: 如果应用启用了 CSRF 防护，应进行相应的测试以确保其有效性。

通过这些测试，你可以保证你的 Spring Security 配置既安全又高效，为用户提供了必要的保护，同时不会干扰应用程序的正常功能。测试是任何安全配置不可或缺的一部分，它确保了安全措施的有效性和应用的健壮性。

2.3.2 主要案例：测试基本的安全配置

在这个案例中，我们将通过一个实际的示例来测试在 Spring Boot 应用中集成的基本 Spring Security 配置。

案例 Demo

假设我们的 Spring Boot 应用有两个主要端点：一个公开的主页 (/) 和一个受保护的用户页面 (/user)。我们将编写测试来验证安全配置是否按预期工作。

步骤 1：添加测试依赖

  1. 在 pom.xml 文件中添加以下依赖，以支持测试：

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

步骤 2：编写测试类

  1. 创建一个测试类 WebSecurityConfigTest。

    package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class WebSecurityConfigTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void accessPublic() throws Exception {
        mockMvc.perform(get("/"))
                .andExpect(status().isOk());
    }

    @Test
    public void accessPrivateUnauthenticated() throws Exception {
        mockMvc.perform(get("/user"))
                .andExpect(status().isUnauthorized());
    }
}

    在这里，我们使用 MockMvc 来模拟发送 HTTP 请求到不同的端点，并验证响应的状态码。我们期望公开页面返回 200 OK 状态，而未经认证的访问受保护的 /user 端点应返回 401 Unauthorized 状态。

步骤 3：运行测试

  1. 在 IDE 中运行测试类或使用 Maven/Gradle 命令行工具来执行测试。
  2. 检查测试结果，确认安全配置是否按预期工作。

通过这个案例，你可以验证你的 Spring Security 配置是否正确实现了基本的认证和授权。这种测试是确保应用安全性的重要步骤，能帮助你捕获潜在的安全问题和配置错误。

2.3.3 ### 拓展案例 1：测试数据库用户存储

在这个案例中，我们将测试 Spring Boot 应用中使用数据库进行用户认证的配置。假设我们的应用使用数据库来存储用户信息，并基于这些信息进行认证。

案例 Demo

假设我们已经有一个集成了数据库用户存储的 Spring Boot 应用，现在我们需要编写测试来验证用户认证功能。

步骤 1：配置测试数据库

  1. 在 src/test/resources 目录下创建一个 application.properties 文件，配置用于测试的数据库信息（使用 H2 数据库作为示例）。

    spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

步骤 2：添加测试依赖

  1. 确保在 pom.xml 中已经添加了 spring-boot-starter-test 和 h2 数据库的依赖。

    <!-- Test dependencies -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope>
</dependency>

步骤 3：编写测试类

  1. 创建一个测试类 UserAuthenticationTest。

    package com.example.demo;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class UserAuthenticationTest {

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @BeforeEach
    public void setup() {
        User user = new User();
        user.setUsername("testuser");
        user.setPassword(passwordEncoder.encode("password"));
        user.setRole("USER");
        userRepository.save(user);
    }

    @Test
    public void authenticateWithValidUser() throws Exception {
        mockMvc.perform(post("/login")
                .param("username", "testuser")
                .param("password", "password"))
                .andExpect(status().isOk());
    }

    @Test
    public void authenticateWithInvalidUser() throws Exception {
        mockMvc.perform(post("/login")
                .param("username", "invaliduser")
                .param("password", "password"))
                .andExpect(status().isUnauthorized());
    }
}

    在这里，我们使用 MockMvc 来模拟登录请求，并验证不同用户（有效和无效）的认证结果。

步骤 4：运行测试

  1. 在 IDE 中运行测试类或使用 Maven/Gradle 命令行工具来执行测试。
  2. 检查测试结果，确认数据库用户存储和认证是否按预期工作。

通过这个案例，你可以确保你的 Spring Boot 应用中的用户认证机制（基于数据库存储）按预期运行，从而提高应用的安全性和可靠性。

2.3.4 拓展案例 2：测试 OAuth2 集成

在这个案例中，我们将演示如何测试 Spring Boot 应用中的 OAuth2 集成，确保第三方登录（如 Google OAuth2）按预期工作。

案例 Demo

假设我们的 Spring Boot 应用已经集成了 Google OAuth2 登录。我们需要编写测试来验证 OAuth2 流程。

步骤 1：添加测试依赖

  1. 确保在 pom.xml 中添加了 spring-boot-starter-test 依赖。

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

步骤 2：配置 OAuth2 测试

  1. 在测试配置中（src/test/resources/application.properties），添加用于测试的 OAuth2 配置。

    spring.security.oauth2.client.registration.google.client-id=test-client-id
spring.security.oauth2.client.registration.google.client-secret=test-client-secret

步骤 3：编写测试类

  1. 创建一个测试类 OAuth2LoginTest。

    package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.redirectedUrlPattern;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class OAuth2LoginTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    @WithMockUser
    public void requestProtectedUrlWithUser() throws Exception {
        mockMvc.perform(get("/user"))
                .andExpect(status().isOk());
    }

    @Test
    public void requestProtectedUrlWithoutUser() throws Exception {
        mockMvc.perform(get("/user"))
                .andExpect(status().is3xxRedirection())
                .andExpect(redirectedUrlPattern("**/oauth2/authorization/google"));
    }
}

    这里我们使用 WithMockUser 来模拟一个已认证的用户，以测试受保护的 URL 访问。同时，我们测试未认证用户访问受保护 URL 时的重定向行为。

步骤 4：运行测试

  1. 在 IDE 中运行测试类或使用 Maven/Gradle 命令行工具来执行测试。
  2. 检查测试结果，确认 OAuth2 集成是否按预期工作。

通过这个案例，你可以确保你的应用中的 OAuth2 集成正确实现了第三方登录流程，提供了有效的用户认证机制。这对于提供一个安全、便捷的用户登录体验至关重要。

江帅帅
关注
专栏目录
上古掌控安全的神-零:Spring Security5.x到Spring Security6.x的迁移
八尺妖剑的博客
04-20 1385
之前有写过一篇关于的文章，但那已经是相对比较旧的版本了，就目前来说，这其中出现了不少的变动和更新，很多API的使用也是有不小的变化，所以我觉得有必要再写几篇文章学习一下，是的，不是一篇，是几篇，下面是初步的写作计划。《上古掌控安全的神-壹:Spring Security6.0+版本初探》《上古掌控安全的神-贰:Spring Security6.0+版本再探》《上古掌控安全的神-叁:Spring Security6.0+版本认证实践》
SpringSecurity
qq_27295923的博客
09-05 768
SpringBoot下使用SpringSecurity （一）基本 1．SpringSecurityJWT学习博客 https://blog.csdn.net/larger5/article/details/81047869 https://blog.csdn.net/larger5/article/details/81063438 2．设置不需要登录就能访问接口 在SpringSecurityC...
全新版本Spring Security使用
BUG指挥课堂
07-11 1832
SpringBoot实战电商项目mall（50k+star）地址：github.com/macrozheng/…首先修改项目的文件，把Spring Boot版本升级至版本。 旧用法 在Spring Boot 2.7.0 之前的版本中，我们需要写个配置类继承，然后重写Adapter中的三个方法进行配置； 如果你在SpringBoot 2.7.0版本中进行使用的话，你就会发现已经被弃用了，看样子Spring Security要坚决放弃这种用法了！ 新用法非常简单，无需再继承，只需直接声明配置类，再配置
Spring Security 新版本配置
weixin_46073538的博客
06-30 3544
Springsecurity最新版配置
新版SpringSecurity5.x使用与配置
Alphamilk的博客
07-21 1762
了解SpringSecurity，并进行简单使用与配置
SpringBoot最新版本Security配置(2023年)，亲测成功
ns3405453840的博客
05-12 3295
application.properties SecurityConfig: 配置默认登录用户(即用数据库的用户和密码登录)： 1:UserDetailsServiceImpl 2：UserDetailsImpl: 3:配置完，记得更改SecurityConfig配置,添加前端密码加密验证， 这里就可以使用security自带登录对数据库信息进行验证登录了通过该工具类根据用户id生成jwt
新版SpringSecurity配置（SpringBoot＞2.7&SpringSecurity＞5.7）
钟健的博客
05-17 1万+
在使用或者以上版本时，会提示：在 Spring Security 5.7.0-M2 中，我们弃用了，因为我们鼓励用户转向基于组件的安全配置。所以之前那种通过继承的方式的配置组件是不行的。同时也会遇到很多问题，例如：在向SpringSecurity过滤器链中添加过滤器时（例如：JWT支持，第三方验证），我们需要注入对象等问题。
入门到精通：SpringBoot2和SpringSecurity5视频教程
06-11
《入门到精通：SpringBoot2和SpringSecurity5视频教程》是一个全面涵盖这两个核心Java技术的教育资源，旨在帮助初学者和有一定经验的开发者深入理解和掌握SpringBoot 2和Spring Security 5的使用。SpringBoot是...
spring-security
06-26
Spring Security 可以通过XML配置、Java配置或者注解配置来设置。Java配置和注解配置使得代码更加简洁易懂，更符合现代开发习惯。 **三、主要组件** 1. **AuthenticationManager**：负责处理认证请求，通常由...
Spring Security 5.7 最新配置细节（直接就能用），WebSecurityConfigurerAdapter 已废弃
热门推荐
江帅帅
06-06 3万+
Spring Security 5.7.1 最新配置细节，WebSecurityConfigurerAdapter 已废弃
Spring Security3.1最新配置实例
05-16
基于struts2 hibernate Spring Security3的权限配置。详情可以关注我的博客。
spring-security的简单配置
qq_43352316的博客
07-27 690
简单配置
SpringSecurity最新版从入门到精通，WebSecurityConfigurerAdapter已经过时？最新版来了。
qq_42713539的博客
03-25 3634
spring security的超详细配置和使用攻略，包括从登录校验开始到不同页面、不同功能的权限管理，包括了整合thymeleaf框架、用户登录信息持久化处理、csrf防护等web安全。
SpringSecurity配置及使用
qq_52183856的博客
02-02 617
SpringSecurity配置及使用
SpringSecurity服务器端配置说明
makaixuan_的博客
08-23 981
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zMldYDBl-1661221320914)(…/AppData/Roaming/Typora/typora-user-images/)]此时登录另一个客户端8082，确认是否也已经授权，免登录了。成功登录自己服务器的首页（user:zhangsan）授权认证成功后跳转到指定客户端的页面。点击登录（成功登录到8081客户端）成功登录到8082，点击登录。登录到8080自己服务器的。到服务器端的认证系统。...
【Spring Boot】配置 Spring Security
最新发布
书山有路，学海无涯。记录成长，追逐梦想
08-02 1642
Spring Security 提供了声明式的安全访问控制解决方案（仅支持基于 Spring 的应用程序），对访问权限进行认证和授权，它基于 Spring AOP 和 Servlet 过滤器，提供了安全性方面的全面解决方案。
SpringSecurity安全框架（配置类版）
武汉小喽啰
07-18 3322
1. 前言 1.1SpringSecurity 框架用法简介 用户登录系统时我们协助 SpringSecurity 把用户对应的角色、权限组装好，同时把各个 资源所要求的权限信息设定好，剩下的“登录验证”、“权限验证”等等工作都交给 SpringSecurity 1.2权限管理过程中的相关概念 1.2.1 主体 英文单词：principal 使用系统的用户或设备或从其他系统远程登录的用户等等。简单说就是谁使用系统 谁就是主体 1.2.2认...
SpringBoot中SpringSecurity安全框架的基本配置与使用
qq_57587177的博客
09-17 1085
SpringSecurity安全框架的使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

江帅帅

“ 能吃个烧鸡腿么 ”

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值