脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Spring Boot  SAML单点登录

Spring Boot 基于 SAML 实现单点登录原理解析

 更新时间：2025年06月13日 10:03:19   作者：一切皆有迹可循  
基于SAML在 Spring Boot 中实现单点登录虽然有一定的复杂度,但能为企业级应用带来强大的身份验证和授权功能,本文将详细介绍在 Spring Boot中基于SAML实现单点登录的原理、方式、优缺点及注意事项,并给出具体代码示例,感兴趣的朋友一起看看吧

前言

在企业级应用开发中，单点登录（SSO）能显著提升用户体验和系统安全性。安全断言标记语言（SAML）作为一种广泛应用的 XML 标准，可在不同安全域之间交换身份验证和授权数据。本文将详细介绍在 Spring Boot 中基于 SAML 实现单点登录的原理、方式、优缺点及注意事项，并给出具体代码示例。

一、SAML 实现单点登录原理

1.1 SAML 基本概念

SAML 定义了三种主要角色：身份提供者（IdP）、服务提供者（SP）和用户。IdP 负责验证用户身份，SP 是用户请求访问的应用，用户则是使用系统的个体。SAML 通过断言（Assertion）来传递身份验证和授权信息。

1.2 单点登录流程

  • 用户访问 SP：用户尝试访问 SP 的受保护资源，若未认证，SP 生成 SAML 请求。
  • 重定向到 IdP：SP 将用户重定向到 IdP 的登录页面，并附带 SAML 请求。
  • 用户登录 IdP：用户在 IdP 输入凭据进行身份验证。
  • IdP 生成 SAML 断言：验证通过后，IdP 创建包含用户身份和授权信息的 SAML 断言。
  • 返回 SAML 响应：IdP 将 SAML 响应（包含断言）发送给 SP。
  • SP 验证 SAML 响应：SP 验证响应的签名和内容，若有效则创建本地会话，允许用户访问资源。

二、Spring Boot 基于 SAML 实现单点登录的方式

2.1 准备工作

创建 Spring Boot 项目，在 pom.xml 中添加必要依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.extensions</groupId>
        <artifactId>spring-security-saml2-core</artifactId>
        <version>1.0.10.RELEASE</version>
    </dependency>
</dependencies>

2.2 配置 SAML

创建 SAMLConfig 类来配置 SAML 相关信息：

import org.opensaml.saml2.metadata.provider.MetadataProvider;
import org.opensaml.saml2.metadata.provider.MetadataProviderException;
import org.opensaml.saml2.metadata.provider.ResourceBackedMetadataProvider;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
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.saml.SAMLAuthenticationProvider;
import org.springframework.security.saml.SAMLBootstrap;
import org.springframework.security.saml.SAMLEntryPoint;
import org.springframework.security.saml.SAMLLogoutFilter;
import org.springframework.security.saml.SAMLLogoutProcessingFilter;
import org.springframework.security.saml.SAMLProcessingFilter;
import org.springframework.security.saml.context.SAMLContextProviderImpl;
import org.springframework.security.saml.key.JKSKeyManager;
import org.springframework.security.saml.metadata.CachingMetadataManager;
import org.springframework.security.saml.metadata.ExtendedMetadata;
import org.springframework.security.saml.metadata.ExtendedMetadataDelegate;
import org.springframework.security.saml.parser.ParserPoolHolder;
import org.springframework.security.saml.util.VelocityFactory;
import org.springframework.security.saml.websso.WebSSOProfileConsumer;
import org.springframework.security.saml.websso.WebSSOProfileConsumerImpl;
import org.springframework.security.saml.websso.WebSSOProfileOptions;
import org.springframework.security.web.authentication.SavedRequestAwareAuthenticationSuccessHandler;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
import org.springframework.security.web.authentication.logout.LogoutHandler;
import org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler;
import org.springframework.security.web.authentication.logout.SimpleUrlLogoutSuccessHandler;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@Configuration
@EnableWebSecurity
public class SAMLConfig extends WebSecurityConfigurerAdapter {
    @Bean
    public SAMLBootstrap sAMLBootstrap() {
        return new SAMLBootstrap();
    }
    @Bean
    public SAMLEntryPoint samlEntryPoint() {
        WebSSOProfileOptions webSSOProfileOptions = new WebSSOProfileOptions();
        webSSOProfileOptions.setIncludeScoping(false);
        SAMLEntryPoint samlEntryPoint = new SAMLEntryPoint();
        samlEntryPoint.setDefaultProfileOptions(webSSOProfileOptions);
        return samlEntryPoint;
    }
    @Bean
    public SAMLProcessingFilter samlWebSSOProcessingFilter() throws Exception {
        SAMLProcessingFilter samlWebSSOProcessingFilter = new SAMLProcessingFilter();
        samlWebSSOProcessingFilter.setAuthenticationManager(authenticationManager());
        samlWebSSOProcessingFilter.setAuthenticationSuccessHandler(successRedirectHandler());
        samlWebSSOProcessingFilter.setAuthenticationFailureHandler(authenticationFailureHandler());
        return samlWebSSOProcessingFilter;
    }
    @Bean
    public SavedRequestAwareAuthenticationSuccessHandler successRedirectHandler() {
        SavedRequestAwareAuthenticationSuccessHandler successRedirectHandler = new SavedRequestAwareAuthenticationSuccessHandler();
        successRedirectHandler.setDefaultTargetUrl("/");
        return successRedirectHandler;
    }
    @Bean
    public SimpleUrlAuthenticationFailureHandler authenticationFailureHandler() {
        SimpleUrlAuthenticationFailureHandler failureHandler = new SimpleUrlAuthenticationFailureHandler();
        failureHandler.setUseForward(true);
        failureHandler.setDefaultFailureUrl("/error");
        return failureHandler;
    }
    @Bean
    public SAMLAuthenticationProvider samlAuthenticationProvider() {
        SAMLAuthenticationProvider samlAuthenticationProvider = new SAMLAuthenticationProvider();
        samlAuthenticationProvider.setUserDetails(samlUserDetailsService());
        samlAuthenticationProvider.setForcePrincipalAsString(false);
        return samlAuthenticationProvider;
    }
    @Bean
    public SAMLUserDetailsService samlUserDetailsService() {
        return new SAMLUserDetailsService();
    }
    @Bean
    public CachingMetadataManager metadata() throws MetadataProviderException {
        List<MetadataProvider> providers = Collections.singletonList(idpMetadata());
        return new CachingMetadataManager(providers);
    }
    @Bean
    public ExtendedMetadataDelegate idpMetadata() throws MetadataProviderException {
        ResourceBackedMetadataProvider provider = new ResourceBackedMetadataProvider(
                () -> new ClassPathResource("/idp-metadata.xml").getInputStream(),
                ParserPoolHolder.getPool());
        ExtendedMetadata extendedMetadata = new ExtendedMetadata();
        extendedMetadata.setIdpDiscoveryEnabled(false);
        return new ExtendedMetadataDelegate(provider, extendedMetadata);
    }
    @Bean
    public WebSSOProfileConsumer webSSOprofileConsumer() {
        return new WebSSOProfileConsumerImpl();
    }
    @Bean
    public JKSKeyManager keyManager() {
        java.util.Map<String, String> passwords = Collections.singletonMap("apollo", "apollo");
        return new JKSKeyManager(new ClassPathResource("samlKeystore.jks"), passwords, "apollo");
    }
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
               .httpBasic().disable()
               .csrf().disable()
               .addFilterBefore(samlMetadataFilter(), BasicAuthenticationFilter.class)
               .addFilterAfter(samlWebSSOProcessingFilter(), BasicAuthenticationFilter.class)
               .addFilterBefore(samlLogoutProcessingFilter(), BasicAuthenticationFilter.class)
               .addFilterBefore(samlLogoutFilter(), BasicAuthenticationFilter.class)
               .authorizeRequests()
               .antMatchers("/saml/**").permitAll()
               .anyRequest().authenticated()
               .and()
               .exceptionHandling()
               .authenticationEntryPoint(samlEntryPoint());
    }
    @Bean
    public SAMLLogoutProcessingFilter samlLogoutProcessingFilter() {
        return new SAMLLogoutProcessingFilter(logoutSuccessHandler(), new SecurityContextLogoutHandler());
    }
    @Bean
    public SAMLLogoutFilter samlLogoutFilter() {
        return new SAMLLogoutFilter(logoutSuccessHandler(),
                new LogoutHandler[]{logoutHandler()},
                new LogoutHandler[]{logoutHandler()});
    }
    @Bean
    public SimpleUrlLogoutSuccessHandler logoutSuccessHandler() {
        SimpleUrlLogoutSuccessHandler successHandler = new SimpleUrlLogoutSuccessHandler();
        successHandler.setDefaultTargetUrl("/");
        return successHandler;
    }
    @Bean
    public LogoutHandler logoutHandler() {
        SecurityContextLogoutHandler logoutHandler = new SecurityContextLogoutHandler();
        logoutHandler.setInvalidateHttpSession(true);
        logoutHandler.setClearAuthentication(true);
        return logoutHandler;
    }
    @Bean
    public SAMLMetadataFilter samlMetadataFilter() {
        return new SAMLMetadataFilter(metadata(), new ExtendedMetadata());
    }
}

2.3 创建用户详情服务

创建 SAMLUserDetailsService 类来处理用户信息：

import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.saml.SAMLUserDetailsService;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Collection;
@Service
public class SAMLUserDetailsService implements SAMLUserDetailsService {
    @Override
    public UserDetails loadUserBySAML(org.opensaml.saml2.core.Assertion assertion) {
        String username = assertion.getSubject().getNameID().getValue();
        Collection<GrantedAuthority> authorities = new ArrayList<>();
        authorities.add(new SimpleGrantedAuthority("ROLE_USER"));
        return new User(username, "", authorities);
    }
}

2.4 提供受保护资源

创建一个简单的控制器来提供受保护的资源：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class ProtectedResourceController {
    @GetMapping("/protected")
    public String protectedResource() {
        return "This is a protected resource accessed via SAML SSO.";
    }
}

三、优缺点分析

3.1 优点

  • 企业级支持：SAML 是为企业环境设计的，众多企业级应用和服务都支持 SAML，方便企业内部不同系统之间的集成。
  • 安全性高：使用 XML 格式的断言进行身份验证和授权，支持数字签名和加密，能有效防止信息篡改和伪造。
  • 标准化程度高：作为开放标准，具有良好的互操作性和兼容性，不同厂商的系统之间可以方便地进行集成。

3.2 缺点

  • 实现复杂度高：涉及复杂的 XML 格式和协议规范，开发者需要对 SAML 有深入的理解，实现难度较大。
  • 配置繁琐：需要处理大量的元数据，包括服务提供商和身份提供商的元数据，配置过程容易出错。

四、需要注意的问题和难点

4.1 元数据管理

元数据包含了 SP 和 IdP 的配置信息，如端点 URL、证书等。需要确保元数据的准确性和及时性，并且在元数据发生变化时及时更新。

4.2 证书管理

SAML 中使用证书进行签名和加密，需要妥善管理证书的生成、存储和更新。确保证书的有效期和安全性，防止证书泄露导致的安全问题。

4.3 错误处理

在 SAML 交互过程中，可能会出现各种错误，如签名验证失败、断言过期等。需要实现完善的错误处理机制，向用户提供明确的错误信息。

4.4 兼容性问题

不同的 IdP 和 SP 可能对 SAML 标准的实现存在细微差异，需要进行充分的测试，确保在不同的环境下都能正常工作。

结语

基于 SAML 在 Spring Boot 中实现单点登录虽然有一定的复杂度，但能为企业级应用带来强大的身份验证和授权功能。通过本文的介绍，你了解了 SAML 单点登录的原理、实现方式、优缺点以及需要注意的问题。在实际应用中，要根据具体需求和场景进行合理配置和优化，以确保系统的安全性和稳定性。

到此这篇关于Spring Boot 基于 SAML 实现单点登录原理解析的文章就介绍到这了,更多相关Spring Boot  SAML单点登录内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Spring框架中@Lazy延迟加载原理和使用详解

    Spring框架中@Lazy延迟加载原理和使用详解

    这篇文章主要介绍了Spring框架中@Lazy延迟加载原理和使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2025-05-05
  • java 服务器接口快速开发之servlet详细教程

    java 服务器接口快速开发之servlet详细教程

    Servlet(Server Applet)是Java Servlet的简称，称为小服务程序或服务连接器，用Java编写的服务器端程序，具有独立于平台和协议的特性，主要功能在于交互式地浏览和生成数据，生成动态Web内容
    2021-06-06
  • 浅谈spring ioc的注入方式及注入不同的数据类型

    浅谈spring ioc的注入方式及注入不同的数据类型

    这篇文章主要介绍了浅谈spring ioc的注入方式及注入不同的数据类型，具有一定借鉴价值,需要的朋友可以参考下
    2017-12-12
  • Spring boot实现文件上传实例（多文件上传)

    Spring boot实现文件上传实例（多文件上传)

    本篇文章主要介绍了Spring boot实现文件上传实例（多文件上传)，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-05-05
  • java BigDecimal精度丢失及常见问分析

    java BigDecimal精度丢失及常见问分析

    这篇文章主要为大家介绍了java BigDecimal精度丢失及常见问分析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-02-02
  • 详解java中import的作用

    详解java中import的作用

    这篇文章主要介绍了java中import作用，import与package机制相关，这里先从package入手，再讲述import以及static import的作用。
    2021-04-04
  • Java日常练习题,每天进步一点点(20)

    Java日常练习题,每天进步一点点(20)

    下面小编就为大家带来一篇Java基础的几道练习题(分享)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧，希望可以帮到你
    2021-07-07
  • ToStringBuilder类的一些心得

    ToStringBuilder类的一些心得

    ToStringBuilder类的一些心得,需要的朋友可以参考一下
    2013-02-02
  • jmeter正则表达式的使用

    jmeter正则表达式的使用

    在jmeter中,可以利用正则表达式提取器来帮助我们完成这一动作，本文就详细的介绍一下应该如何使用，感兴趣的可以了解一下
    2021-11-11
  • Spark SQL 编程初级实践详解

    Spark SQL 编程初级实践详解

    这篇文章主要为大家介绍了Spark SQL 编程初级实践详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-04-04

最新评论