Dropwizard OAuth2认证后，如何让浏览器自动在请求头携带Token？

这个问题核心在于：浏览器默认不会自动把Bearer Token加到后续请求的Authorization头里，所以你重定向到/me时，请求没有携带Token，就触发了认证失败的提示。下面给你几个适配Dropwizard场景的解决方案：

方案一：用HttpOnly Cookie存储Token（推荐） #

这是最安全且适配浏览器行为的方式，登录成功后把Token存入HttpOnly Cookie，浏览器会自动在同域的所有请求中携带这个Cookie，无需前端额外处理。

1. 修改登录接口，添加Token Cookie #

登录成功生成Token后，不要只返回重定向，同时把Token设置为HttpOnly Cookie：

// 登录成功生成token后
String generatedToken = yourTokenService.generateToken(authenticatedUser);

// 创建HttpOnly、Secure的Cookie
NewCookie authCookie = new NewCookie(
    "auth-token",          // Cookie名称
    generatedToken,        // 你的Token值
    "/",                   // 路径：确保所有请求都携带
    null,                  // 域名：根据你的部署环境设置，比如"yourdomain.com"
    NewCookie.DEFAULT_VERSION,
    null,
    3600,                  // 过期时间（秒），这里设1小时
    null,
    true,                  // HttpOnly：防止XSS攻击窃取Token
    true                   // Secure：生产环境建议开启，只在HTTPS下传输
);

// 返回重定向并携带Cookie
return Response.seeOther(new URI("/me"))
    .cookie(authCookie)
    .build();

2. 自定义AuthFilter从Cookie提取Token #

原来的OAuthCredentialAuthFilter默认从Authorization头拿Token，我们需要修改它，让它优先从Cookie读取Token：

public class TokenAuthenticator implements Authenticator<String, User> {
    private final YourTokenService tokenService;

    public TokenAuthenticator(YourTokenService tokenService) {
        this.tokenService = tokenService;
    }

    @Override
    public Optional<User> authenticate(String token) throws AuthenticationException {
        // 原有的Token验证逻辑：根据Token获取用户
        return tokenService.validateAndGetUser(token);
    }

    // 自定义Filter，支持从Cookie提取Token
    public static class CookieAwareOAuthFilter extends OAuthCredentialAuthFilter<User> {
        @Override
        protected Optional<String> getCredentials(HttpServletRequest request) {
            // 先从Cookie找Token
            Cookie[] cookies = request.getCookies();
            if (cookies != null) {
                for (Cookie cookie : cookies) {
                    if ("auth-token".equals(cookie.getName())) {
                        return Optional.of(cookie.getValue());
                    }
                }
            }
            // 如果Cookie里没有， fallback到Authorization头（保持兼容性）
            return super.getCredentials(request);
        }
    }
}

3. 注册自定义Filter到Dropwizard #

在Application的run方法里，替换原来的AuthFilter为我们自定义的：

environment.jersey().register(new AuthDynamicFeature(
    new TokenAuthenticator.CookieAwareOAuthFilter.Builder<User>()
        .setAuthenticator(new TokenAuthenticator(tokenService))
        .setAuthorizer(new TokenAuthorizer())
        .setPrefix("Bearer") // 这里前缀可以保留，不影响Cookie提取逻辑
        .buildAuthFilter()
));
environment.jersey().register(RolesAllowedDynamicFeature.class);
environment.jersey().register(new AuthValueFactoryProvider.Binder<>(User.class));

方案二：传统Session认证（适合纯服务器端渲染场景） #

如果你的应用是纯服务器端渲染（没有前端JS交互），也可以放弃OAuth2 Token，改用Dropwizard支持的Session机制，浏览器会自动携带Session Cookie：

1. 登录接口存入Session #

@POST
@Path("/login")
public Response login(@FormParam("username") String username, @FormParam("password") String password, @Context HttpServletRequest request) {
    // 验证用户名密码，得到authenticatedUser
    User authenticatedUser = yourAuthService.authenticate(username, password);
    
    // 把用户存入Session
    HttpSession session = request.getSession();
    session.setAttribute("currentUser", authenticatedUser);
    
    return Response.seeOther(new URI("/me")).build();
}

2. 实现Session-based的Authenticator #

public class SessionAuthenticator implements Authenticator<ContainerRequest, User> {
    @Override
    public Optional<User> authenticate(ContainerRequest request) throws AuthenticationException {
        // 从请求中获取HttpServletRequest
        HttpServletRequest httpRequest = request.getProperty(HttpServletRequest.class.getName());
        HttpSession session = httpRequest.getSession(false); // 不创建新Session
        
        if (session != null) {
            User user = (User) session.getAttribute("currentUser");
            return Optional.ofNullable(user);
        }
        return Optional.empty();
    }
}

3. 注册Session认证 #

environment.jersey().register(new AuthDynamicFeature(
    new AuthFilter.Builder<User>()
        .setAuthenticator(new SessionAuthenticator())
        .setAuthorizer(new TokenAuthorizer())
        .buildAuthFilter()
));
// 其他注册保持不变
environment.jersey().register(RolesAllowedDynamicFeature.class);
environment.jersey().register(new AuthValueFactoryProvider.Binder<>(User.class));

方案三：前端手动添加请求头（适合前后端分离） #

如果你的页面有前端JS（比如用AJAX请求），可以在登录成功后把Token存在localStorage或sessionStorage，然后用请求拦截器给每个请求加上Authorization头：

// 登录成功后存储Token
localStorage.setItem("authToken", generatedToken);

// 用axios的拦截器自动添加头
axios.interceptors.request.use(config => {
    const token = localStorage.getItem("authToken");
    if (token) {
        config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
});

不过这个方案更适合前后端分离的场景，你的Dropwizard Views是服务器端渲染，所以前两个方案更贴合你的需求。

内容的提问来源于stack exchange，提问作者TM00