Spring Security 单点登录与自动登录机制的实现原理

更新时间：2025年07月26日 16:36:12 作者：从零开始学习人工智能

本文探讨SpringSecurity实现单点登录（SSO）与自动登录机制,涵盖JWT跨系统认证、RememberMe持久化Token存储、安全工具类及最佳实践,强调安全性与性能平衡对提升用户体验的重要性,感兴趣的朋友一起看看吧

一、核心概念解析

1.1 单点登录（SSO）

单点登录是指用户只需要登录一次，就可以访问所有相互信任的应用系统。

1.2 自动登录（Remember Me）

自动登录是指用户在一定时间内无需重复输入用户名密码即可自动完成身份认证。

二、代码分析

让我们先分析一下提供的代码片段：

// 1. 手动查询用户
SysUser sysUser = userService.selectUserByUserName(username);
if (sysUser == null) {
    throw new UsernameNotFoundException("用户不存在");
}
// 3. 查询权限
Set<String> permissions = sysPermissionService.getMenuPermission(sysUser);
// 4. 构造LoginUser对象
LoginUser loginUser = new LoginUser(sysUser.getUserId(),sysUser.getDeptId(),sysUser, permissions);
// 4. 构造已认证的Authentication对象
authentication = new UsernamePasswordAuthenticationToken(
        loginUser,           // principal - 这里传递的是完整的LoginUser对象
        null,                // credentials
        loginUser.getAuthorities() // authorities
);
// 5. 设置到Security上下文
SecurityContextHolder.getContext().setAuthentication(authentication);
Long userId = SecurityUtils.getUserId();

这段代码展示了手动构建认证信息的核心流程。

三、单点登录实现方案

3.1 基于JWT的SSO实现

@Component
public class JwtTokenProvider {
    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;
    public String generateToken(LoginUser loginUser) {
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + expiration);
        return Jwts.builder()
                .setSubject(loginUser.getUsername())
                .claim("userId", loginUser.getUserId())
                .claim("permissions", loginUser.getPermissions())
                .setIssuedAt(new Date())
                .setExpiration(expiryDate)
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }
    public String validateTokenAndGetUserId(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
        return claims.get("userId", String.class);
    }
}

3.2 SSO认证过滤器

@Component
public class SsoAuthenticationFilter extends OncePerRequestFilter {
    @Autowired
    private JwtTokenProvider tokenProvider;
    @Autowired
    private UserService userService;
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                  HttpServletResponse response, 
                                  FilterChain filterChain) throws ServletException, IOException {
        String token = getJwtFromRequest(request);
        if (StringUtils.hasText(token) && tokenProvider.validateToken(token)) {
            try {
                String userId = tokenProvider.validateTokenAndGetUserId(token);
                SysUser sysUser = userService.selectUserById(userId);
                if (sysUser != null) {
                    Set<String> permissions = sysPermissionService.getMenuPermission(sysUser);
                    LoginUser loginUser = new LoginUser(sysUser.getUserId(), 
                                                       sysUser.getDeptId(), 
                                                       sysUser, 
                                                       permissions);
                    UsernamePasswordAuthenticationToken authentication = 
                        new UsernamePasswordAuthenticationToken(
                            loginUser, 
                            null, 
                            loginUser.getAuthorities()
                        );
                    authentication.setDetails(
                        new WebAuthenticationDetailsSource().buildDetails(request)
                    );
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            } catch (Exception ex) {
                logger.error("Could not set user authentication in security context", ex);
            }
        }
        filterChain.doFilter(request, response);
    }
    private String getJwtFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}

四、自动登录机制实现

4.1 RememberMe配置

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private PersistentTokenRepository persistentTokenRepository;
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/login", "/public/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .and()
            .rememberMe()
            .rememberMeParameter("remember-me")
            .tokenRepository(persistentTokenRepository)
            .tokenValiditySeconds(86400) // 24小时
            .userDetailsService(userDetailsService);
    }
}

4.2 持久化Token存储

@Component
public class PersistentTokenRepositoryImpl implements PersistentTokenRepository {
    @Autowired
    private RememberMeTokenMapper rememberMeTokenMapper;
    @Override
    public void createNewToken(PersistentRememberMeToken token) {
        RememberMeToken entity = new RememberMeToken();
        entity.setSeries(token.getSeries());
        entity.setUsername(token.getUsername());
        entity.setToken(token.getTokenValue());
        entity.setLastUsed(token.getDate());
        rememberMeTokenMapper.insert(entity);
    }
    @Override
    public void updateToken(String series, String tokenValue, Date lastUsed) {
        RememberMeToken entity = new RememberMeToken();
        entity.setSeries(series);
        entity.setToken(tokenValue);
        entity.setLastUsed(lastUsed);
        rememberMeTokenMapper.updateByPrimaryKey(entity);
    }
    @Override
    public PersistentRememberMeToken getTokenForSeries(String seriesId) {
        RememberMeToken entity = rememberMeTokenMapper.selectByPrimaryKey(seriesId);
        if (entity != null) {
            return new PersistentRememberMeToken(
                entity.getUsername(),
                entity.getSeries(),
                entity.getToken(),
                entity.getLastUsed()
            );
        }
        return null;
    }
    @Override
    public void removeUserTokens(String username) {
        rememberMeTokenMapper.deleteByUsername(username);
    }
}

五、完整登录服务实现

@Service
public class SysLoginService {
    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private JwtTokenProvider tokenProvider;
    @Autowired
    private UserService userService;
    @Autowired
    private SysPermissionService sysPermissionService;
    /**
     * 用户登录
     */
    public String login(String username, String password, String code, String uuid) {
        // 1. 验证码校验
        validateCaptcha(code, uuid);
        // 2. 用户认证
        Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(username, password)
        );
        // 3. 认证成功后生成JWT Token
        SecurityContextHolder.getContext().setAuthentication(authentication);
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        return tokenProvider.generateToken(loginUser);
    }
    /**
     * 自动登录处理
     */
    public String autoLogin(String token) {
        if (StringUtils.hasText(token) && tokenProvider.validateToken(token)) {
            String userId = tokenProvider.validateTokenAndGetUserId(token);
            SysUser sysUser = userService.selectUserById(userId);
            if (sysUser != null) {
                Set<String> permissions = sysPermissionService.getMenuPermission(sysUser);
                LoginUser loginUser = new LoginUser(sysUser.getUserId(), 
                                                   sysUser.getDeptId(), 
                                                   sysUser, 
                                                   permissions);
                UsernamePasswordAuthenticationToken authentication = 
                    new UsernamePasswordAuthenticationToken(
                        loginUser, 
                        null, 
                        loginUser.getAuthorities()
                    );
                SecurityContextHolder.getContext().setAuthentication(authentication);
                // 生成新的token
                return tokenProvider.generateToken(loginUser);
            }
        }
        throw new AuthenticationException("自动登录失败");
    }
    private void validateCaptcha(String code, String uuid) {
        // 验证码校验逻辑
        String verifyKey = Constants.CAPTCHA_CODE_KEY + uuid;
        String captcha = redisCache.getCacheObject(verifyKey);
        redisCache.deleteObject(verifyKey);
        if (captcha == null || !code.equalsIgnoreCase(captcha)) {
            throw new CaptchaException("验证码错误");
        }
    }
}

六、安全工具类

public class SecurityUtils {
    /**
     * 获取用户ID
     */
    public static Long getUserId() {
        try {
            return getLoginUser().getUserId();
        } catch (Exception e) {
            throw new CustomException("获取用户ID异常", HttpStatus.UNAUTHORIZED);
        }
    }
    /**
     * 获取登录用户信息
     */
    public static LoginUser getLoginUser() {
        try {
            return (LoginUser) getAuthentication().getPrincipal();
        } catch (Exception e) {
            throw new CustomException("获取用户信息异常", HttpStatus.UNAUTHORIZED);
        }
    }
    /**
     * 获取Authentication
     */
    public static Authentication getAuthentication() {
        return SecurityContextHolder.getContext().getAuthentication();
    }
}

七、最佳实践建议

7.1 安全性考虑

Token过期时间：合理设置JWT过期时间
Token刷新机制：实现Token刷新避免频繁登录
HTTPS传输：确保Token在传输过程中的安全

7.2 性能优化

缓存机制：对用户权限信息进行缓存
异步处理：将非关键业务异步处理
数据库优化：对RememberMe表建立合适的索引

7.3 监控和日志

@Component
public class LoginLogAspect {
    @Around("execution(* com.example.service.SysLoginService.login(..))")
    public Object logLogin(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = null;
        try {
            result = joinPoint.proceed();
            // 记录成功日志
            logLoginSuccess(joinPoint.getArgs());
            return result;
        } catch (Exception e) {
            // 记录失败日志
            logLoginFailure(joinPoint.getArgs(), e);
            throw e;
        } finally {
            long endTime = System.currentTimeMillis();
            logger.info("登录耗时: {}ms", endTime - startTime);
        }
    }
}

八、总结

通过本文的介绍，我们了解了：

单点登录的核心原理：基于JWT实现跨系统认证
自动登录的实现机制：RememberMe和持久化Token存储
Spring Security集成：如何与现有安全框架整合
最佳实践：安全性和性能方面的考虑

在实际项目中，需要根据业务需求选择合适的方案，并注意安全性和性能的平衡。单点登录和自动登录机制的合理运用，能够显著提升用户体验和系统安全性。

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

您可能感兴趣的文章:

java采用中文方式显示时间的方法
这篇文章主要介绍了java采用中文方式显示时间的方法,实例分析了java时间操作及字符串转换的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
2015-07-07
java求数组元素重复次数和java字符串比较大小示例
这篇文章主要介绍了java求数组元素重复次数和java字符串比较大小示例,需要的朋友可以参考下
2014-04-04
轻松学会使用JavaMail API发送邮件
想要轻松学会使用JavaMail API发送邮件吗？本指南将带你快速掌握这一技能,让你能够轻松发送电子邮件,无论是个人还是工作需求,跟着我们的步骤,很快你就可以在Java应用程序中自如地处理邮件通信了！
2023-12-12
Spring @value用法示例详解
这篇文章主要介绍了Spring-@value用法详解,为了简化读取properties文件中的配置值，spring支持@value注解的方式来获取，这种方式大大简化了项目配置，提高业务中的灵活性，本文通过实例代码给大家介绍的非常详细，需要的朋友参考下吧
2022-08-08
SpringSecurity中@PermitAll与@PreAuthorize的实现
@PermitAll和@PreAuthorize都是处理安全性的强大工具,本文主要介绍了SpringSecurity中@PermitAll与@PreAuthorize的实现,具有一定的参考价值,感兴趣的可以了解一下
2024-07-07
Java实现简易版联网坦克对战小游戏（附源码）
这篇文章主要给大家介绍了关于Java实现简易版联网坦克对战小游戏的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用java具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
2019-04-04
SpringBoot-Maven打包压缩瘦身方式
这篇文章主要介绍了SpringBoot-Maven打包压缩瘦身方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-05-05
java.imageIo给图片添加水印的实现代码
最近项目在做一个商城项目, 项目上的图片要添加水印①,添加图片水印;②:添加文字水印;一下提供下个方法,希望大家可以用得着
2013-07-07
mybatisPlus返回Map类型的集合
本文主要介绍了mybatisPlus返回Map类型的集合，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2023-03-03
一文带你快速学会JDBC及获取连接的五种方式
JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口,下面这篇文章主要给大家介绍了关于如何通过一文带你快速学会JDBC及获取连接的五种方式,需要的朋友可以参考下
2022-09-09