SpringSecurity身份验证实现完整指南_Java

spring security 表单登录完整指南

概述

spring security 是 spring 生态中用于处理认证和授权的强大框架。本文以实际项目为例，详细讲解如何使用 spring security 实现基于表单的登录认证。

为什么选择 spring security?

✅ 标准化: 提供企业级的安全解决方案
✅ 自动化: 自动处理认证流程、session 管理、csrf 保护
✅ 可扩展: 支持多种认证方式 (表单、oauth2、jwt 等)
✅ 久经考验: 经过大量生产环境验证

本文目标

通过本文，你将学会:

配置 spring security 的 formlogin
自定义登录页面和认证逻辑
处理登录成功和失败的场景
在业务代码中获取当前登录用户
实现登出功能

核心概念

1. 认证 (authentication)

认证是验证用户身份的过程，回答"你是谁？"的问题。

在 spring security 中，认证信息存储在 authentication 对象中:

authentication authentication = securitycontextholder.getcontext().getauthentication();
string username = authentication.getname();  // 获取用户名
object principal = authentication.getprincipal();  // 获取用户详情
collection<? extends grantedauthority> authorities = authentication.getauthorities();  // 获取权限

2. securitycontext

securitycontext 是 spring security 的核心容器，用于存储当前用户的认证信息。

// 获取当前 securitycontext
securitycontext context = securitycontextholder.getcontext();
// 获取认证信息
authentication auth = context.getauthentication();
// 判断用户是否已认证
boolean isauthenticated = auth != null && auth.isauthenticated();

3. 过滤器链 (filter chain)

spring security 通过一系列过滤器来处理请求:

请求 → disableencodeurlfilter
     → webasyncmanagerintegrationfilter
     → securitycontextpersistencefilter  (从 session 中恢复 securitycontext)
     → headerwriterfilter
     → logoutfilter  (处理登出请求)
     → usernamepasswordauthenticationfilter  (处理登录请求)
     → requestcacheawarefilter
     → securitycontextholderawarerequestfilter
     → anonymousauthenticationfilter
     → sessionmanagementfilter
     → exceptiontranslationfilter
     → authorizationfilter  (鉴权)
     → 业务代码

快速开始

步骤 1: 添加依赖

在 pom.xml 中添加 spring security 依赖:

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-security</artifactid>
</dependency>

步骤 2: 配置 securityconfig

创建安全配置类:

@configuration
@enablewebsecurity
public class securityconfig {
    @bean
    public securityfilterchain securityfilterchain(httpsecurity http) throws exception {
        http
            .csrf().disable()  // 演示环境禁用 csrf (生产环境建议启用)
            .authorizehttprequests(auth -> auth
                .antmatchers("/public/**").permitall()  // 公开路径
                .antmatchers("/login").permitall()      // 登录页面允许匿名访问
                .anyrequest().authenticated()           // 其他路径需要认证
            )
            .formlogin(form -> form
                .loginpage("/login")                    // 自定义登录页面
                .loginprocessingurl("/login")           // 登录表单提交的 url
                .defaultsuccessurl("/home", true)       // 登录成功后跳转的页面
                .failureurl("/login?error")             // 登录失败后跳转的页面
                .permitall()
            )
            .logout(logout -> logout
                .logouturl("/logout")                   // 登出 url
                .logoutsuccessurl("/login?logout")      // 登出成功后跳转的页面
                .permitall()
            );
        return http.build();
    }
    @bean
    public passwordencoder passwordencoder() {
        return new bcryptpasswordencoder();  // 使用 bcrypt 加密密码
    }
    @bean
    public userdetailsservice userdetailsservice() {
        // 内存用户存储 (演示用,生产环境应使用数据库)
        userdetails user = user.builder()
            .username("admin")
            .password(passwordencoder().encode("password"))
            .roles("user")
            .build();
        return new inmemoryuserdetailsmanager(user);
    }
}

步骤 3: 创建登录页面

创建 src/main/resources/templates/login.html:

<!doctype html>
<html lang="zh-cn" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <title>登录</title>
</head>
<body>
    <h2>用户登录</h2>
    <!-- 错误提示 -->
    <div th:if="${error}" style="color: red;">
        用户名或密码错误
    </div>
    <!-- 登出成功提示 -->
    <div th:if="${logout}" style="color: green;">
        您已成功退出登录
    </div>
    <!-- 登录表单 -->
    <form method="post" th:action="@{/login}">
        <div>
            <label>用户名:</label>
            <input type="text" name="username" required autofocus>
        </div>
        <div>
            <label>密码:</label>
            <input type="password" name="password" required>
        </div>
        <button type="submit">登录</button>
    </form>
</body>
</html>

关键点:

表单必须使用 post 方法
表单 action 必须是 /login (或配置的 loginprocessingurl)
用户名字段必须命名为 username
密码字段必须命名为 password

步骤 4: 创建 logincontroller

@controller
public class logincontroller {
    @getmapping("/login")
    public string loginpage(@requestparam(required = false) string error,
                           @requestparam(required = false) string logout,
                           model model) {
        if (error != null) {
            model.addattribute("error", "用户名或密码错误");
        }
        if (logout != null) {
            model.addattribute("logout", "您已成功退出登录");
        }
        return "login";
    }
}

注意:

只需要处理 get /login 展示登录页面
post /login 由 spring security 自动处理，不需要编写代码

深入理解

1. formlogin 工作原理

当你配置 formlogin() 时，spring security 会自动注册 usernamepasswordauthenticationfilter:

1. 用户提交登录表单 (post /login)
   ↓
2. usernamepasswordauthenticationfilter 拦截请求
   ↓
3. 从请求中提取 username 和 password
   ↓
4. 创建 usernamepasswordauthenticationtoken (未认证)
   ↓
5. 调用 authenticationmanager.authenticate()
   ↓
6. authenticationmanager 委托给 daoauthenticationprovider
   ↓
7. daoauthenticationprovider 调用 userdetailsservice.loaduserbyusername()
   ↓
8. 获取 userdetails，使用 passwordencoder 比对密码
   ↓
9. 认证成功: 创建已认证的 authentication 对象
   ↓
10. 将 authentication 存入 securitycontext
   ↓
11. securitycontextpersistencefilter 将 securitycontext 保存到 session
   ↓
12. 重定向到 defaultsuccessurl

2. 认证失败流程

1. 密码校验失败
   ↓
2. 抛出 badcredentialsexception
   ↓
3. authenticationfailurehandler 处理异常
   ↓
4. 重定向到 failureurl (/login?error)
   ↓
5. logincontroller 检测到 error 参数
   ↓
6. 在页面显示错误提示

3. 获取当前登录用户的三种方式

方式 1: securitycontextholder (推荐)

@controller
public class mycontroller {
    @getmapping("/profile")
    public string profile(model model) {
        authentication auth = securitycontextholder.getcontext().getauthentication();
        string username = auth.getname();
        model.addattribute("username", username);
        return "profile";
    }
}

方式 2: 方法参数注入

@getmapping("/profile")
public string profile(@authenticationprincipal userdetails user, model model) {
    string username = user.getusername();
    model.addattribute("username", username);
    return "profile";
}

方式 3: principal 参数

@getmapping("/profile")
public string profile(principal principal, model model) {
    string username = principal.getname();
    model.addattribute("username", username);
    return "profile";
}

4. session 管理

spring security 默认会在登录成功后执行 session fixation protection (会话固定攻击防护):

// 默认行为: 登录成功后更换 session id
.sessionmanagement(session -> session
    .sessionfixation().changesessionid()  // 默认值
)
// 其他选项:
.sessionfixation().none()           // 不更换 (不安全)
.sessionfixation().newsession()     // 创建新 session (旧 session 属性会丢失)
.sessionfixation().migratesession() // 迁移 session (保留旧属性)

实战技巧

技巧 1: 自定义登录成功处理器

如果需要在登录成功后执行额外逻辑 (如记录日志、更新登录时间):

@component
public class customauthenticationsuccesshandler implements authenticationsuccesshandler {
    @override
    public void onauthenticationsuccess(httpservletrequest request,
                                       httpservletresponse response,
                                       authentication authentication) throws ioexception {
        // 记录登录日志
        string username = authentication.getname();
        system.out.println("用户 " + username + " 登录成功");
        // 重定向到目标页面
        response.sendredirect("/home");
    }
}

在 securityconfig 中使用:

@autowired
private customauthenticationsuccesshandler successhandler;
.formlogin(form -> form
    .loginpage("/login")
    .successhandler(successhandler)  // 使用自定义处理器
)

技巧 2: 记住我 (remember me)

.rememberme(remember -> remember
    .key("unique-key")              // 加密密钥
    .tokenvalidityseconds(604800)   // token 有效期 (7天)
    .remembermeparameter("remember-me")  // 表单参数名
)

登录表单添加复选框:

<label>
    <input type="checkbox" name="remember-me"> 记住我
</label>

技巧 3: 限制同一用户的并发登录

.sessionmanagement(session -> session
    .maximumsessions(1)  // 同一用户最多 1 个 session
    .maxsessionspreventslogin(true)  // 达到上限后阻止新登录
    .expiredurl("/login?expired")    // session 过期后跳转的页面
)

技巧 4: 在 thymeleaf 中使用 spring security

添加依赖:

<dependency>
    <groupid>org.thymeleaf.extras</groupid>
    <artifactid>thymeleaf-extras-springsecurity5</artifactid>
</dependency>

在模板中使用:

<html xmlns:sec="http://www.thymeleaf.org/extras/spring-security">
<!-- 仅认证用户可见 -->
<div sec:authorize="isauthenticated()">
    欢迎，<span sec:authentication="name">用户</span>！
    <a th:href="@{/logout}" rel="external nofollow" >退出</a>
</div>
<!-- 仅匿名用户可见 -->
<div sec:authorize="!isauthenticated()">
    <a th:href="@{/login}" rel="external nofollow" >登录</a>
</div>
<!-- 仅特定角色可见 -->
<div sec:authorize="hasrole('admin')">
    管理员专属内容
</div>

技巧 5: 登录后跳转到之前访问的页面

spring security 默认会自动实现此功能!

工作原理:

用户访问 /protected/resource (未登录)
spring security 将 /protected/resource 保存到 requestcache
重定向到 /login
用户登录成功后，自动跳转回 /protected/resource

如果需要禁用此功能，强制跳转到固定页面:

.formlogin(form -> form
    .defaultsuccessurl("/home", true)  // 第二个参数 true 表示总是跳转到 /home
)

常见问题

问题 1: 登录后仍然跳转到登录页 (重定向循环)

原因: /login 路径没有配置为允许匿名访问

解决方案:

.authorizehttprequests(auth -> auth
    .antmatchers("/login").permitall()  // 必须添加这一行
    .anyrequest().authenticated()
)

问题 2: 登录失败没有显示错误信息

原因: controller 没有处理 error 参数

解决方案:

@getmapping("/login")
public string loginpage(@requestparam(required = false) string error, model model) {
    if (error != null) {
        model.addattribute("error", "用户名或密码错误");
    }
    return "login";
}

问题 3: csrf token 验证失败

原因: 启用了 csrf 保护但表单没有包含 csrf token

解决方案 1: 禁用 csrf (仅适用于演示环境)

http.csrf().disable();

解决方案 2: 在表单中添加 csrf token

<form method="post" th:action="@{/login}">
    <!-- spring security 会自动注入 csrf token -->
    <input type="hidden" th:name="${_csrf.parametername}" th:value="${_csrf.token}"/>
    <!-- 其他表单字段 -->
</form>

使用 thymeleaf 的 th:action 会自动添加 csrf token，无需手动添加!

问题 4: 获取不到当前用户信息

原因: securitycontext 没有正确存储到 session

检查:

authentication auth = securitycontextholder.getcontext().getauthentication();
if (auth == null) {
    system.out.println("securitycontext 为空");
} else if (!auth.isauthenticated()) {
    system.out.println("用户未认证");
} else {
    system.out.println("用户名: " + auth.getname());
}

问题 5: 静态资源 (css/js/图片) 被拦截

解决方案: 配置静态资源路径为允许匿名访问

.authorizehttprequests(auth -> auth
    .antmatchers("/css/**", "/js/**", "/images/**").permitall()
    .antmatchers("/login").permitall()
    .anyrequest().authenticated()
)

或者使用 websecurity.ignoring():

@bean
public websecuritycustomizer websecuritycustomizer() {
    return (web) -> web.ignoring().antmatchers("/css/**", "/js/**", "/images/**");
}

最佳实践

1. 密码加密

永远不要明文存储密码! 使用 bcryptpasswordencoder:

@bean
public passwordencoder passwordencoder() {
    return new bcryptpasswordencoder();
}
// 创建用户时加密密码
string encodedpassword = passwordencoder.encode("rawpassword");

2. 使用数据库存储用户

生产环境应使用数据库而非内存存储:

@service
public class customuserdetailsservice implements userdetailsservice {
    @autowired
    private userrepository userrepository;
    @override
    public userdetails loaduserbyusername(string username) throws usernamenotfoundexception {
        user user = userrepository.findbyusername(username)
            .orelsethrow(() -> new usernamenotfoundexception("用户不存在"));
        return org.springframework.security.core.userdetails.user.builder()
            .username(user.getusername())
            .password(user.getpassword())  // 数据库中已加密的密码
            .roles(user.getroles().toarray(new string[0]))
            .build();
    }
}

3. 区分开发和生产环境的配置

@configuration
@profile("dev")
public class devsecurityconfig {
    @bean
    public securityfilterchain devsecurityfilterchain(httpsecurity http) throws exception {
        http.csrf().disable();  // 开发环境禁用 csrf
        // ...
    }
}
@configuration
@profile("prod")
public class prodsecurityconfig {
    @bean
    public securityfilterchain prodsecurityfilterchain(httpsecurity http) throws exception {
        http.csrf().csrftokenrepository(cookiecsrftokenrepository.withhttponlyfalse());
        // ...
    }
}

4. 使用 https

生产环境必须使用 https:

http.requireschannel(channel -> channel
    .anyrequest().requiressecure()  // 强制使用 https
);

5. 日志记录

记录关键的安全事件:

@component
@slf4j
public class authenticationeventlistener {
    @eventlistener
    public void onauthenticationsuccess(authenticationsuccessevent event) {
        string username = event.getauthentication().getname();
        log.info("用户登录成功: {}", username);
    }
    @eventlistener
    public void onauthenticationfailure(abstractauthenticationfailureevent event) {
        string username = event.getauthentication().getname();
        exception exception = event.getexception();
        log.warn("用户登录失败: {}, 原因: {}", username, exception.getmessage());
    }
}

6. 避免常见安全漏洞

✅ 启用 csrf 保护 (生产环境)
✅ 使用 https
✅ 密码加密存储
✅ 防止暴力破解 (限制登录尝试次数)
✅ session 超时设置
✅ 安全的密码策略 (长度、复杂度)

// session 超时配置 (application.yml)
server:
  servlet:
    session:
      timeout: 30m  # 30 分钟无操作自动登出

完整示例代码

securityconfig.java

package org.example.demoboot.config;
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.core.userdetails.user;
import org.springframework.security.core.userdetails.userdetails;
import org.springframework.security.core.userdetails.userdetailsservice;
import org.springframework.security.crypto.bcrypt.bcryptpasswordencoder;
import org.springframework.security.crypto.password.passwordencoder;
import org.springframework.security.provisioning.inmemoryuserdetailsmanager;
import org.springframework.security.web.securityfilterchain;
@configuration
@enablewebsecurity
public class securityconfig {
    @bean
    public securityfilterchain securityfilterchain(httpsecurity http) throws exception {
        http
            .csrf().disable()
            .authorizehttprequests(auth -> auth
                .antmatchers("/public/**").permitall()
                .antmatchers("/login").permitall()
                .antmatchers("/ratelimit/**").authenticated()
                .anyrequest().authenticated()
            )
            .formlogin(form -> form
                .loginpage("/login")
                .loginprocessingurl("/login")
                .defaultsuccessurl("/ratelimit", true)
                .failureurl("/login?error")
                .permitall()
            )
            .logout(logout -> logout
                .logouturl("/logout")
                .logoutsuccessurl("/login?logout")
                .permitall()
            );
        return http.build();
    }
    @bean
    public userdetailsservice userdetailsservice() {
        userdetails admin = user.builder()
            .username("admin")
            .password(passwordencoder().encode("password"))
            .roles("user")
            .build();
        userdetails test = user.builder()
            .username("test")
            .password(passwordencoder().encode("test123"))
            .roles("user")
            .build();
        return new inmemoryuserdetailsmanager(admin, test);
    }
    @bean
    public passwordencoder passwordencoder() {
        return new bcryptpasswordencoder();
    }
}

logincontroller.java

package org.example.demoboot.controller;
import org.springframework.stereotype.controller;
import org.springframework.web.bind.annotation.getmapping;
import org.springframework.web.bind.annotation.requestparam;
import org.springframework.ui.model;
@controller
public class logincontroller {
    @getmapping("/login")
    public string loginpage(@requestparam(required = false) string error,
                           @requestparam(required = false) string logout,
                           model model) {
        if (error != null) {
            model.addattribute("error", "用户名或密码错误");
        }
        if (logout != null) {
            model.addattribute("logout", "您已成功退出登录");
        }
        return "login";
    }
}

在业务代码中获取当前用户

package org.example.demoboot.controller;
import org.springframework.security.core.authentication;
import org.springframework.security.core.context.securitycontextholder;
import org.springframework.stereotype.controller;
import org.springframework.ui.model;
import org.springframework.web.bind.annotation.getmapping;
@controller
public class homecontroller {
    @getmapping("/ratelimit")
    public string home(model model) {
        // 获取当前登录用户
        authentication auth = securitycontextholder.getcontext().getauthentication();
        string username = auth.getname();
        model.addattribute("username", username);
        return "ratelimit";
    }
}

总结

本文通过实际代码示例，详细讲解了 spring security 表单登录的核心知识:

✅ 配置 securityconfig: 启用 formlogin，配置登录页面和成功/失败处理
✅ 自定义登录页面: 使用 thymeleaf 创建登录表单
✅ 获取当前用户: 通过 securitycontextholder 获取认证信息
✅ 异常处理: 在 controller 中处理登录错误
✅ 登出功能: 配置 logout url 和成功跳转页面
✅ 实战技巧: remember me、并发控制、自定义成功处理器
✅ 最佳实践: 密码加密、https、日志记录、安全配置

掌握这些知识后，你可以在项目中灵活运用 spring security，构建安全可靠的认证系统。

到此这篇关于springsecurity身份验证实现的文章就介绍到这了,更多相关springsecurity身份验证内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！


验证码：

SpringSecurity身份验证实现完整指南

2026年01月01日 • Java •我要评论