身份认证状态的存储与传递( Spring Boot篇 )

bcgbsh2025-11-17 17:32

在 Spring Boot 中，浏览器获取登录信息的核心是 "身份认证状态的存储与传递"------登录成功后，服务端会生成用户身份凭证，浏览器通过特定机制存储该凭证，后续请求时自动携带，服务端验证凭证后即可识别用户身份，返回对应的登录信息。

以下是主流实现方案，从原理到具体操作逐步说明：

一、核心逻辑：登录信息的"存储-传递-验证"流程

无论哪种方案，本质都是3步：

  1. 登录成功 ：用户提交账号密码，服务端验证通过后，生成包含用户身份（如用户ID、角色）的凭证（如Session ID、JWT Token）；
  2. 凭证存储：服务端存储凭证与用户信息的关联（如Session内存、Redis），浏览器存储凭证（如Cookie、LocalStorage）；
  3. 后续请求：浏览器携带凭证发起请求，服务端验证凭证有效性，从关联存储中取出用户信息，供业务使用（如返回用户昵称、权限）。

二、主流实现方案（按常用程度排序）

方案1：基于 Session + Cookie（传统经典方案）

这是 Spring Boot 整合 Spring Security/Shiro 时的默认方案，依赖 HTTP 协议的 Cookie 和服务端 Session 机制。

原理

  • Session ：服务端创建的内存/持久化存储（如Redis），存储用户登录信息（用户ID、角色等），每个Session对应唯一的 JSESSIONID（凭证）；
  • Cookie ：浏览器自动存储 JSESSIONID，后续请求时自动在 HTTP 头的 Cookie 字段中携带该ID；
  • 流程 ：
    1. 用户登录 → 服务端验证通过 → 创建 Session（存储用户信息）→ 响应时通过 Set-Cookie 头将 JSESSIONID 发送给浏览器；
    2. 浏览器保存 JSESSIONID 到 Cookie；
    3. 后续请求 → 浏览器自动携带 JSESSIONID（Cookie 字段）→ 服务端通过 JSESSIONID 找到对应的 Session → 取出用户登录信息。

代码实现（Spring Security 示例）

  1. 引入依赖（Spring Boot 2.x+）：
xml 复制代码 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
  1. 配置 Spring Security（默认启用 Session + Cookie）：
java 复制代码 
@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    // 密码加密器（Spring Security 要求密码必须加密存储）
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    // 模拟用户（实际从数据库查询）
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("admin")
            .password(passwordEncoder().encode("123456"))
            .roles("ADMIN"); // 存储用户角色（登录信息的一部分）
    }

    // 授权规则（登录接口允许匿名访问）
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/login").permitAll() // 登录接口匿名访问
                .anyRequest().authenticated() // 其他接口需登录
            .and()
                .formLogin() // 启用默认登录页面（或自定义 loginPage）
                .defaultSuccessUrl("/user/info") // 登录成功后跳转的接口（获取登录信息）
            .and()
                .logout()
                .permitAll();
    }
}
  1. 编写接口，获取当前登录用户信息：
java 复制代码 
@RestController
@RequestMapping("/user")
public class UserController {

    // 从 SecurityContext 中获取登录用户信息（Spring Security 自动注入）
    @GetMapping("/info")
    public Principal getLoginUser(Principal principal) {
        // Principal 包含用户名，如需更多信息（如用户ID、昵称），需自定义 User 类
        return principal;
    }
}
  1. 浏览器端表现：
  • 登录成功后，浏览器会在 Cookie 中存储 JSESSIONID；
  • 后续访问 /user/info 时，浏览器自动携带 JSESSIONID，服务端验证后返回当前登录用户（如 {"name":"admin"}）。

特点

  • 优点：简单易用，无需前端额外处理（Cookie 自动携带），安全性较高（可配置 Cookie 为 HttpOnly 防止 XSS 攻击）；
  • 缺点：依赖 Cookie，跨域场景需额外配置（如 CORS + Credentials），分布式部署需共享 Session（如 Redis 存储 Session）。

方案2：基于 JWT Token（无状态方案，适合前后端分离/跨域）

JWT（JSON Web Token）是一种无状态凭证 ，登录成功后服务端生成 Token 并返回给浏览器，浏览器存储 Token（如 LocalStorage），后续请求通过 HTTP 头（如 Authorization: Bearer Token）携带 Token，服务端解析 Token 即可获取用户信息。

原理

  • JWT 结构 ：由 Header（算法）、Payload（用户信息，如用户ID、用户名）、Signature（签名，防止篡改）三部分组成，用 . 拼接；
  • 流程 ：
    1. 用户登录 → 服务端验证通过 → 生成 JWT Token（Payload 中嵌入用户信息）→ 返回 Token 给浏览器；
    2. 浏览器将 Token 存储到 LocalStorage/SessionStorage；
    3. 后续请求 → 前端在请求头中添加 Authorization: Bearer ${Token} → 服务端验证 Token 签名（确保未篡改）→ 解析 Payload 中的用户信息。

代码实现（Spring Security + JWT）

  1. 引入依赖（除 Spring Security 外，需添加 JWT 依赖）：
xml 复制代码 
<!-- JWT 依赖 -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
  1. 编写 JWT 工具类（生成 Token、验证 Token、解析用户信息）：
java 复制代码 
@Component
public class JwtUtil {
    // 密钥（生产环境需配置在配置文件，且定期更换）
    private static final String SECRET = "your-secret-key-32bytes-long-123456";
    // Token 过期时间（如 2 小时）
    private static final long EXPIRATION = 7200000;

    // 生成 Token（登录成功后调用）
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("username", userDetails.getUsername());
        claims.put("roles", userDetails.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()));

        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
                .signWith(SignatureAlgorithm.HS256, SECRET)
                .compact();
    }

    // 验证 Token 有效性
    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(SECRET).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    // 从 Token 中解析用户信息（如用户名）
    public String getUsernameFromToken(String token) {
        Claims claims = Jwts.parser()
                .setSigningKey(SECRET)
                .parseClaimsJws(token)
                .getBody();
        return (String) claims.get("username");
    }
}
  1. 配置 Spring Security（禁用 Session，使用 JWT 认证）：
java 复制代码 
@Configuration
@EnableWebSecurity
public class JwtSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtUtil jwtUtil;
    @Autowired
    private UserDetailsService userDetailsService; // 自定义用户查询服务（从数据库取用户）

    // 认证过滤器：解析请求头中的 Token，验证后注入用户信息到 SecurityContext
    @Bean
    public JwtAuthenticationFilter jwtAuthenticationFilter() {
        return new JwtAuthenticationFilter(jwtUtil, userDetailsService);
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable() // 前后端分离场景禁用 CSRF（Token 本身已防篡改）
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) // 禁用 Session
            .and()
            .authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
            .and()
            .addFilterBefore(jwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class); // 添加 JWT 过滤器
    }
}
  1. 登录接口（生成 Token 并返回）：
java 复制代码 
@RestController
public class LoginController {

    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private JwtUtil jwtUtil;

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody LoginRequest loginRequest) {
        // 验证账号密码
        Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(loginRequest.getUsername(), loginRequest.getPassword())
        );
        SecurityContextHolder.getContext().setAuthentication(authentication);

        // 生成 JWT Token
        UserDetails userDetails = (UserDetails) authentication.getPrincipal();
        String token = jwtUtil.generateToken(userDetails);

        // 返回 Token 给浏览器
        return ResponseEntity.ok(new JwtResponse(token));
    }
}

// 接收登录请求的实体类
@Data
class LoginRequest {
    private String username;
    private String password;
}

// 返回 Token 的实体类
@Data
class JwtResponse {
    private String token;
    public JwtResponse(String token) {
        this.token = token;
    }
}
  1. 浏览器端处理：

  • 登录成功后，前端将 Token 存储到 localStorage：

    javascript 复制代码 
    // 登录请求
fetch('/login', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({username: 'admin', password: '123456'})
})
.then(res => res.json())
.then(data => {
    localStorage.setItem('token', data.token); // 存储 Token
});

// 后续请求（携带 Token）
fetch('/user/info', {
    headers: {
        'Authorization': `Bearer ${localStorage.getItem('token')}` // 携带 Token
    }
})
.then(res => res.json())
.then(userInfo => console.log('登录用户信息：', userInfo));

特点

  • 优点：无状态（服务端无需存储 Session），支持跨域、分布式部署（Token 自带用户信息），适合前后端分离项目；
  • 缺点：Token 一旦生成无法主动撤销（需通过过期时间控制或维护黑名单），Payload 不加密（敏感信息需加密存储），前端需手动处理 Token 存储与携带。

方案3：基于 OAuth2.0/OIDC（第三方登录，如微信、QQ、GitHub）

如果需要支持第三方登录（用户无需注册，通过微信/QQ 等账号登录），则使用 OAuth2.0 + OIDC 协议，浏览器通过第三方授权获取身份凭证，服务端验证后获取用户信息。

核心流程

  1. 浏览器跳转第三方授权页面（如微信登录页）；
  2. 用户授权后，第三方平台返回 code 给浏览器；
  3. 浏览器将 code 发送给后端，后端通过 code 向第三方平台请求 access_token；
  4. 后端用 access_token 调用第三方平台的用户信息接口（如微信的 /sns/userinfo），获取用户昵称、头像等信息；
  5. 后端将第三方用户信息与本地用户关联（或自动注册），生成本地登录凭证（如 Session/JWT），返回给浏览器。

代码实现（Spring Security OAuth2.0 示例，以 GitHub 登录为例）

  1. 引入依赖：
xml 复制代码 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
  1. 配置 GitHub OAuth2.0 信息（application.yml）：
yaml 复制代码 
spring:
  security:
    oauth2:
      client:
        registration:
          github:
            client-id: 你的GitHub客户端ID（从GitHub开发者平台申请）
            client-secret: 你的GitHub客户端密钥
            scope: user:email,read:user # 申请的权限（获取用户邮箱、基本信息）
        provider:
          github:
            user-info-uri: https://api.github.com/user
            email-attribute-name: email
  1. 配置 Spring Security（启用 OAuth2.0 登录）：
java 复制代码 
@Configuration
@EnableWebSecurity
public class OAuth2SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .anyRequest().authenticated()
            .and()
            .oauth2Login() // 启用 OAuth2.0 登录
                .defaultSuccessUrl("/user/info", true) // 登录成功后跳转获取用户信息
                .userInfoEndpoint()
                .userService(customOAuth2UserService); // 自定义用户信息处理（关联本地用户）
    }
}
  1. 获取登录用户信息接口：
java 复制代码 
@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/info")
    public OAuth2User getLoginUser(Authentication authentication) {
        // OAuth2User 包含第三方用户信息（如GitHub昵称、头像、ID）
        return (OAuth2User) authentication.getPrincipal();
    }
}
  1. 浏览器端表现：
  • 访问 /user/info 时，自动跳转 GitHub 登录页；
  • 用户登录授权后，跳转回 /user/info，返回 GitHub 用户信息（如昵称、头像URL）。

三、关键注意点

  1. 安全性：

    • Session + Cookie：配置 Cookie 为 HttpOnly（防止 XSS 攻击）、Secure（仅 HTTPS 传输）、SameSite（防止 CSRF 攻击）；
    • JWT：密钥需足够复杂且定期更换，敏感信息（如密码）不能存入 Payload（Payload 可解码），Token 过期时间不宜过长；
    • 所有方案都建议使用 HTTPS 传输，防止凭证被窃取。

  2. 用户信息扩展：

    • 默认的 Principal/UserDetails 仅包含用户名和角色，如需用户ID、昵称、邮箱等信息，需自定义 User 类实现 UserDetails，并在登录时注入。

  3. 跨域处理：

    • Session + Cookie：跨域时需配置 CORS 允许 credentials（凭证），前端请求需携带 withCredentials: true；
    • JWT：无跨域限制（Token 通过请求头携带），只需配置 CORS 允许 Authorization 头。

  4. 分布式部署：

    • Session + Cookie：需将 Session 存储到共享介质（如 Redis），通过 spring-session-data-redis 依赖实现；
    • JWT：天然支持分布式（无状态），无需额外配置。

总结

  • 传统项目/非前后端分离：优先使用 Session + Cookie（简单、安全、无需前端额外处理）；
  • 前后端分离/跨域/分布式项目：优先使用 JWT Token（无状态、易扩展）；
  • 第三方登录场景：使用 OAuth2.0/OIDC（对接微信、GitHub 等平台）。

无论哪种方案，浏览器获取登录信息的核心都是通过凭证关联服务端的用户身份，差异仅在于凭证的存储方式（Cookie/LocalStorage）和传递方式（自动携带/手动添加请求头）。

相关推荐
xiezhr13 小时前
Java开发中最那些常见的坑，你踩过几个？
java·spring·springboot·后端开发
原来是好奇心2 天前
Spring Boot缓存实战：@Cacheable注解详解与性能优化
java·spring·mybatis·springboot
千寻技术帮3 天前
50013_基于微信小程序的校园志愿者系统
mysql·微信小程序·springboot·文档·ppt
合作小小程序员小小店5 天前
web网页开发，在线%考试管理%系统，基于Idea,vscode,html,css,vue,java,maven,springboot,mysql
java·前端·系统架构·vue·intellij-idea·springboot
he___H5 天前
RabbitMQ 小项目之扫盲班
微服务·springboot
程序员小赵同学5 天前
Spring AI Alibaba文生图实战：从零开始编写AI图片生成Demo
阿里云·ai·springboot·springai
合作小小程序员小小店6 天前
web网页开发，在线考勤管理系统，基于Idea,html,css,vue,java,springboot,mysql
java·前端·vue.js·后端·intellij-idea·springboot
披着羊皮不是狼7 天前
多用户博客系统搭建（1）：表设计+登录注册接口
java·开发语言·springboot
IT小哥哥呀9 天前
Jenkins + Docker 打造自动化持续部署流水线
docker·微服务·自动化·jenkins·springboot·高并发·限流
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05Linux下V2Ray安装配置指南06jdk21下载、安装（Windows、Linux、macOS）072025 最新教程：注册并切换到美区 Apple ID08Labelme从安装到标注：零基础完整指南09《大数据技术原理与应用》实验报告三 熟悉HBase常用操作10综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件