Spring Rest端点动态权限配置：如何替换硬编码@PreAuthorize实现？

当然可以！Spring Security提供了多种方案来摆脱@PreAuthorize的硬编码权限，让你从数据库或配置文件这类外部源加载权限配置，我给你整理几个实用的实现思路：

方案一：自定义权限表达式处理器（最灵活） #

这种方式可以完全自定义@PreAuthorize的校验逻辑，把权限判断的逻辑从硬编码转移到外部数据源。

步骤： #

1. 实现自定义的MethodSecurityExpressionHandler，继承Spring默认的DefaultMethodSecurityExpressionHandler，在里面注入你的权限查询服务（比如数据库DAO）。
2. 重写createEvaluationContext方法，解析当前接口的标识（比如RequestMapping的路径），然后从外部加载对应的权限，再注入自定义的校验函数。
3. 在全局方法安全配置类中注册这个自定义处理器。

代码示例： #

首先是自定义表达式处理器：

@Component
public class CustomMethodSecurityExpressionHandler extends DefaultMethodSecurityExpressionHandler {
    private final PermissionRepository permissionRepo;

    // 构造注入权限查询的Repository
    public CustomMethodSecurityExpressionHandler(PermissionRepository permissionRepo) {
        this.permissionRepo = permissionRepo;
    }

    @Override
    public EvaluationContext createEvaluationContext(Authentication auth, MethodInvocation invocation) {
        StandardEvaluationContext context = (StandardEvaluationContext) super.createEvaluationContext(auth, invocation);
        
        // 从当前方法的RequestMapping注解里拿到接口路径
        String endpoint = extractEndpointFromMethod(invocation.getMethod());
        if (endpoint == null) {
            return context;
        }
        
        // 从数据库加载该接口对应的权限列表
        Set<String> requiredPermissions = permissionRepo.findPermissionsByEndpoint(endpoint);
        
        // 把自定义的权限校验逻辑注入到Spring EL上下文里
        context.setVariable("hasDynamicPermission", new DynamicPermissionChecker(requiredPermissions, auth));
        return context;
    }

    // 辅助方法：解析方法上的RequestMapping路径
    private String extractEndpointFromMethod(Method method) {
        RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
        if (requestMapping != null && requestMapping.value().length > 0) {
            return requestMapping.value()[0];
        }
        // 也可以处理GetMapping/PostMapping等派生注解
        PostMapping postMapping = method.getAnnotation(PostMapping.class);
        if (postMapping != null && postMapping.value().length > 0) {
            return postMapping.value()[0];
        }
        return null;
    }

    // 内部类：封装权限校验逻辑
    private static class DynamicPermissionChecker implements Supplier<Boolean> {
        private final Set<String> requiredPermissions;
        private final Authentication auth;

        public DynamicPermissionChecker(Set<String> requiredPermissions, Authentication auth) {
            this.requiredPermissions = requiredPermissions;
            this.auth = auth;
        }

        @Override
        public Boolean get() {
            // 判断当前用户的权限是否包含所需的任一权限
            return auth.getAuthorities().stream()
                    .map(GrantedAuthority::getAuthority)
                    .anyMatch(requiredPermissions::contains);
        }
    }
}

然后注册这个处理器到全局方法安全配置：

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {
    private final CustomMethodSecurityExpressionHandler customHandler;

    public MethodSecurityConfig(CustomMethodSecurityExpressionHandler customHandler) {
        this.customHandler = customHandler;
    }

    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        return customHandler;
    }
}

最后在接口上使用自定义的表达式：

@PreAuthorize("hasDynamicPermission()")
@RequestMapping(value = "/xxxx", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
public ResponseEntity<?> method(@RequestBody RequestClass request) {
    // 你的接口业务逻辑
}

方案二：完全基于数据库的SecurityFilterChain（无注解） #

如果不想用@PreAuthorize注解，可以直接在Spring Security的过滤器链中动态加载所有接口的权限配置，完全摆脱代码中的权限硬编码。

实现思路： #

1. 启动时从数据库读取所有接口的权限映射（比如接口路径、请求方法、所需权限）。
2. 把这些映射转换成Spring Security的请求匹配器和权限规则，添加到SecurityFilterChain中。
3. 如果需要热更新权限，可以加个定时任务或者事件监听来刷新过滤器链。

代码示例： #

@Configuration
public class SecurityConfig {
    private final PermissionRepository permissionRepo;

    public SecurityConfig(PermissionRepository permissionRepo) {
        this.permissionRepo = permissionRepo;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(auth -> {
            // 从数据库加载所有接口的权限配置
            List<EndpointPermission> endpointPermissions = permissionRepo.findAll();
            
            for (EndpointPermission perm : endpointPermissions) {
                // 为每个接口配置对应的权限要求
                auth.requestMatchers(HttpMethod.valueOf(perm.getRequestMethod()), perm.getEndpoint())
                        .hasAnyAuthority(perm.getRequiredPermissions().toArray(new String[0]));
            }
            
            // 其他接口默认需要认证
            auth.anyRequest().authenticated();
        });
        
        // 这里可以添加其他Security配置，比如登录、CSRF等
        return http.build();
    }
}

方案三：Spring EL调用自定义服务（最简单） #

如果不想修改框架底层逻辑，这是最快的实现方式：直接在@PreAuthorize的表达式里调用一个自定义的权限校验服务，这个服务内部从外部源读取权限配置。

代码示例： #

首先定义一个权限校验服务：

@Component("permissionService")
public class PermissionService {
    private final PermissionRepository permissionRepo;

    public PermissionService(PermissionRepository permissionRepo) {
        this.permissionRepo = permissionRepo;
    }

    public boolean hasAccess(String endpoint, Authentication auth) {
        // 从数据库加载该接口所需的权限
        Set<String> requiredPermissions = permissionRepo.findPermissionsByEndpoint(endpoint);
        
        // 校验用户权限是否匹配
        return auth.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .anyMatch(requiredPermissions::contains);
    }
}

然后在接口上使用：

@PreAuthorize("@permissionService.hasAccess('/xxxx', authentication)")
@RequestMapping(value = "/xxxx", method = RequestMethod.POST, consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
public ResponseEntity<?> method(@RequestBody RequestClass request) {
    // 你的接口逻辑
}

这种方式虽然还是需要在注解里写接口路径，但权限规则是从外部加载的，比硬编码权限灵活很多。

内容的提问来源于stack exchange，提问作者TheOni