Spring Security 6 【6-记住我功能】

于 2025-06-29 08:44:51 发布
阅读量549 收藏 22
点赞数 30
CC 4.0 BY-SA版权
分类专栏： # Security 文章标签： spring java security
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/148974495

Spring Security 6 记住我功能实现指南

Spring Security 6 提供了强大的"记住我"功能实现，允许用户在会话关闭后仍保持登录状态。以下是完整的实现方案和代码示例：

核心实现方案

1. 基于持久化令牌的实现（推荐）

import org.springframework.security.web.authentication.rememberme.PersistentTokenRepository;
import org.springframework.security.web.authentication.rememberme.JdbcTokenRepositoryImpl;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Autowired
    private DataSource dataSource; // 数据源
    
    @Autowired
    private UserDetailsService userDetailsService;

    // 配置持久化令牌存储
    @Bean
    public PersistentTokenRepository persistentTokenRepository() {
        JdbcTokenRepositoryImpl tokenRepo = new JdbcTokenRepositoryImpl();
        tokenRepo.setDataSource(dataSource);
        // 启动时创建表（仅第一次使用）
        // tokenRepo.setCreateTableOnStartup(true);
        return tokenRepo;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/", "/home", "/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .permitAll()
            )
            .rememberMe(remember -> remember
                .tokenRepository(persistentTokenRepository())
                .userDetailsService(userDetailsService)
                .tokenValiditySeconds(1209600) // 14天有效期
                .rememberMeParameter("remember-me") // 表单参数名
                .rememberMeCookieName("remember-me-cookie") // Cookie名称
                .useSecureCookie(true) // 仅HTTPS传输
                .key("uniqueAndSecretKey") // 加密密钥
            )
            .logout(logout -> logout
                .logoutSuccessUrl("/login?logout")
                .deleteCookies("JSESSIONID", "remember-me-cookie") // 删除Cookie
            );
        
        return http.build();
    }
}

2. 基于签名Cookie的实现（简单）

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .rememberMe(remember -> remember
            .key("uniqueAndSecretKey") // 必须设置
            .tokenValiditySeconds(1209600) // 14天
            .rememberMeParameter("remember-me")
            .userDetailsService(userDetailsService)
        );
    return http.build();
}

数据库表结构

Spring Security 需要以下表存储持久化令牌：

CREATE TABLE persistent_logins (
    username VARCHAR(64) NOT NULL,
    series VARCHAR(64) PRIMARY KEY,
    token VARCHAR(64) NOT NULL,
    last_used TIMESTAMP NOT NULL
);

前端登录表单

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login</title>
</head>
<body>
    <h2>Login</h2>
    <form th:action="@{/login}" method="post">
        <div>
            <label>Username:</label>
            <input type="text" name="username" required>
        </div>
        <div>
            <label>Password:</label>
            <input type="password" name="password" required>
        </div>
        <div>
            <label>
                <input type="checkbox" name="remember-me"/> Remember me
            </label>
        </div>
        <div>
            <button type="submit">Login</button>
        </div>
    </form>
</body>
</html>

自定义记住我服务

import org.springframework.security.web.authentication.rememberme.PersistentTokenBasedRememberMeServices;

public class CustomRememberMeServices extends PersistentTokenBasedRememberMeServices {

    public CustomRememberMeServices(String key, 
                                   UserDetailsService userDetailsService,
                                   PersistentTokenRepository tokenRepository) {
        super(key, userDetailsService, tokenRepository);
    }

    @Override
    protected void onLoginSuccess(HttpServletRequest request, 
                                 HttpServletResponse response,
                                 Authentication successfulAuthentication) {
        // 自定义登录成功处理
        String username = successfulAuthentication.getName();
        logger.info("Remember-me login successful for user: " + username);
        
        super.onLoginSuccess(request, response, successfulAuthentication);
    }

    @Override
    protected UserDetails processAutoLoginCookie(String[] cookieTokens, 
                                               HttpServletRequest request,
                                               HttpServletResponse response) 
        throws RememberMeAuthenticationException, UsernameNotFoundException {
        
        try {
            return super.processAutoLoginCookie(cookieTokens, request, response);
        } catch (RememberMeAuthenticationException e) {
            // 自定义异常处理
            logger.error("Remember-me authentication failed: " + e.getMessage());
            throw e;
        }
    }
}

在配置中使用自定义服务：

@Bean
public RememberMeServices rememberMeServices() {
    CustomRememberMeServices rememberMeServices = new CustomRememberMeServices(
        "uniqueAndSecretKey",
        userDetailsService,
        persistentTokenRepository()
    );
    rememberMeServices.setTokenValiditySeconds(1209600);
    rememberMeServices.setParameter("remember-me");
    rememberMeServices.setCookieName("remember-me-cookie");
    return rememberMeServices;
}

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .rememberMe(remember -> remember
            .rememberMeServices(rememberMeServices())
        );
    return http.build();
}

记住我功能的高级配置

1. 多设备管理

@Service
public class RememberMeTokenService {

    @Autowired
    private PersistentTokenRepository tokenRepository;
    
    public List<PersistentRememberMeToken> getUserTokens(String username) {
        return tokenRepository.findByUsername(username);
    }
    
    public void revokeToken(String series) {
        tokenRepository.removeToken(series);
    }
    
    public void revokeAllUserTokens(String username) {
        tokenRepository.removeUserTokens(username);
    }
}

@RestController
@RequestMapping("/account")
public class AccountController {
    
    @Autowired
    private RememberMeTokenService tokenService;
    
    @GetMapping("/sessions")
    public ResponseEntity<List<SessionInfo>> getUserSessions(
            @AuthenticationPrincipal UserDetails user) {
        List<PersistentRememberMeToken> tokens = tokenService.getUserTokens(user.getUsername());
        
        List<SessionInfo> sessions = tokens.stream().map(token -> 
            new SessionInfo(
                token.getSeries(),
                token.getTokenValue(),
                token.getDate()
            )
        ).collect(Collectors.toList());
        
        return ResponseEntity.ok(sessions);
    }
    
    @DeleteMapping("/sessions/{series}")
    public ResponseEntity<?> revokeSession(@PathVariable String series) {
        tokenService.revokeToken(series);
        return ResponseEntity.noContent().build();
    }
    
    @DeleteMapping("/sessions")
    public ResponseEntity<?> revokeAllSessions(@AuthenticationPrincipal UserDetails user) {
        tokenService.revokeAllUserTokens(user.getUsername());
        return ResponseEntity.noContent().build();
    }
    
    public static class SessionInfo {
        private final String series;
        private final String token;
        private final Date lastUsed;
        
        // 构造函数、getters
    }
}

2. 安全事件监听

@Component
public class RememberMeEventListener {
    
    private static final Logger logger = LoggerFactory.getLogger(RememberMeEventListener.class);
    
    @EventListener
    public void handleInteractiveAuthenticationSuccess(
            InteractiveAuthenticationSuccessEvent event) {
        
        if (event.getAuthentication() instanceof RememberMeAuthenticationToken) {
            String username = event.getAuthentication().getName();
            logger.info("Remember-me login successful for user: " + username);
            // 发送通知、记录审计日志等
        }
    }
    
    @EventListener
    public void handleAuthenticationFailure(
            AbstractAuthenticationFailureEvent event) {
        
        if (event.getException() instanceof RememberMeAuthenticationException) {
            String sourceIp = ((WebAuthenticationDetails) 
                event.getAuthentication().getDetails()).getRemoteAddress();
            
            logger.warn("Remember-me authentication failed from IP: " + sourceIp);
            // 安全告警、限制访问等
        }
    }
}

安全最佳实践

  1. 密钥管理：

    • 使用强密钥（至少32字符）
    • 定期轮换密钥（会导致所有记住我令牌失效）
    • 从安全配置存储获取密钥，而非硬编码

  2. Cookie安全：

    .rememberMe(remember -> remember
    .rememberMeCookieName("rm")
    .useSecureCookie(true) // 仅HTTPS
    .cookieDomain("yourdomain.com")
    .cookieHttpOnly(true) // 防止XSS
    .cookiePath("/")
)

  3. 会话管理：

    • 设置合理的令牌有效期（14-30天）
    • 提供用户管理活动会话的能力
    • 敏感操作前要求重新认证

  4. 令牌安全：

    • 使用持久化令牌而非签名Cookie
    • 每次认证后更新令牌
    • 监控异常登录模式

完整示例：用户界面

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Account Security</title>
    <style>
        .session-card { border: 1px solid #ddd; padding: 15px; margin-bottom: 10px; }
        .current-session { background-color: #e6f7ff; }
    </style>
</head>
<body>
    <h1>Active Sessions</h1>
    
    <div th:each="session : ${sessions}" 
         th:class="${session.current ? 'session-card current-session' : 'session-card'}">
        <h3 th:text="${session.browser} + ' on ' + ${session.os}">Browser on OS</h3>
        <p>Location: <span th:text="${session.location}">Location</span></p>
        <p>IP Address: <span th:text="${session.ipAddress}">IP</span></p>
        <p>Last Accessed: <span th:text="${session.lastAccess}">Date</span></p>
        
        <div th:if="${!session.current}">
            <button th:onclick="'revokeSession(\'' + ${session.series} + '\')'">Revoke</button>
        </div>
    </div>
    
    <div th:if="${#lists.size(sessions) > 1}">
        <button onclick="revokeAllSessions()">Revoke All Other Sessions</button>
    </div>
    
    <script>
    function revokeSession(series) {
        fetch('/account/sessions/' + series, { method: 'DELETE' })
            .then(response => {
                if (response.ok) {
                    alert('Session revoked');
                    location.reload();
                }
            });
    }
    
    function revokeAllSessions() {
        fetch('/account/sessions', { method: 'DELETE' })
            .then(response => {
                if (response.ok) {
                    alert('All other sessions revoked');
                    location.reload();
                }
            });
    }
    </script>
</body>
</html>

配置参数说明

配置项默认值说明
tokenValiditySeconds1209600 (14天)记住我令牌有效期
alwaysRememberfalse是否总是记住
useSecureCookie跟随请求安全属性是否仅HTTPS发送Cookie
rememberMeParameter“remember-me”前端复选框名称
rememberMeCookieName“remember-me”Cookie名称
key随机UUID签名密钥（必须设置）
tokenRepositorynull持久化令牌存储（推荐使用）

故障排除

  1. 记住我功能不生效：

    • 检查前端表单参数名是否匹配
    • 确认密钥配置一致
    • 验证数据库连接正常（持久化令牌）
    • 检查Cookie是否被浏览器阻止

  2. 登录后立即失效：

    • 确保服务器时间正确
    • 验证令牌有效期设置
    • 检查是否有多个服务实例共享密钥

  3. 安全警告：

    • 确保使用HTTPS
    • 设置HttpOnly和Secure Cookie标志
    • 定期轮换加密密钥

Spring Security 6 的记住我功能提供了灵活且安全的实现方案。持久化令牌方案比简单的签名Cookie更安全，推荐在生产环境中使用。同时结合多设备管理和安全监控，可以构建更加安全的认证系统。

Spring Security 6.x 系列（1）—— 初识Spring Security
gmHappy
10-05 2万+
`Spring Security`作为一个功能完善的安全框架，具有以下特性： - **认证（Authentication）**：解决 "你是谁" 的问题，验证系统中是否有这个“用户”(用户/设备/系统)，也就是我们常说的“登录”。 - **授权（Authorization）**：权限控制/鉴别，解决的是系统中某个用户能够访问哪些资源，即“你能干什么”的问题。`Spring Security` 支持基于 `URL` 的请求授权、方法访问授权、对象访问授权。
Spring Security 6.x 系列【11】认证篇之记住我功能深入解析
记录知识、锤炼自我
04-04 1247
（记住我）是比较常见的一种功能，打开一个网站后，如果超过一定的时间未操作，会话过期后需要重新登录。功能可以“记住”当前登录用户，就算会话过期，或者浏览器关闭，下次进入时，不再需要认证，直接自动登录。例如：微信开放平台提供的支持，当开启该功能后，认证通过时，会向浏览器发送一个Cookie保存记住我信息，会话失效后发起请求，服务端发现cookie中存在登录时不会去校验// 开启记住我 http . rememberMe() . alwaysRemember(true);可以使用。
springsecurity记住我
热门推荐
钟健的博客
04-03 5万+
Spring Security 记住我 第一步 创建（配置）数据库 spring: datasource: username: root password: 123456 url: jdbc:mysql://127.0.0.1:3306/study-security?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8 driver-class-name: com.mysql.cj.jd
Spring Security 记住我
白石的专栏
12-05 386
本教程将展示**如何**使用 Spring Security 在 Web 应用程序中启用和配置记住我功能。
SpringSecurity---Remember Me
gaoqiandr的博客
09-19 567
本文主要介绍的是Security中的Remember Me
springSecurity-记住我(Remember me)
最新发布
weixin_54097396的博客
04-18 1244
Remember me(记住我)记住我，当用户发起登录勾选了记住我，在一定的时间内再次登录就不用输入用户名和密码了，即使浏览器退出重新打开也是如此。二.流程分析在SpringSecurity中提供RememberMeAuthenticationFilter过滤器来实现记住我功能，其核心流程如下：1.认证成功UsernamePasswordAuthenticationFilter会调用RememberMeServices创建Token。
Spring Security ‘记住我’ 功能
小汤圆
08-10 419
Spring Security记住我功能
Spring security实现记住我下次自动登录功能过程详解
08-24
Spring Security 实现记住我下次自动登录功能过程详解 Spring Security 是一个功能强大且广泛使用的 Java 认证和授权框架，提供了许多功能强大的功能，例如认证、授权、RememberMe 等。在本文中，我们将详细介绍...
Spring Security 实现“记住我”功能及原理解析
08-19
Spring Security 实现“记住我”功能及原理解析 Spring Security 是一个功能强大且灵活的身份验证和授权框架，它提供了许多实用的功能来满足各种安全需求。其中，“记住我”功能是一个非常重要的功能，它允许用户在...
SpringSecurity5.7.11实现用户认证和记住我功能
01-02
在5.7.11版本中，SpringSecurity不仅强化了基础的安全特性，还支持用户认证和“记住我”功能，使得用户体验得到了提升。下面将详细介绍这两个核心功能的实现。 **一、用户认证** 用户认证是任何安全系统的基础，它...
七.Spring Security-记住我(Remember me)
qq_32115993的博客
10-22 786
七.记住我 - Remember me 一.记住我概述 1.1.什么是记住我 Remember me(记住我)记住我，当用户发起登录勾选了记住我，在一定的时间内再次登录就不用输入用户名和密码了，即使浏览器退出重新打开也是如此。 1.2.流程分析 在SpringSecurity中提供RememberMeAuthenticationFilter过滤器来实现记住我功能，其核心流程如下： 1.认证成功UsernamePasswordAuthenticationFilter会调用RememberMeServices创
Spring Security 记住我功能
zongzhibin117的博客
09-15 139
Spring Security 记住我功能基于数据库或者内存（一般使用数据库）。 引入Mybatis相关的依赖。 增加Mybatis相关配置。 修改Spring Security配置： http.rememberMe(). // 需要使用userService userDetailsService(userService) // 指定存储位置 .tokenRepository() 前端加一个复选框name为remeberme，提
SpringSecurity（七）添加记住我功能
lizc_lizc的博客
11-14 1694
记住我基本原理 用户认证成功后调用RemeberMeService服务，这个服务里有一个TokenRepository，它会生成一个Token写入浏览器Cookie，同时它还会使用TokenRepository将Token和用户名写入到数据库中。 当用户再次访问系统时,过滤器链如下所示，请求会经过RememberMeAuthenticationFilter过滤器，该过滤器会读取cookie...
SpringSecurity的remember me记住我功能
weixin_46278059的博客
12-11 513
SpringSecurity的remember me记住我功能
Spring Security 入门 Remember-Me 记住我功能
SheTing'Blog
04-16 893
用户选择了“记住我”成功登录后，将会把username、随机生成的序列号、生成的token存入一个数据库表中，同时将它们的组合生成一个cookie发送给客户端浏览器。 当没有登录的用户访问系统时，首先检查 remember-me 的 cookie 值 ，有则检查其值包含的 username、序列号和 token 与数据库中是否一致，一致则通过验证。并且系统还会重新生成一个新的 token 替换数据库中对应旧的 token，序列号 series 保持不变 ，同时删除旧的 cookie，重新生成 cookie.
Spring Security 的 RememberMe 详解 !!!!!
weixin_52834606的博客
09-03 3948
spring security 记住我 rememberMe
Spring——Security安全框架之记住我
专注写bug
02-24 3915
文章目录简介思维逻辑配置和测试数据库创建配置类注入数据源，配置操作数据库对象配置config(HttpSecurity)页面增加记住我选项测试注意事项原理分析代码下载 简介 在一般的网站中，比如Bilibili。当用户登录成功后，关闭浏览器后，下次重新进入网站，可以自动登录。 本次就来探究如何实现这种自动登录、记住我的功能。 思维逻辑 需要实现记住我的功能操作，需要保证具体的实现方式，接下来就来梳理下。 首先，在Security框架中，针对记住我的功能实现，Security框架本身对其做了一定的封装，其实现
SpringSecurity入门《之RememberMe“记住我”功能》
潘大Q仙的博客
04-04 259
RememberMe“记住我”功能 在配置类中开启RememberMe功能： @Override protected void configure(HttpSecurity security) throws Exception { security.authorizeRequests() ....... .and() ...
SpringSecurity5.7.11：用户认证与记住我功能实现指南
资源摘要信息: "SpringSecurity5.7.11实现用户认证和记住我功能" Spring Security是Java领域中广泛使用的安全性框架，用于为Spring应用提供身份验证和授权。Spring Security 5.7.11版本不仅提供了最新的安全特性，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值