详解如何在Spring Security中自定义权限表达式

一、Spring Security自定义权限表达式概述

在Spring Security中，我们可以使用表达式来描述权限，这些表达式通常包含在配置文件或者注解中。然而，Spring Security默认的权限表达式并不一定能够满足我们的需求，因此我们可能需要自定义权限表达式。

要使用自定义的权限表达式，我们需要进行以下两步：

1. 自定义Security Expression

我们需要继承SecurityExpression类，并实现evaluate方法。这个方法的返回值表示是否拥有权限。

1. 注册自定义Security Expression

我们需要将自定义的Security Expression注册到Spring Security的表达式处理器中。

二、自定义Security Expression示例

下面给出两个实际的自定义Security Expression示例。

1. 基于权限点的访问控制

我们可以基于权限点来进行访问控制，这样更加细粒度化。

首先，我们需要定义一个Permission类：

public class Permission {

    private String code;

    public Permission(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

然后，我们继承SecurityExpression类实现自定义Security Expression：

public class PermissionExpression implements SecurityExpression {

    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final PermissionEvaluator permissionEvaluator;

    private final Authentication authentication;

    private Permission permission;

    public PermissionExpression(PermissionEvaluator permissionEvaluator,
                                 Authentication authentication, Permission permission) {
        this.permissionEvaluator = permissionEvaluator;
        this.authentication = authentication;
        this.permission = permission;
    }

    @Override
    public boolean evaluate(WebExpressionContext ctx) throws EvaluationException {
        if (authentication == null) {
            return false;
        }
        try {
            return permissionEvaluator.hasPermission(authentication, null, permission);
        } catch (Exception e) {
            logger.error("error occurs while evaluate permission expression", e);
        }
        return false;
    }

    @Override
    public String toString() {
        return "hasPermission(#" + permission.code + ")";
    }
}

上面的Security Expression使用了PermissionEvaluator来判断认证用户是否拥有指定的权限点，我们需要先定义一个自定义的PermissionEvaluator：

@Component
public class CustomPermissionEvaluator implements PermissionEvaluator {

    @Override
    public boolean hasPermission(Authentication authentication, 
                                  Object targetDomainObject, Object permissionObject) {
        if (targetDomainObject == null || permissionObject == null) {
            // 参数为空，返回无权限
            return false;
        }
        Permission permission = (Permission) permissionObject;

        // 开发人员需要根据具体的业务逻辑进行判断
        boolean hasPermission = false;

        // TODO: 根据业务逻辑判断是否有权限

        return hasPermission;
    }

    @Override
    public boolean hasPermission(Authentication authentication, Serializable targetId, 
                                  String targetType, Object permissionObject) {
        throw new UnsupportedOperationException();
    }
}

接着，我们需要将自定义的Security Expression注册到Spring Security的表达式处理器中：

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

    @Autowired
    private PermissionEvaluator permissionEvaluator;

    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        DefaultMethodSecurityExpressionHandler handler = new DefaultMethodSecurityExpressionHandler();
        handler.setPermissionEvaluator(permissionEvaluator);
        return handler;
    }
}

现在我们就可以进行基于权限点的访问控制了。例如，我们可以在Controller方法中使用以下注解：

@PreAuthorize("hasPermission(#permission, 'read')")
public ResponseEntity<?> query(@RequestParam("permission") Permission permission) {
    // TODO: 根据业务逻辑处理查询请求
}

1. 基于自定义属性的访问控制

我们可以基于自定义的对象属性（例如用户）来进行访问控制。

首先，我们需要为用户定义一个自定义的属性：

public class CustomUser {

    private String id;

    private String name;

    private List<String> roles;

    public CustomUser(String id, String name) {
        this.id = id;
        this.name = name;
        this.roles = new ArrayList<>();
    }

    public void addRole(String role) {
        this.roles.add(role);
    }

    public List<String> getRoles() {
        return roles;
    }

    public void setRoles(List<String> roles) {
        this.roles = roles;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

然后，我们继承SecurityExpression类实现自定义Security Expression：

public class HasRoleExpression implements SecurityExpression {

    private List<String> roles;

    private String id;

    public HasRoleExpression(String id, List<String> roles) {
        this.id = id;
        this.roles = roles;
    }

    @Override
    public boolean evaluate(WebExpressionContext ctx) throws EvaluationException {
        Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        if (principal != null && principal instanceof CustomUser) {
            CustomUser user = (CustomUser) principal;
            if (user.getId().equals(id)) {
                // 如果用户ID和传入的ID匹配，则判断用户角色
                for (String role : roles) {
                    if (user.getRoles().contains(role)) {
                        return true;
                    }
                }
            }
        } 
        return false;
    }

    @Override
    public String toString() {
        return "hasRole('" + id + "', " + roles + ")";
    }
}

现在我们可以在Controller方法中使用以下注解：

@PreAuthorize("hasRole(#id, {'ROLE_ADMIN', 'ROLE_USER'})")
public ResponseEntity<?> query(@RequestParam String id) {
    // TODO: 根据业务逻辑处理查询请求
}

三、总结

自定义Spring Security的权限表达式可以让我们更加灵活地进行访问控制。需要注意的是，自定义表达式要遵循Spring Security表达式语言的语法格式，并且需要将其正确地注册到Spring Security框架中。在实际应用中，我们应该结合具体的业务场景来设计自定义权限表达式。