@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Authorized{
  Role[] roles() default{
    Role.ADMIN, 
    Role.SALE_STAFF, 
    Role.INVENTORY_MANAGER,
    Role.FINANCIAL_STAFF, 
    Role.HR, Role.GM
  }
}

package java.lang.annotation;

/**
 * Indicates how long annotations with the annotated interface are to
 * be retained.  If no Retention annotation is present on
 * an annotation interface declaration, the retention policy defaults to
 * {@code RetentionPolicy.CLASS}.
 *
 * <p>A Retention meta-annotation has effect only if the
 * meta-annotated interface is used directly for annotation.  It has no
 * effect if the meta-annotated interface is used as a member interface in
 * another annotation interface.
 *
 * @author  Joshua Bloch
 * @since 1.5
 * @jls 9.6.4.2 @Retention
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * Returns the retention policy.
     * @return the retention policy
     */
    RetentionPolicy value();
}

package java.lang.annotation;

/**
 * Annotation retention policy.  The constants of this enumerated class
 * describe the various policies for retaining annotations.  They are used
 * in conjunction with the {@link Retention} meta-annotation interface to
 * specify how long annotations are to be retained.
 *
 * @author  Joshua Bloch
 * @since 1.5
 */
public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation interface
     * can be applied to.
     * @return an array of the kinds of elements an annotation interface
     * can be applied to
     */
    ElementType[] value();
}

public enum ElementType {
    /** Class, interface (including annotation interface), enum, or record
     * declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation interface declaration (Formerly known as an annotation type.) */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE,

    /**
     * Module declaration.
     *
     * @since 9
     */
    MODULE,

    /**
     * Record component
     *
     * @jls 8.10.3 Record Members
     * @jls 9.7.4 Where Annotations May Appear
     *
     * @since 16
     */
    RECORD_COMPONENT;
}

@Component
@Data
public class JwtConfig {

    private static String secret;

    private static long expire;

    private Key key;

    @Value("${jwt.secret}") //value在application.yml中配置
    public void setJwtSecret(String jwtSecret) { //通过set让static方法读取配置文件中的值
        JwtConfig.secret = jwtSecret;
    }

    @Value("${jwt.expire}") //value在application.yml中配置
    public void setExpire(long expire) { //通过set让static方法读取配置文件中的值
        JwtConfig.expire = expire;
    }

		//签发Jwt
    public String createJWT(UserPO userPO) {
        Date date = new Date();
        Date expireDate = new Date(date.getTime() + expire);

        String jwt = JWT.create()
                //可以将基本信息放到claims中
                .withClaim("name", userPO.getName())
                //name
                .withClaim("role", userPO.getRole().name())
                //超时设置,设置过期的日期
                .withExpiresAt(expireDate)
                //签发时间
                .withIssuedAt(new Date())
                //SECRET加密
                .sign(Algorithm.HMAC256(secret));
        return jwt;
    }

    //解析Jwt
    public Map<String, Claim> parseJwt(String token) {
        try {
            JWTVerifier verifier = JWT.require(Algorithm.HMAC256(secret)).build();
            DecodedJWT jwt = verifier.verify(token);
            return jwt.getClaims();
        } catch (TokenExpiredException e) {
            throw new MyServiceException("A0230", "用户登陆已过期");
        } catch (JWTVerificationException | IllegalArgumentException e) { //解析错误 或者 token写错
            throw new MyServiceException("A0200", "登陆失败");
        }


}

@Aspect
@Configuration
@Order(1)
public class AuthAspect {
    private final UserService userService;
		private final JwtConfig jwtConfig;
  
  @Autowired
    public AuthAspect(UserService userService, JwtConfig jwtConfig){
         this.userService = userService;
        this.jwtConfig = jwtConfig;
    }
  
  @Before(value = "execution(public * com.nju.edu.erp.web.controller.*.*(..)) && @annotation(authorized)")
    public void authCheck(JoinPoint joinPoint, Authorized authorized);
}

@GetMapping("/create")
@Authorized(roles = {Role.ADMIN, Role.GM, Role.INVENTORY_MANAGER})
public Response createCategory(@RequestParam(value = "parentId") int parentId,
                           @RequestParam(value = "name") String name) {
    return Response.buildSuccess(categoryService.createCategory(parentId, name));
}

@Service
public class UserServiceImpl implements UserService {

    private final UserDao userDao;

    private final JwtConfig jwtConfig;

    @Autowired
    public UserServiceImpl(UserDao userDao, JwtConfig jwtConfig);
  
  	@Override
    public Map<String, String> login(UserVO userVO) {
        UserPO userPO = userDao.findByNameAndPassword(userVO.getName(), userVO.getPassword());
        if (null == userPO) {
            throw new MyServiceException("A0000", "用户名或密码错误");
        }
        Map<String, String> authToken = new HashMap<>();
        String token = jwtConfig.createJWT(userPO);
        authToken.put("token", token);
        return authToken;
    }
  
  	@Override
    public int updatePassword(UserVO userVO,String newPassword);
  
    @Override
    public UserVO auth(String token);
}