Java 安全认证与权限控制实战

配置 URL 级别的访问控制

下面这个配置展示了典型的 URL 拦截思路：静态资源放行，根路径限制为管理员访问，其他路径按业务需要继续配置。

<bean id="filterChainProxy" class="org.springframework.security.web.FilterChainProxy">
 <sec:http>
     <sec:intercept-url pattern="/resources/**" access="permitAll"/>
     <sec:intercept-url pattern="/" access="hasRole('ROLE_ADMIN')"/>
     <sec:intercept-url pattern="/*" />

     <sec:http-basic entry-point-ref="authenticationEntryPoint"/>
 </sec:http>
</bean>

这里需要注意一点：intercept-url 的顺序很重要。匹配规则是按顺序生效的，越具体的规则越应该放在前面，否则很容易被更宽泛的规则覆盖。

使用方法注解控制权限

除了 URL 拦截，Spring Security 也常用方法级注解做细粒度授权。这样做的好处是，权限规则可以直接贴近业务代码，维护起来更直观。

@RestController
public class MyController {

    @RequestMapping("/admin")
    @PreAuthorize("hasAuthority('permission:accessAdminPage')")
    public String admin() {
        return "Welcome Admin!";
    }

    @RequestMapping("/user")
    @RolesAllowed({"ROLE_USER", "ROLE_MANAGER"})
    public String user() {
        return "Hello User";
    }
}

@PreAuthorize 更适合表达复杂权限表达式，而 @RolesAllowed 更偏向角色判断。两者并不冲突，关键在于你想表达的是'某个具体权限'还是'某个角色集合'。

如果用户没有满足条件，Spring Security 会直接返回 403 Forbidden。这个行为在后端权限控制里很常见，也很清晰。

Spring Security 与 JWT 集成

在前后端分离或多服务协作的架构里，JWT 是很常见的认证方案。它的优势是无状态、可携带信息、便于跨服务传递身份。

这里以 RSA 签名思路为例说明整体流程：服务端签发 JWT，客户端在后续请求中携带 Token，服务端校验 Token 后再决定是否放行。

服务端依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

生成和解析 JWT

下面这个 JwtConfig 负责生成 Token 和解析 Token。Token 里包含用户名、签发时间、过期时间等信息，签名后交给客户端保存。

import io.jsonwebtoken.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class JwtConfig {

  @Value("${jwt.secret}")
  private String secret;

  public String generateToken(String username){
      Map<String, Object> map = new HashMap<>();
      map.put("username", username);
      Date now = new Date();
      Calendar calendar = Calendar.getInstance();
      calendar.add(Calendar.MINUTE, 10);
      Date expirationTime = calendar.getTime();

      return Jwts.builder().setHeaderParam("typ", "JWT").setClaims(map).setIssuer("auth.com").setSubject("subject")
             .setAudience("audience").setId("id").setIssuedAt(now).setNotBefore(now)
             .setExpiration(expirationTime).signWith(SignatureAlgorithm.HS512, this.secret).compact();
  }

  public String getUsernameFromToken(String token){
      Claims claims = Jwts.parser().setSigningKey(this.secret).parseClaimsJws(token).getBody();
      return claims.getSubject();
  }

  @Bean
  public JwtTokenProvider getTokenProvider(){
    return new JwtTokenProvider();
  }
}

这里有个细节值得留意：getUsernameFromToken 实际读取的是 subject，而 generateToken 里把用户名放进了 claims。如果你打算通过 subject 取用户名，生成时也要一致地写入；否则后续解析出来的值可能并不是你预期的用户名。

从请求中提取 JWT

JwtTokenProvider 的作用是从请求头里取出 Token，再交给 Spring Security 去完成认证。

import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.MalformedJwtException;
import io.jsonwebtoken.UnsupportedJwtException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Component
public class JwtTokenProvider{

  @Autowired
  private UserDetailsService userDetailsService;

  @Autowired
  private JwtConfig config;

  public Authentication getAuthentication(HttpServletRequest request) throws IOException, ExpiredJwtException, UnsupportedJwtException, MalformedJwtException {
    final String authorizationHeader = request.getHeader("Authorization");
    if (authorizationHeader == null || !authorizationHeader.startsWith("Bearer ")) {
      throw new RuntimeException("JWT Token not found");
    }
    final String token = authorizationHeader.substring(7);
    final String username = config.getUsernameFromToken(token);
    return userDetailsService.loadUserByUsername(username);
  }
}

实际项目里，一般还会补上过期校验、签名校验失败处理和异常映射，否则前端收到的错误会比较粗糙。这个例子保留了核心链路，思路是清楚的：拿到 Token、解析出用户名、再加载用户详情交给 Spring Security 处理。

前端如何携带 JWT

前端通常会在请求拦截器里自动加上 Authorization 头。这样业务代码不需要每次手工拼接 Token，请求层就能把认证信息统一带上。

import axios from 'axios';
class AxiosAuthPlugin {
  constructor(token) {
    this._token = `Bearer ${token}`;
  }

  request(config) {
    const headers = config.headers || {};
    headers['Authorization'] = this._token;
    config.headers = headers;
    return config;
  }
}

const instance = axios.create({
  baseURL: process.env.VUE_APP_BASE_URL || '/',
  timeout: parseInt(process.env.VUE_APP_TIMEOUT) || 10000
});

instance.interceptors.request.use((config) => {
  let token = localStorage.getItem('token');
  if (!token && JSON.stringify(config.data).includes('refresh')) {
    return Promise.reject(new Error('No refresh token provided'));
  } else {
    token = token ? JSON.parse(token).access_token : '';
    config.headers = {'Authorization': `${token}`};
    return config;
  }
}, error => {
  return Promise.reject(error);
});

export default function createAxiosInstance() {
  return instance;
}

这段代码的逻辑很典型：普通请求直接带上 access_token，刷新请求则单独处理。这样做能把'访问接口'和'续期 Token'这两条链路分开，失败时也更容易定位问题。

在 Vue 中调用时，通常会把登录、刷新和拉取数据的流程串起来：

import plugin from './AxiosAuthPlugin';
const instance = plugin.createAxiosInstance();

async login() {
  try {
    const res = await instance.post('/login', {username, password});
    localStorage.setItem('token', JSON.stringify(res));
    router.push('/');
  } catch (err) {
    console.log(`Login failed, message:${err}`);
  }
},

async refreshToken() {
  try {
    const refreshToken = JSON.parse(localStorage.getItem('token')).refresh_token;
    const res = await instance.post('/token/refresh', {refresh_token: refreshToken});
    localStorage.setItem('token', JSON.stringify(res));
  } catch (err) {
    console.log(`Refresh token failed, message:${err}`);
    localStorage.removeItem('token');
    alert('Please log in again.');
    router.push('/login');
  }
},

async getData() {
  try {
    const res = await instance.get('/data');
    return res.data;
  } catch (err) {
    console.log(`Get data failed, message:${err}`);
    if (err.response && err.response.status === 401) {
      await refreshToken();
      const newData = await getData();
      return newData;
    }
    throw err;
  }
}

这里的关键点是：当接口返回 401 时，不要急着让用户重新登录，可以先尝试刷新 Token。只有刷新失败，再把用户引导回登录页。这样体验会顺很多。

实践中的一些提醒

JWT 和 Spring Security 结合起来很方便，但落地时别忽略这些问题：

• Token 不要存得太久，过期时间要合理。
• 解析和校验失败要统一处理，避免前端拿到一堆杂乱异常。
• 如果是敏感系统，优先考虑 HTTPS，避免 Token 在传输过程中被窃取。
• 浏览器本地存储并不是最安全的方案，生产环境里要结合业务风险谨慎选择。
• 权限模型不要一开始就设计得过重，先保证清晰可维护，再逐步细化。

小结

认证解决的是'你是谁'，权限控制解决的是'你能做什么'。在 Java 体系里，Spring Security 提供了比较完整的支撑：既能做 URL 级别拦截，也能做方法级授权，还能和 JWT 这类无状态认证方案配合使用。实际项目里，RBAC 适合做主骨架，ABAC 适合补细节，二者结合起来，通常更容易在安全性和可维护性之间找到平衡。