JAVA自定义注解+AOP实现认证授权

还记得JAVA实现认证授权的常见方式吗？

1. 基于过滤器（Filter）：在 Web 应用中，可以使用 Servlet 过滤器来拦截请求，并在其中进行认证和授权检查。例如，实现 javax.servlet.Filter 接口，在 doFilter 方法中进行处理。
2. 基于 Spring Security：这是一个强大的安全框架，提供了丰富的认证和授权功能，包括用户认证、角色权限管理、密码加密等。
3. 基于 Shiro：这是一个功能强大且易于使用的安全框架，支持身份验证、授权、加密、会话管理等功能。
4. 基于令牌（Token）：例如 JWT（JSON Web Token），客户端在登录成功后获取令牌，后续请求携带令牌，服务端验证令牌的有效性和权限。
5. 基于数据库权限表：在数据库中维护用户、角色和权限的关系表，在业务逻辑中根据用户信息查询权限表来进行认证授权。

今天我们来讲解一个不常见的：基于自定义注解+AOP的授权

以下是上述几种认证授权方式的优缺点：

1. 基于过滤器（Filter）

优点：

• 简单直接，易于理解和实现。
• 可以在请求到达业务逻辑之前进行处理。

缺点：

• 对于复杂的认证授权逻辑，代码可能会变得复杂且难以维护。
• 与特定的 Web 框架紧密耦合。

    2.基于 Spring Security

优点：

• 功能强大，提供了全面的认证和授权机制。
• 支持多种认证方式和权限管理策略。
• 与 Spring 框架集成良好。

缺点：

• 学习曲线相对较高，配置较为复杂。
• 可能会引入一些额外的开销。

3.基于 Shiro

优点：

• 易于使用和配置。
• 提供了灵活的认证和授权策略。

缺点：

• 相对于一些大型框架，可能在功能的全面性上略有不足。

4.基于令牌（Token）

优点：

• 无状态，易于扩展和分布式部署。
• 可以减少服务器端的会话管理开销。

缺点：

• 令牌的安全性需要妥善处理，如防止令牌泄露和篡改。
• 令牌的有效期管理需要仔细设计。

5.基于数据库权限表

优点：

• 数据存储和权限管理相对直观。

缺点：

• 每次请求都需要进行数据库查询，可能影响性能。
• 权限变更时需要同步更新数据库，可能存在一定的延迟。

6.基于自定义注解 + AOP 这种认证授权方式的优缺点分析：

优点：

1. 灵活性高：可以根据具体的业务需求自定义注解的属性和行为，实现非常个性化的认证授权规则。
2. 代码解耦：将认证授权逻辑从业务代码中分离出来，使得业务代码更加专注于核心功能，提高了代码的可读性和可维护性。
3. 集中管理：认证授权的逻辑集中在 AOP 切面中，便于统一管理和修改。

缺点：

1. 复杂性：实现自定义注解和 AOP 切面需要对 Java 注解和 AOP 机制有较深入的理解，增加了一定的技术门槛。
2. 调试困难：由于认证授权逻辑分布在切面中，调试时可能相对复杂，需要对 AOP 的执行流程有清晰的认识。
3. 性能影响：虽然 AOP 在大多数情况下性能影响较小，但如果切面中的逻辑过于复杂或者频繁执行，可能会对性能产生一定的影响。

综合来看，基于自定义注解 + AOP 的认证授权方式在一些对灵活性和代码结构有较高要求的场景中具有优势，但在简单项目或者对性能要求极为苛刻的场景中，可能需要谨慎考虑。

先不讲其他的认证授权方式，今天的主角是它：自定义注解 + AOP！

回头我再记录一期关于各种认证授权方式的详解

以下是一个使用自定义注解和 AOP（面向切面编程）实现认证授权的简单示例：

首先，定义一个自定义注解：

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

@Retention(RetentionPolicy.RUNTIME)
public @interface Authenticated {
    // 可以添加一些属性，例如权限级别等
}

解析：

@Retention(RetentionPolicy.RUNTIME) 是 Java 注解中的一个设置，用于指定注解的保留策略。

RetentionPolicy.RUNTIME 表示该注解在运行时仍然可以被获取和使用。这意味着在程序运行时，可以通过反射机制来获取这个注解，并根据注解的信息执行相应的逻辑。

那么问题来了，自定义注解为什么要用@Retention(RetentionPolicy.RUNTIME)呢?

使用 `@Retention(RetentionPolicy.RUNTIME)` 是为了确保自定义的注解在运行时仍然可用和可访问。 `RetentionPolicy` 用于指定注解的保留策略，它有以下几种取值：

1. `RetentionPolicy.SOURCE`：注解仅在源代码级别保留，不会被编译进字节码文件，在编译阶段之后就不可用了。

2. `RetentionPolicy.CLASS`：注解在编译后的字节码文件中保留，但在运行时无法获取到。

3. `RetentionPolicy.RUNTIME`：注解会被编译进字节码文件，并且在运行时可以通过反射机制获取和处理。

当希望在运行时能够读取和处理注解的信息，以实现一些动态的功能（如通过反射获取注解并根据注解的值执行不同的逻辑）时，就需要将注解的保留策略设置为 `RetentionPolicy.RUNTIME`。

如果不加@Retention(RetentionPolicy.RUNTIME)会怎么样呢？

如果不加 @Retention(RetentionPolicy.RUNTIME) ，默认的保留策略通常是 RetentionPolicy.CLASS 。这意味着该注解在编译后的字节码中保留，但在运行时无法通过反射机制获取到，从而无法在运行时基于该注解进行一些动态的处理和决策。例如，如果您希望在运行时通过反射获取注解信息来执行不同的逻辑，由于注解未被保留到运行时，就无法实现这样的功能

看见没，@Retention(RetentionPolicy.RUNTIME)反射

例如，如果一个自定义注解使用了 @Retention(RetentionPolicy.RUNTIME) ，那么在运行时可以通过以下方式获取：

Class<?> clazz = SomeClass.class;
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
    HasPermissions annotation = method.getAnnotation(HasPermissions.class);
    if (annotation!= null) {
        // 处理注解的信息
    }
}

 这样，就能够在运行时根据注解的存在和其包含的信息来决定程序的行为。

扯远了

咱们继续看权限认证的代码

public @interface Authenticated { // 可以添加一些属性，例如权限级别等 }

这是一个自定义注解 Authenticated 的定义。在这个注解中，您可以添加一些属性来提供更多的信息和灵活性。其中，@interface 是 Java 中用于定义注解（Annotation）的关键字。注解是一种特殊的类，它为程序元素（如类、方法、变量等）添加元数据（metadata）。通过注解，可以为代码添加一些额外的信息，然后在程序运行时或者通过特定的框架和工具来读取和处理这些信息，以实现各种功能，例如自动配置、权限控制、日志记录等。

例如，如果您想要添加一个表示权限级别的属性，可以这样做：

@Authenticated(level = 1)
public void someMethod() {
    // 方法体
}

然后在处理这个注解的 AOP 切面或者其他相关逻辑中，就可以获取并使用这个权限级别属性的值来进行更细致的认证授权判断。

自定义注解自定义完了，接下来就是AOP了

接下来，创建一个切面类来处理认证授权逻辑：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class AuthenticationAspect {

    @Around("@annotation(Authenticated)")
    public Object authenticate(ProceedingJoinPoint joinPoint) throws Throwable {
        // 在此处实现认证授权逻辑
        // 例如，检查用户是否登录，是否具有足够的权限等
        boolean isAuthenticated = true; // 模拟认证成功

        if (isAuthenticated) {
            return joinPoint.proceed();
        } else {
            throw new RuntimeException("认证失败，无权访问");
        }
    }
}

解析：

@Aspect 是在面向切面编程（AOP）中使用的一个注解。

当一个类被标注为 @Aspect 时，表明这个类是一个切面类，其中定义的方法可以包含各种通知（Advice），例如 @Before（前置通知）、@After（后置通知）、@Around（环绕通知）等，用于在目标方法执行的特定时机执行切面中的逻辑。

通过使用 @Aspect 注解，可以将与核心业务逻辑无关的横切关注点（如日志记录、事务管理、权限检查等）从业务代码中分离出来，提高代码的模块化和可维护性。

在 Spring AOP 中，`@Before`（前置通知）、`@After`（后置通知）、`@AfterReturning`（返回通知）和`@Around`（环绕通知）这四种通知的区别主要体现在它们执行的时机和功能上，具体区别如下：

- **`@Before`（前置通知）**：在目标方法执行之前执行。如果在此回调方法中抛出异常，则目标方法不会再执行，但会继续执行后置通知和异常通知。它可以用于在目标方法执行前进行一些准备工作，如参数校验、日志记录等。

- **`@After`（后置通知）**：在目标方法（切入点）执行之后执行，无论目标方法是否正常返回或抛出异常都会执行。通常用于进行资源清理、记录方法结束等操作。

- **`@AfterReturning`（返回通知）**：在目标方法（切入点）返回结果之后执行。需要注意的是，如果目标方法抛出了异常，将不会执行返回通知，而是直接跳转到异常通知（`@AfterThrowing`）。它可用于对目标方法的返回结果进行处理或后续的操作。

- **`@Around`（环绕通知）**：目标方法执行前后分别执行一些代码，类似拦截器，可以控制目标方法是否继续执行。它能够在目标方法执行前后织入增强动作，可以决定目标方法在什么时候执行、如何执行，甚至完全阻止目标方法的执行；也可以改变执行目标方法的参数值和返回值。环绕通知常用于统计方法耗时、进行参数校验、处理事务等操作。

环绕通知的执行流程较为复杂，正常流程为：【环绕通知-前】->【前置通知】->【目标方法执行】->【返回通知】->【后置通知】->【环绕通知-后】。如果在环绕通知中不调用`proceed()`方法来执行目标方法，则只会执行环绕通知中【环绕通知-前】的部分（等价于`@Before`）。

知识点就是反复的提起来，反复的回忆基础：

那么我举出一个在AOP中@Before`（前置通知）**：在目标方法执行之前执行自定义逻辑的代码回忆一下：

 @Before（前置通知）中可以执行那些自定义的代码逻辑？

1. 参数验证：检查传入目标方法的参数是否符合特定的规则和条件。
2. 日志记录：记录关于即将执行的目标方法的相关信息，比如方法名称、参数值等。
3. 权限检查：确定当前执行上下文是否有权限执行目标方法。
4. 初始化或设置一些上下文信息：为目标方法的执行准备必要的环境或数据。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class PreAdviceExample {

    @Before("execution(public void someMethod(int))")
    public void beforeSomeMethod(JoinPoint joinPoint) {
        int parameter = (int) joinPoint.getArgs()[0];
        if (parameter < 0) {
            throw new IllegalArgumentException("参数不能为负数");
        }
    }
}

在上述示例中，当执行 someMethod 方法且参数为整数时，会先进入前置通知进行参数是否为负数的检查。

这4种注解，每一个注解适合的地方不一样，有空再研究吧

总的来说，这四种通知注解提供了不同的时机来插入额外的逻辑，以便实现横切关注点的分离，使代码更加模块化和可维护。开发人员可以根据具体的需求选择合适的通知注解来增强目标方法的行为。在实际使用中，需要根据业务场景和需求来决定使用哪种通知，或者结合多种通知来实现更复杂的功能。例如，前置通知和后置通知常用于简单的日志记录或资源管理，而环绕通知则更适合需要全面控制目标方法执行流程的情况，如事务管理、性能监控等。同时，返回通知可以在目标方法正常返回后进行特定的处理。

接着往下分析：

@Component 是 Spring 框架中的一个注解，用于将一个普通的 Java 类标记为 Spring 管理的组件。

当一个类被标注为 @Component 后，Spring 容器会在启动时自动扫描并实例化这个类，并将其纳入 Spring 的管理范围，以便进行依赖注入、生命周期管理等操作。

除了 @Component ，Spring 还提供了一些更具针对性的衍生注解，如 @Service（用于服务层）、@Repository（用于数据访问层）、@Controller（用于 Web 控制器），它们的功能与 @Component 类似，但在语义上更明确地表示了组件的类型和用途。

接着往下分析：

public class AuthenticationAspect {

    @Around("@annotation(Authenticated)")
    public Object authenticate(ProceedingJoinPoint joinPoint) throws Throwable {
        // 在此处实现认证授权逻辑
        // 例如，检查用户是否登录，是否具有足够的权限等
        boolean isAuthenticated = true; // 模拟认证成功

        if (isAuthenticated) {
            return joinPoint.proceed();
        } else {
            throw new RuntimeException("认证失败，无权访问");
        }
    }
}

这段代码定义了一个名为 AuthenticationAspect 的类，其中包含一个使用 @Around 注解的方法 authenticate 。

@Around("@annotation(Authenticated)") 表示这个方法会环绕（在目标方法执行前后）处理被 @Authenticated 注解标注的方法。

在 authenticate 方法内部，实现了认证授权的逻辑。通过一个模拟的变量 isAuthenticated 来表示认证是否成功。如果认证成功，通过 joinPoint.proceed() 执行被环绕的目标方法并返回其结果；如果认证失败，则抛出一个运行时异常表示无权访问。

• @Around：这是 Spring AOP 中的一个注解，用于定义环绕通知。环绕通知可以在目标方法执行前后执行自定义的逻辑，并且可以控制目标方法是否执行、执行的时机以及如何执行等。它具有很强的灵活性，可以完全控制方法的执行流程。
• "@annotation(Authenticated)"：这是一个切点表达式，表示匹配被 @Authenticated 注解标注的方法。只有当执行带有 @Authenticated 注解的方法时，环绕通知才会生效

然后，在需要进行认证授权的方法上添加自定义注解：

public class YourService {

    @Authenticated
    public void someMethod() {
        // 被保护的方法逻辑
        System.out.println("有权限访问此方法");
    }
}

在上述示例中，当执行带有 `@Authenticated` 注解的方法时，会先进入切面的 `authenticate` 方法进行认证授权的判断，如果认证成功则执行方法，否则抛出异常。实际应用中，您需要根据具体的认证授权需求来完善认证逻辑。

最后回头来看：

1. 自定义注解的定义：

   import java.lang.annotation.Retention;
   import java.lang.annotation.RetentionPolicy;
   
   @Retention(RetentionPolicy.RUNTIME)
   public @interface Authenticated {
       // 可以添加一些属性，例如权限级别等
   }

   这段代码定义了一个名为 Authenticated 的自定义注解。通过 @Retention(RetentionPolicy.RUNTIME) 确保该注解在运行时可被获取和处理。

2. 切面类 AuthenticationAspect ：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class AuthenticationAspect {

    @Around("@annotation(Authenticated)")
    public Object authenticate(ProceedingJoinPoint joinPoint) throws Throwable {
        // 在此处实现认证授权逻辑
        // 例如，检查用户是否登录，是否具有足够的权限等
        boolean isAuthenticated = true; // 模拟认证成功

        if (isAuthenticated) {
            return joinPoint.proceed();
        } else {
            throw new RuntimeException("认证失败，无权访问");
        }
    }
}

 这个类是一个切面，用于处理认证授权的逻辑。@Aspect 表明这是一个切面类，@Component 使得该类能被 Spring 容器管理。@Around("@annotation(Authenticated)") 注解的方法 authenticate 会在被 @Authenticated 注解标记的方法执行前后进行拦截，并在其中实现具体的认证授权判断逻辑。

3.YourService 类：

public class YourService {

    @Authenticated
    public void someMethod() {
        // 被保护的方法逻辑
        System.out.println("有权限访问此方法");
    }
}

 在这个类中的 someMethod 方法使用了 @Authenticated 注解，表明该方法需要经过认证授权才能执行。当调用这个方法时，会触发前面定义的切面中的认证授权逻辑。

这是一个简单的实例，明天打算用一个实际开发中的源代码解析记录一下