如何在Spring Security中使用复杂对象作为权限且无需实现自定义AccessDecisionManager？

没问题！完全不用自定义AccessDecisionManager就能在Spring Security里处理复杂权限对象。框架本身提供了不少灵活的扩展点，能让你复用现有的SpEL支持和默认投票机制，没必要重新造轮子。下面给你几个实用的方案：

方案1：自定义SpEL权限表达式组件 #

你可以创建一个自定义的Spring组件，封装复杂权限的判断逻辑，然后在@PreAuthorize或@PostAuthorize注解里通过SpEL直接调用这个组件的方法。这种方式灵活度很高，完全贴合你的业务权限规则。

步骤1：创建自定义权限判断组件 #

@Component("customSecurity")
public class CustomSecurityChecker {

    /**
     * 判断当前用户是否拥有指定资源+操作的权限
     */
    public boolean hasPermission(String resource, String action) {
        // 从SecurityContext获取当前登录用户的认证信息
        Authentication auth = SecurityContextHolder.getContext().getAuthentication();
        if (auth == null || !auth.isAuthenticated()) {
            return false;
        }

        // 遍历用户的权限集合，匹配复杂权限对象
        return auth.getAuthorities().stream()
                .filter(authority -> authority instanceof ComplexPermission)
                .map(ComplexPermission.class::cast)
                .anyMatch(perm -> perm.getResource().equals(resource) 
                        && perm.getAction().equals(action)
                        // 这里可以添加更多复杂判断逻辑，比如租户、资源ID等
                        && perm.getTenantId().equals(getCurrentTenantId()));
    }

    // 辅助方法：获取当前租户ID（示例）
    private String getCurrentTenantId() {
        // 这里可以根据你的业务逻辑获取租户ID，比如从请求头、ThreadLocal等
        return "tenant_001";
    }
}

步骤2：在业务方法中使用 #

@Service
public class OrderService {

    // 调用自定义组件的方法进行权限校验
    @PreAuthorize("@customSecurity.hasPermission('ORDER', 'UPDATE')")
    public void updateOrder(Order order) {
        // 业务逻辑代码
    }
}

注意点 #

• 你的复杂权限对象ComplexPermission需要实现GrantedAuthority接口，不过只需要实现getAuthority()方法即可，这个方法的返回值可以是一个唯一标识（比如resource:action:tenant），或者甚至返回空字符串（不推荐，但不影响自定义逻辑的执行）。

方案2：利用内置的PermissionEvaluator接口 #

Spring Security内置了PermissionEvaluator接口，专门用于处理细粒度的权限判断。实现这个接口后，你可以直接在SpEL中使用hasPermission()表达式，完全复用默认的方法安全机制。

步骤1：实现PermissionEvaluator #

@Component
public class CustomPermissionEvaluator implements PermissionEvaluator {

    /**
     * 针对业务对象的权限判断
     * @param authentication 当前用户认证信息
     * @param targetDomainObject 要操作的业务对象（比如Order）
     * @param permission 要执行的操作（比如"UPDATE"）
     */
    @Override
    public boolean hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
        if (authentication == null || !(permission instanceof String) || !(targetDomainObject instanceof Order)) {
            return false;
        }

        String action = (String) permission;
        Order order = (Order) targetDomainObject;

        // 匹配复杂权限
        return authentication.getAuthorities().stream()
                .filter(auth -> auth instanceof ComplexPermission)
                .map(ComplexPermission.class::cast)
                .anyMatch(perm -> perm.getResource().equals("ORDER")
                        && perm.getAction().equals(action)
                        && perm.getTenantId().equals(order.getTenantId())
                        && perm.getResourceId().equals(order.getId().toString()));
    }

    /**
     * 针对资源ID和类型的权限判断（适合没有业务对象实例的场景）
     */
    @Override
    public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
        if (authentication == null || !(permission instanceof String)) {
            return false;
        }

        String action = (String) permission;
        // 这里可以根据targetType和targetId查询资源信息，再进行权限匹配
        // 示例逻辑：
        return authentication.getAuthorities().stream()
                .filter(auth -> auth instanceof ComplexPermission)
                .map(ComplexPermission.class::cast)
                .anyMatch(perm -> perm.getResource().equals(targetType)
                        && perm.getAction().equals(action)
                        && perm.getResourceId().equals(targetId.toString()));
    }
}

步骤2：配置全局方法安全 #

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig extends GlobalMethodSecurityConfiguration {

    @Autowired
    private CustomPermissionEvaluator permissionEvaluator;

    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        DefaultMethodSecurityExpressionHandler handler = new DefaultMethodSecurityExpressionHandler();
        // 注册自定义的PermissionEvaluator
        handler.setPermissionEvaluator(permissionEvaluator);
        return handler;
    }
}

步骤3：在业务方法中使用 #

@Service
public class OrderService {

    // 针对业务对象的权限校验
    @PreAuthorize("hasPermission(#order, 'UPDATE')")
    public void updateOrder(Order order) {
        // 业务逻辑
    }

    // 针对资源ID和类型的权限校验
    @PreAuthorize("hasPermission(#orderId, 'ORDER', 'DELETE')")
    public void deleteOrder(Long orderId) {
        // 业务逻辑
    }
}

方案3：将复杂权限转为字符串标识（极简方案） #

如果你的复杂权限可以通过组合属性生成唯一的字符串，也可以让权限对象实现GrantedAuthority，并在getAuthority()方法中返回这个组合字符串，这样就能直接使用默认的hasAuthority()或hasAnyAuthority()表达式，完全不需要自定义任何扩展组件。

示例代码 #

public class ComplexPermission implements GrantedAuthority {
    private String resource;
    private String action;
    private String tenantId;

    // 构造器、getter、setter

    @Override
    public String getAuthority() {
        // 生成唯一的权限字符串
        return String.format("PERM_%s_%s_%s", resource.toUpperCase(), action.toUpperCase(), tenantId);
    }
}

使用方式 #

@Service
public class OrderService {

    @PreAuthorize("hasAuthority('PERM_ORDER_UPDATE_TENANT_001')")
    public void updateOrder(Order order) {
        // 业务逻辑
    }
}

这种方式适合权限规则相对固定的场景，优点是完全不需要额外配置，缺点是权限字符串会比较冗长，且不够灵活。

以上三种方案都不需要自定义AccessDecisionManager，都是基于Spring Security的原生扩展点实现，完美复用了框架自带的SpEL支持和投票机制，避免了重新实现的麻烦。

内容的提问来源于stack exchange，提问作者pera.coyote