SpringSecurity6数据库认证配置详解

最近发现不少小伙伴都对文章很感兴趣，所以今天继续给大家介绍文章相关的知识，本文《Spring Security 6 外部数据库认证实现》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

本文详细介绍了如何在 Spring Security 6 中集成外部数据库进行用户认证。核心在于实现自定义的 UserDetailsService 接口，并通过注入数据访问对象（如 Repository 或 DAO）来从外部数据库获取用户凭据。文章将提供清晰的代码示例，涵盖 UserDetailsService 实现、PasswordEncoder 配置以及 SecurityFilterChain 的集成，帮助开发者顺利实现基于外部数据库的认证机制。

1. Spring Security 6 认证机制概述

Spring Security 6 引入了更现代的配置方式，移除了 WebSecurityConfigurerAdapter，转而推荐使用组件化的 SecurityFilterChain Bean 来定义安全规则。尽管配置方式有所变化，但其核心的认证流程依然依赖于 UserDetailsService 接口来加载用户详情，并结合 PasswordEncoder 进行密码校验。这意味着，即使使用外部数据库存储用户凭据，我们仍然需要实现 UserDetailsService 来桥接 Spring Security 与数据库。

2. 核心概念：UserDetailsService

UserDetailsService 是 Spring Security 中一个至关重要的接口，它负责根据用户名查找用户的详细信息。当用户尝试登录时，Spring Security 会调用 UserDetailsService 的 loadUserByUsername(String username) 方法来获取与该用户名关联的用户数据，包括用户名、密码以及权限/角色列表。

为了从外部数据库加载用户，我们需要实现这个接口，并在其中注入一个数据访问对象（DAO 或 Repository），该对象负责与数据库进行实际交互，查询用户数据。

3. 实现自定义 UserDetailsService

首先，定义一个简单的用户实体类，用于表示从数据库中获取的用户信息：

// User.java
package com.example.model;

import java.util.List;

public class User {
    private String username;
    private String password; // 存储加密后的密码
    private List<String> roles;

    public User(String username, String password, List<String> roles) {
        this.username = username;
        this.password = password;
        this.roles = roles;
    }

    // Getters and Setters
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public List<String> getRoles() { return roles; }
    public void setRoles(List<String> roles) { this.roles = roles; }
}

接下来，实现 UserDetailsService 接口。在这个实现中，我们将注入一个 UserRepository 来模拟从外部数据库获取用户数据。

// MyUserDetailsService.java
package com.example.security;

import com.example.model.User;
import com.example.repository.UserRepository;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

@Service
public class MyUserDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    public MyUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 从外部数据库获取用户数据
        User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new UsernameNotFoundException("User not found with username: " + username));

        // 将自定义的用户对象转换为 Spring Security 要求的 UserDetails 对象
        List<SimpleGrantedAuthority> authorities = user.getRoles().stream()
                .map(role -> new SimpleGrantedAuthority("ROLE_" + role)) // Spring Security 角色前缀通常为 "ROLE_"
                .collect(Collectors.toList());

        return new org.springframework.security.core.userdetails.User(
                user.getUsername(),
                user.getPassword(),
                authorities
        );
    }
}

4. 数据访问层 (DAO/Repository) 示例

UserRepository 是一个接口，定义了与数据库交互的方法。这里我们使用一个简单的接口，并假设其背后可以通过 JPA、JdbcTemplate 或其他方式连接到外部数据库。

// UserRepository.java
package com.example.repository;

import com.example.model.User;
import java.util.Optional;
import org.springframework.stereotype.Repository;

// 这是一个示例接口，实际实现会与数据库交互
@Repository
public interface UserRepository {
    Optional<User> findByUsername(String username);
}

为了演示，我们可以提供一个简单的内存实现来模拟数据库访问。在实际项目中，这部分应替换为与实际数据库交互的代码，例如使用 Spring Data JPA 或 JdbcTemplate。

// InMemoryUserRepositoryImpl.java (用于演示，实际项目中应连接数据库)
package com.example.repository;

import com.example.model.User;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

@Component
public class InMemoryUserRepositoryImpl implements UserRepository {

    private final Map<String, User> users = new HashMap<>();

    public InMemoryUserRepositoryImpl() {
        // 模拟数据库中的用户数据，密码应为加密后的形式
        // 这里使用 {noop} 前缀表示不进行密码编码，仅用于演示。
        // 生产环境中请务必使用强密码编码器，例如 BCryptPasswordEncoder。
        users.put("schueler", new User("schueler", "{noop}password", Arrays.asList("SCHUELER")));
        users.put("lehrer", new User("lehrer", "{noop}password", Arrays.asList("LEHRER")));
        users.put("verwaltung", new User("verwaltung", "{noop}password", Arrays.asList("VERWALTUNG")));
    }

    @Override
    public Optional<User> findByUsername(String username) {
        return Optional.ofNullable(users.get(username));
    }
}

注意：在生产环境中，InMemoryUserRepositoryImpl 应被替换为实际与外部数据库交互的实现，例如使用 Spring Data JPA 或 JdbcTemplate。

5. 配置 Spring Security 6

在 Spring Security 6 中，UserDetailsService 和 PasswordEncoder 作为 Spring Bean 存在，Spring Security 会自动发现并使用它们。因此，我们只需要在 SecurityConfiguration 中定义 SecurityFilterChain 即可。

// SecurityConfiguration.java
package com.example.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.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                .authorizeHttpRequests((requests) -> requests
                        .requestMatchers("/vertretungsplan").hasAnyRole("SCHUELER", "LEHRER", "VERWALTUNG")
                        .requestMatchers("/account").hasAnyRole("LEHRER", "VERWALTUNG")
                        .requestMatchers("/administration").hasRole("VERWALTUNG")
                        .requestMatchers("/", "/login", "/error").permitAll() // 允许访问根路径、登录页和错误页
                        .anyRequest().authenticated() // 其他所有请求都需要认证
                )
                .formLogin(form -> form
                        .loginPage("/login") // 指定自定义登录页面的URL
                        .defaultSuccessUrl("/home", true) // 登录成功后的跳转页面
                        .permitAll() // 允许所有用户访问登录页面
                )
                .logout(logout -> logout
                        .logoutSuccessUrl("/login?logout") // 登出成功后的跳转页面
                        .permitAll()
                );
        return http.build();
    }

    /**
     * 配置密码编码器。
     * Spring Security 会自动发现这个 PasswordEncoder Bean 并用于密码验证。
     * 强烈推荐使用 BCryptPasswordEncoder 或其他安全的密码编码器。
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

重要提示：

• 在 InMemoryUserRepositoryImpl 中，我们为了演示使用了 {noop} 前缀。但在实际应用中，User 实体中的密码应始终存储为经过 PasswordEncoder 加密后的密文。例如，如果使用 BCryptPasswordEncoder，则在保存用户到数据库时，密码需要先经过 BCryptPasswordEncoder.encode() 方法处理。
• MyUserDetailsService 中返回的 org.springframework.security.core.userdetails.User 对象的密码，必须是数据库中存储的加密后的密码。Spring Security 会使用配置的 PasswordEncoder 来比较用户输入的密码和 UserDetails 中提供的密码。

6. 注意事项与最佳实践

1. 密码编码器 (PasswordEncoder)：
   • 始终使用强密码编码器，如 BCryptPasswordEncoder。切勿在生产环境中使用 NoOpPasswordEncoder 或明文密码。
   • 确保在用户注册或更新密码时，将密码通过 PasswordEncoder 进行编码后再存入数据库。
2. 数据库连接配置：
   • 在 application.properties 或 application.yml 中配置数据库连接信息，例如 spring.datasource.url, `spring.

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。