【Spring】使用自定义注解方式实现AOP鉴权

AOP,是一种面向切面编程,可以通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

在软件开发中,鉴权(Authentication)是一项非常重要的安全措施,用于验证用户身份和权限。在应用程序中,我们通常会使用AOP(Aspect-Oriented Programming)来实现鉴权功能,以便在需要进行鉴权的地方进行统一的处理。

一种常用的实现AOP鉴权的方式是使用自定义注解。通过定义一个自定义注解,并在需要进行鉴权的方法上加上该注解,我们可以在运行时通过AOP切面来拦截方法调用,并进行鉴权操作。

第一种实现逻辑

首先,我们需要定义一个自定义注解,用于标识需要进行鉴权的方法。可以使用Java的注解机制来实现,如下所示:

java 复制代码
import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
  
@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
public @interface Authenticated {  
    String[] roles() default {};  
}  

在上面的代码中,我们定义了一个名为Authenticated的注解,并指定了它的作用目标为方法。Authenticated注解还包含了一个可选的roles属性,用于指定允许访问该方法的用户角色。

接下来,我们需要编写一个AOP切面来实现鉴权逻辑。可以使用Spring框架提供的@Aspect注解来定义一个切面类,并使用@Around注解来实现方法拦截和鉴权逻辑,如下所示:

java 复制代码
import org.aspectj.lang.JoinPoint;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.springframework.security.core.Authentication;  
import org.springframework.security.core.context.SecurityContextHolder;  
import org.springframework.stereotype.Component;  
  
@Aspect  
@Component  
public class AuthorizationAspect {  
  
    @Around("@annotation(authenticated)")  
    public Object authenticate(ProceedingJoinPoint joinPoint, Authenticated authenticated) throws Throwable {  
        // 获取当前用户的角色  
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();  
        String[] userRoles = authentication.getAuthorities().stream().map(Object::toString).toArray(String[]::new);  
  
        // 获取方法需要的角色  
        String[] requiredRoles = authenticated.roles();  
  
        // 鉴权逻辑  
        boolean authorized = false;  
        for (String requiredRole : requiredRoles) {  
            for (String userRole : userRoles) {  
                if (userRole.equals(requiredRole)) {  
                    authorized = true;  
                    break;  
                }  
            }  
        }  
  
        // 如果鉴权通过,则继续执行原方法,否则抛出鉴权异常  
        if (authorized) {  
            return joinPoint.proceed();  
        } else {  
            throw new AuthorizationException("Access denied");  
        }  
    }  
}  

在上面的代码中,我们定义了一个名为AuthorizationAspect的切面类,并使用@Around注解来标识需要拦截的方法。在authenticate方法中,我们首先获取当前用户的角色,然后与方法需要的角色进行比较,判断是否有权限访问该方法。

最后,我们在需要进行鉴权的方法上加上@Authenticated注解,并指定允许访问该方法的用户角色,如下所示:

java 复制代码
@Authenticated(roles = {"admin", "user"})  
public void someMethod() {  
    // 需要鉴权的方法逻辑  
} 

通过上述步骤,我们就实现了使用自定义注解方式来实现AOP鉴权。在运行时,AOP切面会拦截带有@Authenticated注解的方法调用,并进行鉴权操作。如果鉴权通过,则继续执行原方法,否则抛出鉴权异常。

第二种实现逻辑

新建一个注解类

java 复制代码
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PermissionAnnotation {
    String id() default "";
    String name() default "";
}

新建切面类

java 复制代码
@Aspect
@Component
public class PermissionAspect {

	@Pointcut("@annotation(xxx.xxx.xxx.PermissionAnnotation)")
    public void permissionPointCut() {
        // Do nothing because of it's a pointcut
    }

    @Around("permissionPointCut()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        MethodSignature sign = (MethodSignature) proceedingJoinPoint.getSignature();
        Method method = sign.getMethod();
        PermissionAnnotation annotation = method.getAnnotation(PermissionAnnotation.class);
      String id= annotation.id();
      String name= annotation.name();
        if (checkPermission(id, name)) {
            // 有权限,业务方法执行
            Object result = proceedingJoinPoint.proceed();
            // 业务方法执行完可进行额外操作
            
        } else {
            // 没有权限
        }
    }
	private boolean checkPermission() {
        // 权限判断
        if (xxx) {
        return true;
        }
        return false;
    }
}

业务方法使用

java 复制代码
@Override
@PermissionAnnotation(id= "${id}")
public void deleteUser(String id) {
    //业务代码
}

其实这俩种实现逻辑基于的原理是一样的,就是看实际应用需要的是何种形式,当然也会有第三种第四种...

总结起来,使用自定义注解方式实现AOP鉴权可以提高代码的可读性和可维护性

相关推荐
橘猫云计算机设计1 小时前
基于Springboot的自习室预约系统的设计与实现(源码+lw+部署文档+讲解),源码可白嫖!
java·spring boot·后端·毕业设计
秋书一叶2 小时前
SpringBoot项目打包为window安装包
java·spring boot·后端
碎梦归途2 小时前
23种设计模式-结构型模式之外观模式(Java版本)
java·开发语言·jvm·设计模式·intellij-idea·外观模式
极客先躯2 小时前
高级java每日一道面试题-2025年4月13日-微服务篇[Nacos篇]-Nacos如何处理网络分区情况下的服务可用性问题?
java·服务器·网络·微服务·nacos·高级面试
pwzs2 小时前
Spring MVC 执行流程全解析:从请求到响应的七步走
java·后端·spring·spring mvc
我该如何取个名字3 小时前
Mac配置Java的环境变量
java·开发语言·macos
kkkkatoq3 小时前
Java中的锁
java·开发语言
界面开发小八哥3 小时前
「Java EE开发指南」用MyEclipse开发EJB 3无状态会话Bean(二)
java·ide·java-ee·eclipse·myeclipse
LCY1333 小时前
spring security +kotlin 实现oauth2.0 认证
java·spring·kotlin
soulermax4 小时前
数字ic后端设计从入门到精通2(含fusion compiler, tcl教学)
java·linux·服务器