Java鉴权功能设计指南 - 使用Token和自定义注解

本文将介绍如何在Java中设计一个基于Token的鉴权功能。我们将使用JSON Web Token（JWT）作为Token的实现，因为它具有较好的安全性和易用性。我们还将使用自定义注解来实现鉴权验证。

2. Token颁发

当用户登录成功后，我们需要颁发一个Token，表示用户已经过验证。以下是一个简单的Token颁发过程：

2.1 添加JWT库

首先，我们需要将JWT库添加到项目中。对于Maven项目，可以在pom.xml中添加以下依赖：

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

2.2 创建Token

使用JWT库，我们可以轻松创建Token。以下是一个简单的Token生成示例：

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;

public class TokenUtils {
    private static final String SECRET_KEY = "your_secret_key";
    private static final long EXPIRATION_TIME = 86400000; // 1 day

    public static String createToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }
}

3. 自定义注解实现鉴权验证

为了在需要鉴权验证的地方使用自定义注解，我们需要执行以下操作：

3.1 创建自定义注解

我们首先创建一个名为@RequireAuth的自定义注解：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface RequireAuth {
}

3.2 实现鉴权拦截器

接下来，我们需要实现一个鉴权拦截器，该拦截器将在每个请求到达控制器之前执行。在拦截器中，我们可以执行以下操作：

• 检查请求的方法或类上是否有@RequireAuth注解。
• 如果有@RequireAuth注解，则从请求头中获取Token，并验证Token的有效性。

以下是一个基于Spring的鉴权拦截器示例：

import io.jsonwebtoken.Jwts;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.httpHttpServletResponse;
 import java.lang.reflect.Method;
public class AuthInterceptor implements HandlerInterceptor {
  private static final String SECRET_KEY = "your_secret_key";

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    // 检查请求的方法或类上是否有@RequireAuth注解
    if (handler instanceof HandlerMethod) {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        Class<?> declaringClass = method.getDeclaringClass();

        if (declaringClass.isAnnotationPresent(RequireAuth.class) || method.isAnnotationPresent(RequireAuth.class)) {
            // 从请求头中获取Token
            String token = request.getHeader("Authorization");

            // 验证Token的有效性
            if (token == null || !validateToken(token)) {
                response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized.");
                return false;
            }
        }
    }

    return true;
}

private boolean validateToken(String token) {
    try {
        Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token);
        return true;
    } catch (Exception e) {
        return false;
    }
}

  

3.3 注册鉴权拦截器

最后，我们需要将鉴权拦截器注册到Spring MVC配置中

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

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new AuthInterceptor());
    }
}

4. 使用自定义注解

现在，我们可以在需要鉴权验证的控制器方法或类上使用@RequireAuth注解：

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

@RestController
public class MyController {

    @RequireAuth
    @GetMapping("/protected")
    public String getProtectedResource() {
        return "This is a protected resource.";
    }

    @GetMapping("/public")
    public String getPublicResource() {
        return "This is a public resource.";
    }
}

5. 总结

本文介绍了如何在Java中设计一个基于Token的鉴权功能，并使用自定义注解实现验证。我们使用JWT作为Token的实现，并创建了一个名为@RequireAuth的自定义注解。通过实现鉴权拦截器，我们可以在请求到达控制器之前验证Token的有效性。最后，我们可以在需要鉴权验证的控制器方法或类上使用@RequireAuth注解。

这种方法允许我们轻松地为应用程序添加鉴权功能，并确保只有经过授权的用户才能访问受保护的资源。