首页 > 文章 > java教程

Java跨域Token认证与登录方案

时间：2025-07-20 16:59:37 250浏览收藏

在Java前后端分离架构中，跨域Token传递与登录认证是关键环节。本文深入探讨了如何通过合理配置CORS策略和Token机制（如JWT）实现安全可靠的跨域认证。首先，详细阐述了后端（Spring Boot）全局与局部CORS配置方法，强调`allowCredentials(true)`的重要性，并演示了前端（axios）如何携带Token发起请求。其次，分析了JWT无状态认证的优势及其在登录流程中的应用，包括Token存储、请求头附加和后端验证。此外，文章还对比了Session-Cookie、OAuth 2.0等其他认证策略，总结了在不同场景下的适用性，为开发者提供全面的Java跨域Token传递与登录认证解决方案，助力构建安全高效的Web应用。

要在Java前后端实现跨域Token传递和登录认证，核心在于后端正确配置CORS策略并支持凭证传递，同时前端需配合携带Token。1. 后端使用Spring Boot时可通过实现WebMvcConfigurer接口进行全局CORS配置，明确允许来源、方法、头信息，并设置allowCredentials(true)以支持凭证；2. 局部CORS可通过@CrossOrigin注解实现；3. 前端使用axios时应配置withCredentials: true，并在请求拦截器中添加Authorization头携带JWT；4. 登录成功后前端将Token存储于localStorage并在后续请求中自动附加至请求头；5. 后端验证JWT签名并解析用户信息完成认证。此外，还可考虑Session-Cookie、OAuth 2.0或API Key等其他认证方式，但JWT因其无状态性更适用于分布式系统。

如何使用Java进行跨域Token传递 Java前后端登录认证策略

要在Java前后端实现跨域Token传递和登录认证，核心在于后端正确配置CORS（跨域资源共享）策略，允许前端在不同域名下发送带有凭证的请求，同时前端也需要配合设置。通常，我们会采用基于Token（如JWT）的无状态认证方式，因为它天然适合分布式和跨域场景。

解决方案

在我看来，处理跨域Token传递和登录认证，主要围绕两点展开：一是确保后端CORS配置的严谨与灵活，二是前端在发送请求时能正确携带并处理Token。

后端（Java/Spring Boot为例）的CORS配置

Spring Boot提供了非常便捷的CORS配置方式。你可以选择全局配置，也可以针对特定控制器或方法进行细粒度控制。

全局CORS配置： 这是我个人比较推荐的做法，尤其是在项目初期或CORS策略相对统一的情况下。通过实现WebMvcConfigurer接口并重写addCorsMappings方法，可以集中管理所有CORS规则。

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**") // 允许所有路径进行CORS
                .allowedOrigins("http://localhost:3000", "https://your-frontend-domain.com") // 明确指定允许的来源，避免使用"*"
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") // 允许的HTTP方法
                .allowedHeaders("*") // 允许所有请求头
                .allowCredentials(true) // 允许发送Cookie或HTTP认证信息
                .exposedHeaders("Authorization", "X-Auth-Token") // 暴露自定义头，前端才能访问
                .maxAge(3600); // 预检请求的缓存时间，单位秒
    }
}

这里特别需要注意的是allowedOrigins，不要图省事直接用*，这会带来安全隐患。还有allowCredentials(true)是关键，它允许前端发送附带凭证（如Cookie或Authorization头）的请求。如果你的Token是放在响应头中返回给前端的，那么exposedHeaders也至关重要，否则前端JavaScript无法读取到这些自定义的响应头。

局部CORS配置： 如果你只想对某个控制器或方法开启CORS，可以使用@CrossOrigin注解。

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@CrossOrigin(origins = "http://localhost:3000", allowCredentials = "true")
public class AuthController {

    @GetMapping("/api/hello")
    public String hello() {
        return "Hello from backend!";
    }
}

这种方式在某些特定API需要特殊CORS规则时非常有用。

前端（JavaScript/React/Vue等）的请求配置

前端在发送跨域请求时，需要明确告诉浏览器，这个请求是允许携带凭证的。以axios为例：

import axios from 'axios';

// 配置axios实例，确保每次请求都带上凭证
const api = axios.create({
  baseURL: 'http://localhost:8080', // 后端API地址
  withCredentials: true, // 允许携带Cookie或HTTP认证信息
});

// 登录请求
async function login(username, password) {
  try {
    const response = await api.post('/login', { username, password });
    // 假设后端登录成功后返回JWT Token在响应体或响应头中
    const token = response.data.token || response.headers['authorization'];
    if (token) {
      localStorage.setItem('jwt_token', token); // 将Token存储到localStorage
      console.log('登录成功，Token已存储');
    }
    return response.data;
  } catch (error) {
    console.error('登录失败:', error);
    throw error;
  }
}

// 后续请求，从localStorage中获取Token并添加到请求头
api.interceptors.request.use(
  config => {
    const token = localStorage.getItem('jwt_token');
    if (token) {
      config.headers.Authorization = `Bearer ${token}`; // 标准做法是Bearer Token
    }
    return config;
  },
  error => {
    return Promise.reject(error);
  }
);

// 示例：访问受保护资源
async function getProtectedData() {
  try {
    const response = await api.get('/api/protected');
    console.log('受保护数据:', response.data);
    return response.data;
  } catch (error) {
    console.error('获取受保护数据失败:', error);
    // 可以在这里处理Token过期或无效的情况，比如跳转到登录页
    if (error.response && error.response.status === 401) {
        console.log("Token过期或无效，请重新登录。");
        // window.location.href = '/login'; // 示例：跳转到登录页
    }
    throw error;
  }
}

// 调用示例
// login('user', 'password').then(() => {
//   getProtectedData();
// });

前端的withCredentials: true非常关键，它告诉浏览器在跨域请求时也要发送Cookie（如果你的Token是放在HttpOnly Cookie里的话），或者允许后端设置Access-Control-Allow-Credentials为true时，通过Authorization头传递Token。

Token认证策略（JWT）

JWT（JSON Web Token）是当前非常流行的无状态认证方案。

登录流程： 用户提供凭证（用户名/密码），后端验证通过后，生成一个JWT。这个JWT包含用户ID、角色等信息，并用密钥签名。
Token传递： 后端将生成的JWT返回给前端。前端通常会将这个Token存储在localStorage、sessionStorage或HttpOnly的Cookie中。
后续请求： 前端在后续每次请求时，都将这个JWT放在HTTP请求的Authorization头中，格式通常是Authorization: Bearer 。
后端验证： 后端收到请求后，从Authorization头中提取JWT，使用相同的密钥验证其签名，并解析出用户身份信息。如果验证通过，就允许访问资源。

JWT的优势在于它的无状态性，后端不需要存储Session信息，这对于分布式系统和微服务架构非常有利。

为什么跨域Token传递会成为一个“痛点”？

在我看来，跨域Token传递之所以成为一个“痛点”，根源在于浏览器“同源策略”（Same-Origin Policy）的严格限制，以及安全与便利性之间的永恒矛盾。

同源策略是浏览器为了安全而设立的一道防线，它规定了只有协议、域名、端口都相同的资源才能互相访问。这就像给每个网站划了一块地盘，防止A网站未经许可读取或修改B网站的数据。这本意是好的，极大程度上避免了恶意网站的攻击。

然而，在现代Web应用中，前后端分离、微服务架构已经成为主流。前端可能部署在app.example.com，后端API则在api.example.com，甚至不同的服务在service1.api.example.com和service2.api.example.com。这时候，同源策略就成了“拦路虎”。前端想调用后端API，浏览器会因为域名不同而直接拒绝请求，并报错“Cross-Origin Request Blocked”。

Token作为用户身份的凭证，它需要在每次请求中从前端传递到后端。如果浏览器不允许跨域请求，Token自然也无法顺利送达。解决这个问题的核心就是CORS（跨域资源共享），它像是给同源策略打了个“补丁”，允许服务器明确告诉浏览器：“嘿，虽然我跟请求方不在同一个源，但我是信任它的，你可以让它访问我的资源。”

但CORS的配置本身又是一门学问。仅仅是允许跨域还不够，如果涉及到敏感信息（比如登录凭证），你还需要允许前端携带credentials（如Cookie或Authorization头），并且后端也必须明确响应Access-Control-Allow-Credentials: true。这其中任何一个环节出了问题，比如后端忘了设置exposedHeaders，前端就拿不到响应头里的Token；或者allowedOrigins写错了，前端请求就会被拒绝，都会导致跨域Token传递失败。

所以，与其说它是“痛点”，不如说它是一个典型的安全与便利性平衡的挑战。既要确保数据安全，又要让不同源的应用能够协同工作，这要求开发者对CORS机制有深入理解，并能进行精细化配置。

Java后端如何优雅地处理CORS请求？

在Java后端，尤其是使用Spring Boot时，处理CORS请求确实可以做到相当优雅。我个人觉得，Spring框架在这一块的设计非常人性化，提供了多种层面的支持，让你能根据项目的具体需求选择最合适的方案。

1. 全局配置 CorsConfigurationSource 或 WebMvcConfigurer

这是我最常使用的方式，因为它能集中管理所有CORS规则，避免了在每个控制器上重复添加注解。通过实现WebMvcConfigurer接口并重写addCorsMappings方法，你可以定义一个通用的CORS策略，适用于你所有或大部分API。

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**") // 匹配所有路径
                .allowedOrigins("http://localhost:3000", "https://your-frontend.com") // 明确允许的来源，非常重要
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") // 允许的HTTP方法
                .allowedHeaders("*") // 允许所有请求头，也可以指定具体的头
                .allowCredentials(true) // 允许携带认证信息（如Cookie或Authorization头）
                .exposedHeaders("Authorization", "X-Custom-Header") // 如果后端响应头中包含自定义信息，需要暴露
                .maxAge(3600); // 预检请求的缓存时间，减少浏览器发送OPTIONS请求的频率
    }
}

这里面的addMapping("/**")表示这个CORS规则适用于所有API路径。allowedOrigins是重中之重，我总是强调要列出具体的域名，而不是简单地用*，因为后者会大幅降低安全性。allowCredentials(true)则是为了支持前端发送带有Cookie或Authorization头（Bearer Token）的请求。如果后端在响应中自定义了头信息（比如新的Token或者一些业务状态码），并且前端需要读取这些头，那么exposedHeaders就不能省略。maxAge则是一个性能优化点，它告诉浏览器预检请求（OPTIONS请求）的结果可以缓存多久。

2. 使用 @CrossOrigin 注解

对于一些特殊情况，或者当你需要为某个特定的控制器或方法设置独特的CORS规则时，@CrossOrigin注解就显得非常方便。它可以直接放在类上或方法上。

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@CrossOrigin(origins = "http://specific-domain.com", allowCredentials = "true") // 针对此控制器生效
public class SpecialController {

    @GetMapping("/special-api")
    public String getSpecialData() {
        return "This is special data.";
    }

    @CrossOrigin(origins = "http://another-domain.com") // 针对此方法生效，会覆盖类级别的配置
    @GetMapping("/another-special-api")
    public String getAnotherSpecialData() {
        return "This is another special data.";
    }
}

这种方式的优点是直观，配置与业务代码紧密相连。但如果大量使用，可能会导致CORS配置分散，管理起来稍显不便。我通常会优先考虑全局配置，只在确实需要例外时才使用@CrossOrigin。

3. 自定义 Filter

虽然Spring Boot的内置支持已经很强大，但在一些非Spring框架项目，或者需要更细粒度、更复杂的CORS逻辑时，自定义一个javax.servlet.Filter也是一个选择。你可以在doFilter方法中手动设置HttpServletResponse的CORS相关头信息。

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

// @Component // 如果要让Spring管理这个Filter
// @Order(Ordered.HIGHEST_PRECEDENCE) // 确保Filter执行顺序靠前
public class CustomCorsFilter implements Filter {

    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        HttpServletRequest request = (HttpServletRequest) req;

        response.setHeader("Access-Control-Allow-Origin", "http://localhost:3000");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, X-Requested-With");
        response.setHeader("Access-Control-Allow-Credentials", "true"); // 允许携带凭证

        // 处理预检请求
        if ("OPTIONS".equalsIgnoreCase(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);
        } else {
            chain.doFilter(req, res);
        }
    }

    // 省略init和destroy方法
}

这种方式提供了最大的灵活性，但实现起来相对繁琐，并且需要手动处理OPTIONS预检请求。在Spring Boot项目中，我通常不会首选这种方式，除非有非常特殊的集成需求。

总的来说，Spring Boot的WebMvcConfigurer或@CrossOrigin注解已经能够优雅地解决绝大多数CORS问题。关键在于理解每个配置项的含义，并根据实际安全需求进行精确配置。

除了Token，还有哪些前后端认证策略可以考虑？

除了我们前面提到的基于Token（尤其是JWT）的认证策略，前后端认证其实还有其他几种常见方案。每种方案都有其适用场景、优缺点，选择哪一种，往往取决于项目的规模、安全性要求、团队熟悉度以及架构设计。

1. Session-Cookie 认证

这是最传统的认证方式，也是很多早期Web应用和单体应用的首选。

工作原理： 用户登录后，后端服务器会在内存或数据库中创建一个Session，存储用户的状态信息（比如用户ID、登录时间等），然后生成一个唯一的Session ID，通过HTTP响应头中的Set-Cookie字段将其发送给浏览器。浏览器接收到Session ID后，会将其存储在Cookie中，并在后续每次请求时自动带上这个Cookie。后端服务器通过Session ID来查找对应的Session，从而识别用户。
优点：
- 实现简单： 很多Web框架（如Spring MVC、Servlet）都内置了Session管理，开箱即用。
- 安全性高（相对）： Session ID本身是无意义的，且存储在Cookie中，配合HttpOnly和Secure属性可以有效防止XSS攻击和中间人攻击。Session信息存储在服务器端，客户端无法篡改。
缺点：
- 有状态性： 服务器需要维护Session状态，这在分布式系统（多台服务器）下会成为一个大问题，需要Session共享机制（如Sticky Session、Redis、数据库存储Session），增加了架构复杂性。
- 扩展性差： 随着用户量增加，Session存储会消耗大量服务器资源。
- 跨域挑战： Cookie默认受同源策略限制，跨域传递Cookie需要复杂的CORS配置，且容易受到CSRF攻击（需要额外的CSRF Token防御）。
- 移动端不友好： 移动App通常不依赖Cookie，Session-Cookie认证在App端实现起来比较麻烦。

2. OAuth 2.0 / OpenID Connect (OIDC)

这通常不是直接的用户登录认证策略，而是一种授权框架，用于第三方应用访问用户资源，或者实现单点登录（SSO）。

工作原理： 用户通过第三方身份提供者（如Google、GitHub、微信）进行认证，然后授权第三方应用访问其在身份提供者处的某些资源。OAuth 2.0主要关注授权，而OpenID Connect则在OAuth 2.0的基础上增加了身份认证层。
优点：
- 安全性高： 用户无需将自己的凭证暴露给第三方应用。
- 标准协议： 广泛应用于各种场景，生态成熟。
- 实现SSO： 方便用户在多个应用之间无缝切换。
缺点：
- 复杂性高： 协议流程相对复杂，对于简单的前后端认证场景来说，可能过于重量级。
- 不适合直接的API认证： 它更侧重于授权，而不是像JWT那样直接作为API访问凭证。

3. API Key 认证

主要用于机器到机器的认证，或者公共API的简单访问控制。

工作原理： 客户端在请求中携带一个预先分配的API Key（通常放在请求头或URL参数中），后端验证这个Key的有效性。
优点：
- 简单直接： 实现和使用都非常简单。
缺点：
- 安全性较低： API Key通常是长期有效的，一旦泄露，风险较大。通常不适合直接用于用户登录认证。
- 无法识别具体用户： 只能识别是哪个“应用”或“客户端”发出的请求，无法区分具体是哪个用户。

总结

在我看来，在当前前后端分离和微服务盛行的时代，JWT（Token）认证无疑是主流且推荐的选择。它的无状态性完美契合了分布式系统的需求，解决了Session-Cookie在扩展性上的痛点，同时通过签名机制保证了Token的不可篡改性。

Session-Cookie认证在一些传统项目或单体应用中仍然有其价值，尤其是在严格要求防止CSRF攻击且服务器可以维护状态的场景。而OAuth 2.0/OIDC则更侧重于解决身份联邦和授权委托的问题，它与JWT常常是结合使用的，比如OAuth 2.0流程最终会颁发一个JWT作为访问令牌。API Key则更偏向于服务间或公共API的简单鉴权。

选择哪种策略，始终是权衡安全、性能、扩展性和开发复杂度的结果。但对于大多数现代Web应用，我都会毫不犹豫地选择JWT作为前后端登录认证的核心策略。

以上就是《Java跨域Token认证与登录方案》的详细内容，更多关于jwt,前后端分离,Java跨域,Token认证,CORS配置的资料请关注golang学习网公众号！

jwt 前后端分离 Java跨域 Token认证 CORS配置